[IBAL] Change CEP DREP API
[mirror/winof/.git] / inc / iba / ib_al_ioctl.h
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Copyright (c) 1996-2003 Intel 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 \r
35 #ifndef __IB_UAL_IOCTL_H__\r
36 #define __IB_UAL_IOCTL_H__\r
37 \r
38 #include <complib/cl_types.h>\r
39 #include <iba/ib_types.h>\r
40 #include <iba/ib_ci.h>\r
41 #include <iba/ib_al.h>\r
42 \r
43 \r
44 \r
45 /*\r
46 * Typedefs\r
47 *\r
48 */\r
49 /*\r
50 * ual_close_ca_ioctl:\r
51 * NOTES:\r
52 * It is sufficient to pass the ca handle to the kernel proxy on close_ca\r
53 * The UAL context for this CA instance maintains the application callback\r
54 * So, when the proxy notifies for a close_ca_callback, we know which\r
55 * app callback to call\r
56 *\r
57 */\r
58 \r
59 \r
60 /****s* User-mode Access Layer/ual_bind_file_ioctl_t\r
61 * NAME\r
62 *       ual_bind_file_ioctl_t\r
63 *\r
64 * DESCRIPTION\r
65 *       IOCTL structure containing the input and output parameters for\r
66 *       binding a file handle to an existing proxy context.\r
67 *\r
68 * SYNOPSIS\r
69 */\r
70 typedef struct _ual_bind_file_ioctl\r
71 {\r
72         TO_LONG_PTR(void* ,                     h_file) ;\r
73 \r
74 }       ual_bind_file_ioctl_t;\r
75 /*\r
76 * FIELDS\r
77 *       h_file\r
78 *               File handle from the user-mode process intended for asynchronous requests.\r
79 *               The IOCTL code will specify the type of asynchronous requests to be\r
80 *               performed on this file handle.\r
81 *\r
82 * SEE ALSO\r
83 *\r
84 * NOTES\r
85 *****/\r
86 \r
87 \r
88 /****s* User-mode Access Layer/ual_get_uvp_name_t\r
89 * NAME\r
90 *       ual_get_uvp_name_t\r
91 *\r
92 * DESCRIPTION\r
93 *       IOCTL structure containing the input and output parameters for\r
94 *       getting the user library information.\r
95 *\r
96 * SYNOPSIS\r
97 */\r
98 typedef union _ual_get_uvp_name\r
99 {\r
100         struct _ual_get_uvp_name_in\r
101         {\r
102                 ib_net64_t                              ca_guid;\r
103 \r
104         }       in;\r
105         struct _ual_get_uvp_name_out\r
106         {\r
107                 ib_api_status_t                 status;\r
108                 char                                    uvp_lib_name[MAX_LIB_NAME];\r
109 \r
110         }       out;\r
111 \r
112 }       ual_get_uvp_name_ioctl_t;\r
113 /*\r
114 * FIELDS\r
115 *       in.ca_guid\r
116 *               The GUID of the channel adapter\r
117 *\r
118 *       out.status\r
119 *               Status of the operation\r
120 *\r
121 *       out.uvp_lib_name\r
122 *               The vendor's library name associated with the CA\r
123 *\r
124 * SEE ALSO\r
125 *\r
126 *\r
127 * NOTES\r
128 *****/\r
129 \r
130 \r
131 \r
132 /****s* User-mode Access Layer/ual_open_ca_ioctl_t\r
133 * NAME\r
134 *       ual_open_ca_ioctl_t\r
135 *\r
136 * DESCRIPTION\r
137 *       IOCTL structure containing the input and output parameters for\r
138 *       ib_open_ca\r
139 *\r
140 * SYNOPSIS\r
141 */\r
142 typedef union _ual_open_ca_ioctl\r
143 {\r
144         struct _ual_open_ca_ioctl_in\r
145         {\r
146                 ci_umv_buf_t                            umv_buf;\r
147                 ib_net64_t                                      guid;\r
148                 TO_LONG_PTR(void* ,                             context) ;\r
149 \r
150         }       in;\r
151 \r
152         struct _ual_open_ca_ioctl_out\r
153         {\r
154                 ci_umv_buf_t                            umv_buf;\r
155                 ib_api_status_t                         status;\r
156                 uint64_t                                        h_ca;\r
157 \r
158         }       out;\r
159 \r
160 }       ual_open_ca_ioctl_t;\r
161 /*\r
162 * FIELDS\r
163 *       in.umv_buf\r
164 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
165 *               exchange private information with the kernel-mode HCA driver.\r
166 *\r
167 *       in.guid\r
168 *               The GUID of the channel adapter to open.\r
169 *\r
170 *       in.context\r
171 *               A caller-specified context to associate with this opened instance\r
172 *               of the channel adapter.  This context is returned to the user when\r
173 *               invoking asynchronous callbacks referencing this channel adapter.\r
174 *\r
175 *       out.umv_buf\r
176 *               Returns the status from the HCA driver to the user-mode HCA library,\r
177 *               along with any vendor specific output information.\r
178 *\r
179 *       out.status\r
180 *               Status of the operation\r
181 *\r
182 *       out.h_ca\r
183 *               On return from IOCTL, contains the CA Handle from AL.\r
184 *****/\r
185 \r
186 \r
187 \r
188 /****s* User-mode Access Layer/ual_query_ca_ioctl_t\r
189 * NAME\r
190 *       ual_query_ca_ioctl_t\r
191 *\r
192 * DESCRIPTION\r
193 *       IOCTL structure containing the input and output parameters for\r
194 *       ib_query_ca\r
195 *\r
196 * SYNOPSIS\r
197 */\r
198 typedef union _ual_query_ca_ioctl\r
199 {\r
200         struct _ual_query_ca_ioctl_in\r
201         {\r
202                 ci_umv_buf_t                            umv_buf;\r
203                 uint64_t                                        h_ca;\r
204                 uint32_t                                        byte_cnt;\r
205                 TO_LONG_PTR(ib_ca_attr_t* ,             p_ca_attr) ;\r
206 \r
207         }       in;\r
208         struct _ual_query_ca_ioctl_out\r
209         {\r
210                 ci_umv_buf_t                            umv_buf;\r
211                 ib_api_status_t                         status;\r
212                 uint32_t                                        byte_cnt;\r
213 \r
214         }       out;\r
215 \r
216 }       ual_query_ca_ioctl_t;\r
217 /*\r
218 * FIELDS\r
219 *       in.umv_buf\r
220 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
221 *               exchange private information with the kernel-mode HCA driver.\r
222 *\r
223 *       in.h_ca\r
224 *               The handle to an open instance of CA returned via a\r
225 *               ual_open_ca_ioctl structure.\r
226 *\r
227 *       in.byte_cnt\r
228 *               Specifies the size of the data buffer referenced by the p_ca_attr\r
229 *               parameter.\r
230 *\r
231 *       p_ca_attr\r
232 *               A reference to a buffer where the channel adapter attributes,\r
233 *               including port attribute information will be copied.  If this parameter\r
234 *               is NULL, then the required buffer size needed to return all of the CA\r
235 *               attribute information is returned through the out.byte_cnt parameter.\r
236 *               The ib_ca_attr_t structure for the specified channel adapter is stored\r
237 *               at the top of this buffer.\r
238 *\r
239 *       out.umv_buf\r
240 *               Returns the status from the HCA driver to the user-mode HCA library,\r
241 *               along with any vendor specific output information.\r
242 *\r
243 *       out.status\r
244 *               Status of the operation\r
245 *\r
246 *       out.byte_cnt\r
247 *               Contains the number of bytes used or needed to copy all CA attributes.\r
248 *****/\r
249 \r
250 \r
251 \r
252 /****s* User-mode Access Layer/ual_modify_ca_ioctl_t\r
253 * NAME\r
254 *       ual_modify_ca_ioctl_t\r
255 *\r
256 * DESCRIPTION\r
257 *       IOCTL structure containing the input and output parameters for\r
258 *       ib_modify_ca\r
259 *\r
260 * SYNOPSIS\r
261 */\r
262 typedef union _ual_modify_ca_ioctl\r
263 {\r
264         struct _ual_modify_ca_ioctl_in\r
265         {\r
266                 uint64_t                                        h_ca;\r
267                 uint8_t                                         port_num;\r
268                 ib_ca_mod_t                                     ca_mod;\r
269                 ib_port_attr_mod_t                      port_attr_mod;\r
270 \r
271         }       in;\r
272         struct _ual_modify_ca_ioclt_out\r
273         {\r
274                 ib_api_status_t                         status;\r
275 \r
276         }       out;\r
277 \r
278 \r
279 }       ual_modify_ca_ioctl_t;\r
280 /*\r
281 * FIELDS\r
282 *       in.h_ca\r
283 *               The handle to an open instance of CA (in KAL space).\r
284 *\r
285 *       in.port_num\r
286 *               An index of the port that is being modified.\r
287 *\r
288 *       in.ca_mod\r
289 *               The mask of the attributes and counters to modify.\r
290 *\r
291 *       in.port_attr_mod\r
292 *               List of port attribute information to modify.\r
293 *\r
294 *       out.status\r
295 *               Status of the operation\r
296 *****/\r
297 \r
298 \r
299 \r
300 /****s* User-mode Access Layer/ual_close_ca_ioctl_t\r
301 * NAME\r
302 *       ual_close_ca_ioctl_t\r
303 *\r
304 * DESCRIPTION\r
305 *       IOCTL structure containing the input and output parameters for\r
306 *       ib_close_ca\r
307 *\r
308 * SYNOPSIS\r
309 */\r
310 typedef union _ual_close_ca_ioctl\r
311 {\r
312         struct _ual_close_ca_ioctl_in\r
313         {\r
314                 uint64_t                                        h_ca;\r
315 \r
316         }       in;\r
317         struct _ual_close_ca_ioctl_out\r
318         {\r
319                 ib_api_status_t                         status;\r
320 \r
321         }       out;\r
322 \r
323 }       ual_close_ca_ioctl_t;\r
324 /*\r
325 * FIELDS\r
326 *       in.h_ca\r
327 *               The handle to an open instance of CA (in KAL space).\r
328 *\r
329 *       out.status\r
330 *               Status of the operation\r
331 *****/\r
332 \r
333 /****s* User-mode Access Layer/ual_ci_call_ioctl_t\r
334 * NAME\r
335 *       ual_ci_call_ioctl_t\r
336 *\r
337 * DESCRIPTION\r
338 *       IOCTL structure containing the input and output parameters for\r
339 *       ib_ci_call\r
340 *\r
341 * SYNOPSIS\r
342 */\r
343 typedef union _ual_ci_call_ioctl\r
344 {\r
345         struct _ual_ci_call_ioctl_in\r
346         {\r
347                 ci_umv_buf_t                            umv_buf;\r
348                 ib_ci_op_t                                      ci_op;\r
349                 uint64_t                                        h_ca;\r
350                 uint32_t                                        num_handles;\r
351                 uint64_t                                        handle_array[1];\r
352 \r
353         }       in;\r
354         struct _ual_ci_call_ioctl_out\r
355         {\r
356                 ci_umv_buf_t                            umv_buf;\r
357                 ib_ci_op_t                                      ci_op;\r
358                 ib_api_status_t                         status;\r
359 \r
360         }       out;\r
361 \r
362 }       ual_ci_call_ioctl_t;\r
363 /*\r
364 * FIELDS\r
365 *       in.umv_buf\r
366 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
367 *               exchange private information with the kernel-mode HCA driver.\r
368 *\r
369 *       in.ci_op\r
370 *               Contains information on the operation that needs to be performed\r
371 *               by the verbs provider.  The proxy marshals the data buffer between\r
372 *               user mode and kernel space.\r
373 *\r
374 *       in.h_ca\r
375 *               The handle to an open instance of CA returned by a ual_open_ca_ioctl.\r
376 *\r
377 *       in.num_handles\r
378 *               The number of handles in the array at in.p_handle_array.\r
379 *\r
380 *       in.handle_array\r
381 *               First entry in an array of handles used for this operation.  Ignored if\r
382 *               in.num_handles is zero.\r
383 *\r
384 *       out.umv_buf\r
385 *               Returns the status from the HCA driver to the user-mode HCA library,\r
386 *               along with any vendor specific output information.\r
387 *\r
388 *       out.status\r
389 *               Status of the operation\r
390 *\r
391 *       out.ci_op\r
392 *               Contains information on the operation that needs to be performed\r
393 *               by the verbs provider.  The proxy marshals the data buffer between\r
394 *               user mode and kernel space.\r
395 *****/\r
396 \r
397 \r
398 \r
399 /****s* User-mode Access Layer/ual_alloc_pd_ioctl_t\r
400 * NAME\r
401 *       ual_alloc_pd_ioctl_t\r
402 *\r
403 * DESCRIPTION\r
404 *       IOCTL structure containing the input and output parameters for\r
405 *       ib_alloc_pd\r
406 *\r
407 * SYNOPSIS\r
408 */\r
409 typedef union _ual_alloc_pd_ioctl\r
410 {\r
411         struct _ual_alloc_pd_ioctl_in\r
412         {\r
413                 ci_umv_buf_t                            umv_buf;\r
414                 uint64_t                                        h_ca;\r
415                 ib_pd_type_t                            type;\r
416                 TO_LONG_PTR(void* ,                             context) ;\r
417 \r
418         }       in;\r
419         struct _ual_alloc_pd_ioctl_out\r
420         {\r
421                 ci_umv_buf_t                            umv_buf;\r
422                 ib_api_status_t                         status;\r
423                 uint64_t                                        h_pd;\r
424 \r
425         }       out;\r
426 \r
427 }       ual_alloc_pd_ioctl_t;\r
428 /*\r
429 * FIELDS\r
430 *       in.umv_buf\r
431 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
432 *               exchange private information with the kernel-mode HCA driver.\r
433 *\r
434 *       in.h_ca\r
435 *               The handle to an open instance of CA returned in a ual_open_ca_ioctl.\r
436 *\r
437 *       in.context\r
438 *               UAL's pd context. This context will be provided on destroy callback.\r
439 *\r
440 *       out.umv_buf\r
441 *               Returns the status from the HCA driver to the user-mode HCA library,\r
442 *               along with any vendor specific output information.\r
443 *\r
444 *       out.status\r
445 *               Status of the operation\r
446 *\r
447 *       out.h_pd\r
448 *               The handle to the PD to use in further PD-related IOCTLs.\r
449 *****/\r
450 \r
451 \r
452 \r
453 /****s* User-mode Access Layer/ual_dealloc_pd_ioctl_t\r
454 * NAME\r
455 *       ual_dealloc_pd_ioctl_t\r
456 *\r
457 * DESCRIPTION\r
458 *       IOCTL structure containing the input and output parameters for\r
459 *       ib_dealloc_pd\r
460 *\r
461 * SYNOPSIS\r
462 */\r
463 typedef union _ual_dealloc_pd_ioctl\r
464 {\r
465         struct _ual_dealloc_pd_ioctl_in\r
466         {\r
467                 uint64_t                                        h_pd;\r
468 \r
469         }       in;\r
470         struct _ual_dealloc_pd_ioctl_out\r
471         {\r
472                 ib_api_status_t                         status;\r
473 \r
474         }       out;\r
475 \r
476 }       ual_dealloc_pd_ioctl_t;\r
477 /*\r
478 * FIELDS\r
479 *       in.h_pd\r
480 *               The handle of the PD that is going to be deallocated.\r
481 *\r
482 *       out.status\r
483 *               Status of the operation\r
484 *****/\r
485 \r
486 \r
487 \r
488 /****s* User-mode Access Layer/ual_create_av_ioctl_t\r
489 * NAME\r
490 *       ual_create_av_ioctl_t\r
491 *\r
492 * DESCRIPTION\r
493 *       IOCTL structure containing the input and output parameters for\r
494 *       ib_create_av\r
495 *\r
496 * SYNOPSIS\r
497 */\r
498 typedef union _ual_create_av_ioctl\r
499 {\r
500         struct _ual_create_av_ioctl_in\r
501         {\r
502                 ci_umv_buf_t                            umv_buf;\r
503                 uint64_t                                        h_pd;\r
504                 ib_av_attr_t                            attr;\r
505 \r
506         }       in;\r
507         struct _ual_create_av_ioctl_out\r
508         {\r
509                 ci_umv_buf_t                            umv_buf;\r
510                 ib_api_status_t                         status;\r
511                 uint64_t                                        h_av;\r
512 \r
513         }       out;\r
514 \r
515 }       ual_create_av_ioctl_t;\r
516 /*\r
517 * FIELDS\r
518 *       in.umv_buf\r
519 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
520 *               exchange private information with the kernel-mode HCA driver.\r
521 *\r
522 *       in.h_pd\r
523 *               The handle to an already allocated PD (in KAL space).\r
524 *\r
525 *       in.attr\r
526 *               Attributes of the address vector that needs to be created.\r
527 *\r
528 *       out.umv_buf\r
529 *               Returns the status from the HCA driver to the user-mode HCA library,\r
530 *               along with any vendor specific output information.\r
531 *\r
532 *       out.status\r
533 *               Status of the operation.\r
534 *\r
535 *       out.h_av\r
536 *               Handle to the newly created address vector.\r
537 *****/\r
538 \r
539 \r
540 \r
541 /****s* User-mode Access Layer/ual_query_av_ioctl_t\r
542 * NAME\r
543 *       ual_query_av_ioctl_t\r
544 *\r
545 * DESCRIPTION\r
546 *       IOCTL structure containing the input and output parameters for\r
547 *       ib_query_av\r
548 *\r
549 * SYNOPSIS\r
550 */\r
551 typedef union _ual_query_av_ioctl\r
552 {\r
553         struct _ual_query_av_ioctl_in\r
554         {\r
555                 ci_umv_buf_t                            umv_buf;\r
556                 uint64_t                                        h_av;\r
557 \r
558         }       in;\r
559         struct _ual_query_av_ioctl_out\r
560         {\r
561                 ci_umv_buf_t                            umv_buf;\r
562                 ib_api_status_t                         status;\r
563                 ib_av_attr_t                            attr;\r
564                 TO_LONG_PTR(void* ,                             pd_context) ;\r
565 \r
566         }       out;\r
567 \r
568 }       ual_query_av_ioctl_t;\r
569 /*\r
570 * FIELDS\r
571 *       in.umv_buf\r
572 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
573 *               exchange private information with the kernel-mode HCA driver.\r
574 *\r
575 *       in.h_av\r
576 *               A handle to an existing address vector.\r
577 *\r
578 *       out.umv_buf\r
579 *               Returns the status from the HCA driver to the user-mode HCA library,\r
580 *               along with any vendor specific output information.\r
581 *\r
582 *       out.status\r
583 *               Status of the operation.\r
584 *\r
585 *       out.attr\r
586 *               Attributes of the address vector.\r
587 *\r
588 *       pd_context\r
589 *               Context associated with the PD when created.\r
590 *****/\r
591 \r
592 \r
593 \r
594 /****s* User-mode Access Layer/ual_modify_av_ioctl_t\r
595 * NAME\r
596 *       ual_modify_av_ioctl_t\r
597 *\r
598 * DESCRIPTION\r
599 *       IOCTL structure containing the input and output parameters for\r
600 *       ib_modify_av\r
601 *\r
602 * SYNOPSIS\r
603 */\r
604 typedef union _ual_modify_av_ioctl\r
605 {\r
606         struct _ual_modify_av_ioctl_in\r
607         {\r
608                 ci_umv_buf_t                            umv_buf;\r
609                 uint64_t                                        h_av;\r
610                 ib_av_attr_t                            attr;\r
611 \r
612         }       in;\r
613         struct _ual_modify_av_ioctl_out\r
614         {\r
615                 ci_umv_buf_t                            umv_buf;\r
616                 ib_api_status_t                         status;\r
617 \r
618         }       out;\r
619 \r
620 }       ual_modify_av_ioctl_t;\r
621 /*\r
622 * FIELDS\r
623 *       in.umv_buf\r
624 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
625 *               exchange private information with the kernel-mode HCA driver.\r
626 *\r
627 *       in.h_av\r
628 *               A handle to an existing address vector.\r
629 *\r
630 *       in.attr\r
631 *               The requested attributes to be used for modifying the address vector.\r
632 *\r
633 *       out.umv_buf\r
634 *               Returns the status from the HCA driver to the user-mode HCA library,\r
635 *               along with any vendor specific output information.\r
636 *\r
637 *       out.status\r
638 *               Status of the operation\r
639 *****/\r
640 \r
641 \r
642 \r
643 /****s* User-mode Access Layer/ual_destroy_av_ioctl_t\r
644 * NAME\r
645 *       ual_destroy_av_ioctl_t\r
646 *\r
647 * DESCRIPTION\r
648 *       IOCTL structure containing the input and output parameters for\r
649 *       ib_destroy_av\r
650 *\r
651 * SYNOPSIS\r
652 */\r
653 typedef union _ual_destroy_av_ioctl\r
654 {\r
655         struct _ual_destroy_av_ioctl_in\r
656         {\r
657                 uint64_t                                        h_av;\r
658 \r
659         }       in;\r
660         struct _ual_destroy_av_ioctl_out\r
661         {\r
662                 ib_api_status_t                         status;\r
663 \r
664         }       out;\r
665 \r
666 }       ual_destroy_av_ioctl_t;\r
667 /*\r
668 * FIELDS\r
669 *       in.h_av\r
670 *               A handle to an existing address vector.\r
671 *\r
672 *       out.status\r
673 *               Status of the operation.\r
674 *****/\r
675 \r
676 /****s* User-mode Access Layer/ual_create_srq_ioctl_t\r
677 * NAME\r
678 *       ual_create_srq_ioctl_t\r
679 *\r
680 * DESCRIPTION\r
681 *       IOCTL structure containing the input and output parameters for\r
682 *       ib_create_srq\r
683 *\r
684 * SYNOPSIS\r
685 */\r
686 typedef union _ual_create_srq_ioctl\r
687 {\r
688         struct _ual_create_srq_ioctl_in\r
689         {\r
690                 ci_umv_buf_t                            umv_buf;\r
691                 uint64_t                                        h_pd;\r
692                 ib_srq_attr_t                           srq_attr;\r
693                 TO_LONG_PTR(void* ,                             context) ;\r
694                 boolean_t                               ev_notify;\r
695 \r
696         }       in;\r
697         struct _ual_create_srq_ioctl_out\r
698         {\r
699                 ci_umv_buf_t                            umv_buf;\r
700                 ib_api_status_t                 status;\r
701                 uint64_t                                        h_srq;\r
702 \r
703         }       out;\r
704 \r
705 }       ual_create_srq_ioctl_t;\r
706 /*\r
707 * FIELDS\r
708 *       in.umv_buf\r
709 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
710 *               exchange private information with the kernel-mode HCA driver.\r
711 *\r
712 *       in.h_pd\r
713 *               Protection domain on which to create the srq.\r
714 *\r
715 *       in.srq_attr\r
716 *               Attributes necessary for creating the srq.\r
717 *\r
718 *       in.context\r
719 *               UAL's srq context that needs to be returned on a callback.\r
720 *\r
721 *       in.ev_notify\r
722 *               Boolean indicating whether asynchronous events should be\r
723 *               forwarded to user-mode.\r
724 *\r
725 *       out.umv_buf\r
726 *               Returns the status from the HCA driver to the user-mode HCA library,\r
727 *               along with any vendor specific output information.\r
728 *\r
729 *       out.status\r
730 *               Status of the operation.\r
731 *\r
732 *       out.h_srq\r
733 *               Handle for the newly created srq.\r
734 *****/\r
735 \r
736 \r
737 /****s* User-mode Access Layer/ual_modify_srq_ioctl_t\r
738 * NAME\r
739 *       ual_modify_srq_ioctl_t\r
740 *\r
741 * DESCRIPTION\r
742 *       IOCTL structure containing the input and output parameters for\r
743 *       ib_modify_srq\r
744 *\r
745 * SYNOPSIS\r
746 */\r
747 typedef union _ual_modify_srq_ioctl\r
748 {\r
749         struct _ual_modify_srq_ioctl_in\r
750         {\r
751                 ci_umv_buf_t                            umv_buf;\r
752                 uint64_t                                        h_srq;\r
753                 ib_srq_attr_mask_t                      srq_attr_mask;\r
754                 ib_srq_attr_t                           srq_attr;\r
755 \r
756         }       in;\r
757         struct _ual_modify_srq_ioctl_out\r
758         {\r
759                 ci_umv_buf_t                            umv_buf;\r
760                 ib_api_status_t                 status;\r
761 \r
762         }       out;\r
763 \r
764 }       ual_modify_srq_ioctl_t;\r
765 /*\r
766 * FIELDS\r
767 *       in.umv_buf\r
768 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
769 *               exchange private information with the kernel-mode HCA driver.\r
770 *\r
771 *       in.h_srq\r
772 *               A handle to an existing Queue Pair.\r
773 *\r
774 *       in.modify_attr\r
775 *               Attributes used for modifying the srq.\r
776 *\r
777 *       out.umv_buf\r
778 *               Returns the status from the HCA driver to the user-mode HCA library,\r
779 *               along with any vendor specific output information.\r
780 *\r
781 *       out.status\r
782 *               Status of the operation.\r
783 *\r
784 *****/\r
785 \r
786 \r
787 \r
788 /****s* User-mode Access Layer/ual_query_srq_ioctl_t\r
789 * NAME\r
790 *       ual_query_srq_ioctl_t\r
791 *\r
792 * DESCRIPTION\r
793 *       IOCTL structure containing the input and output parameters for\r
794 *       ib_query_srq\r
795 *\r
796 * SYNOPSIS\r
797 */\r
798 typedef union _ual_query_srq_ioctl\r
799 {\r
800         struct _ual_query_srq_ioctl_in\r
801         {\r
802                 ci_umv_buf_t                            umv_buf;\r
803                 uint64_t                                        h_srq;\r
804 \r
805         }       in;\r
806         struct _ual_query_srq_ioctl_out\r
807         {\r
808                 ci_umv_buf_t                            umv_buf;\r
809                 ib_api_status_t                 status;\r
810                 ib_srq_attr_t                           srq_attr;\r
811 \r
812         }       out;\r
813 \r
814 } ual_query_srq_ioctl_t;\r
815 /*\r
816 * FIELDS\r
817 *       in.umv_buf\r
818 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
819 *               exchange private information with the kernel-mode HCA driver.\r
820 *\r
821 *       h_srq\r
822 *               Handle to the srq whose attributes to query.\r
823 *\r
824 *       out.umv_buf\r
825 *               Returns the status from the HCA driver to the user-mode HCA library,\r
826 *               along with any vendor specific output information.\r
827 *\r
828 *       out.status\r
829 *               Status of the operation.\r
830 *\r
831 *       out.srq_attr\r
832 *               Attributes of the srq.\r
833 *****/\r
834 \r
835 \r
836 \r
837 /****s* User-mode Access Layer/ual_destroy_srq_ioctl_t\r
838 * NAME\r
839 *       ual_destroy_srq_ioctl_t\r
840 *\r
841 * DESCRIPTION\r
842 *       IOCTL structure containing the input and output parameters for\r
843 *       ib_destroy_srq\r
844 *\r
845 * SYNOPSIS\r
846 */\r
847 typedef union _ual_destroy_srq_ioctl\r
848 {\r
849         struct _ual_destroy_srq_ioctl_in\r
850         {\r
851                 uint64_t                                        h_srq;\r
852 \r
853         }       in;\r
854         struct _ual_destroy_srq_ioctl_out\r
855         {\r
856                 ib_api_status_t                 status;\r
857 \r
858         }       out;\r
859 \r
860 }       ual_destroy_srq_ioctl_t;\r
861 /*\r
862 * FIELDS\r
863 *       in.h_srq\r
864 *               Handle of the srq that needs to be destroyed.\r
865 *\r
866 *       out.status\r
867 *               Status of the operation.\r
868 *****/\r
869 \r
870 \r
871 \r
872 /****s* User-mode Access Layer/ual_create_qp_ioctl_t\r
873 * NAME\r
874 *       ual_create_qp_ioctl_t\r
875 *\r
876 * DESCRIPTION\r
877 *       IOCTL structure containing the input and output parameters for\r
878 *       ib_create_qp\r
879 *\r
880 * SYNOPSIS\r
881 */\r
882 typedef union _ual_create_qp_ioctl\r
883 {\r
884         struct _ual_create_qp_ioctl_in\r
885         {\r
886                 ci_umv_buf_t                            umv_buf;\r
887                 uint64_t                                        h_pd;\r
888                 ib_qp_create_t                          qp_create;\r
889                 TO_LONG_PTR(void* ,                             context) ;\r
890                 boolean_t                                       ev_notify;\r
891 \r
892         }       in;\r
893         struct _ual_create_qp_ioctl_out\r
894         {\r
895                 ci_umv_buf_t                            umv_buf;\r
896                 ib_api_status_t                         status;\r
897                 ib_qp_attr_t                            attr;\r
898                 uint64_t                                        h_qp;\r
899 \r
900         }       out;\r
901 \r
902 }       ual_create_qp_ioctl_t;\r
903 /*\r
904 * FIELDS\r
905 *       in.umv_buf\r
906 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
907 *               exchange private information with the kernel-mode HCA driver.\r
908 *\r
909 *       in.h_pd\r
910 *               Protection domain on which to create the QP.\r
911 *\r
912 *       in.qp_create\r
913 *               Attributes necessary for creating the QP.\r
914 *\r
915 *       in.context\r
916 *               UAL's qp context that needs to be returned on a callback.\r
917 *\r
918 *       in.ev_notify\r
919 *               Boolean indicating whether asynchronous events should be\r
920 *               forwarded to user-mode.\r
921 *\r
922 *       out.umv_buf\r
923 *               Returns the status from the HCA driver to the user-mode HCA library,\r
924 *               along with any vendor specific output information.\r
925 *\r
926 *       out.status\r
927 *               Status of the operation.\r
928 *\r
929 *       out.attr\r
930 *               Actual attributes of the newly created QP.\r
931 *\r
932 *       out.h_qp\r
933 *               Handle for the newly created QP.\r
934 *****/\r
935 \r
936 \r
937 \r
938 /****s* User-mode Access Layer/ual_modify_qp_ioctl_t\r
939 * NAME\r
940 *       ual_modify_qp_ioctl_t\r
941 *\r
942 * DESCRIPTION\r
943 *       IOCTL structure containing the input and output parameters for\r
944 *       ib_modify_qp\r
945 *\r
946 * SYNOPSIS\r
947 */\r
948 typedef union _ual_modify_qp_ioctl\r
949 {\r
950         struct _ual_modify_qp_ioctl_in\r
951         {\r
952                 ci_umv_buf_t                            umv_buf;\r
953                 uint64_t                                        h_qp;\r
954                 ib_qp_mod_t                                     modify_attr;\r
955 \r
956         }       in;\r
957         struct _ual_modify_qp_ioctl_out\r
958         {\r
959                 ci_umv_buf_t                            umv_buf;\r
960                 ib_api_status_t                         status;\r
961                 //ib_qp_query_t                         query_attr; // Not returned by AL\r
962 \r
963         }       out;\r
964 \r
965 }       ual_modify_qp_ioctl_t;\r
966 /*\r
967 * FIELDS\r
968 *       in.umv_buf\r
969 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
970 *               exchange private information with the kernel-mode HCA driver.\r
971 *\r
972 *       in.h_qp\r
973 *               A handle to an existing Queue Pair.\r
974 *\r
975 *       in.modify_attr\r
976 *               Attributes used for modifying the QP.\r
977 *\r
978 *       out.umv_buf\r
979 *               Returns the status from the HCA driver to the user-mode HCA library,\r
980 *               along with any vendor specific output information.\r
981 *\r
982 *       out.status\r
983 *               Status of the operation.\r
984 *\r
985 *       out.query_attr\r
986 *               On return from the ioctl, contains the actual attributes of\r
987 *               the QP just modified.\r
988 *****/\r
989 \r
990 \r
991 \r
992 /****s* User-mode Access Layer/ual_query_qp_ioctl_t\r
993 * NAME\r
994 *       ual_query_qp_ioctl_t\r
995 *\r
996 * DESCRIPTION\r
997 *       IOCTL structure containing the input and output parameters for\r
998 *       ib_query_qp\r
999 *\r
1000 * SYNOPSIS\r
1001 */\r
1002 typedef union _ual_query_qp_ioctl\r
1003 {\r
1004         struct _ual_query_qp_ioctl_in\r
1005         {\r
1006                 ci_umv_buf_t                            umv_buf;\r
1007                 uint64_t                                        h_qp;\r
1008 \r
1009         }       in;\r
1010         struct _ual_query_qp_ioctl_out\r
1011         {\r
1012                 ci_umv_buf_t                            umv_buf;\r
1013                 ib_api_status_t                         status;\r
1014                 ib_qp_attr_t                            attr;\r
1015 \r
1016         }       out;\r
1017 \r
1018 } ual_query_qp_ioctl_t;\r
1019 /*\r
1020 * FIELDS\r
1021 *       in.umv_buf\r
1022 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
1023 *               exchange private information with the kernel-mode HCA driver.\r
1024 *\r
1025 *       h_qp\r
1026 *               Handle to the QP whose attributes to query.\r
1027 *\r
1028 *       out.umv_buf\r
1029 *               Returns the status from the HCA driver to the user-mode HCA library,\r
1030 *               along with any vendor specific output information.\r
1031 *\r
1032 *       out.status\r
1033 *               Status of the operation.\r
1034 *\r
1035 *       out.attr\r
1036 *               Attributes of the QP.\r
1037 *****/\r
1038 \r
1039 \r
1040 \r
1041 /****s* User-mode Access Layer/ual_destroy_qp_ioctl_t\r
1042 * NAME\r
1043 *       ual_destroy_qp_ioctl_t\r
1044 *\r
1045 * DESCRIPTION\r
1046 *       IOCTL structure containing the input and output parameters for\r
1047 *       ib_destroy_qp\r
1048 *\r
1049 * SYNOPSIS\r
1050 */\r
1051 typedef union _ual_destroy_qp_ioctl\r
1052 {\r
1053         struct _ual_destroy_qp_ioctl_in\r
1054         {\r
1055                 uint64_t                                        h_qp;\r
1056 \r
1057         }       in;\r
1058         struct _ual_destroy_qp_ioctl_out\r
1059         {\r
1060                 ib_api_status_t                         status;\r
1061 \r
1062         }       out;\r
1063 \r
1064 }       ual_destroy_qp_ioctl_t;\r
1065 /*\r
1066 * FIELDS\r
1067 *       in.h_qp\r
1068 *               Handle of the QP that needs to be destroyed.\r
1069 *\r
1070 *       out.status\r
1071 *               Status of the operation.\r
1072 *****/\r
1073 \r
1074 \r
1075 \r
1076 /****s* User-mode Access Layer/ual_create_cq_ioctl_t\r
1077 * NAME\r
1078 *       ual_create_cq_ioctl_t\r
1079 *\r
1080 * DESCRIPTION\r
1081 *       IOCTL structure containing the input and output parameters for\r
1082 *       ib_create_cq\r
1083 *\r
1084 * SYNOPSIS\r
1085 */\r
1086 typedef union _ual_create_cq_ioctl\r
1087 {\r
1088         struct _ual_create_cq_ioctl_in\r
1089         {\r
1090                 ci_umv_buf_t                            umv_buf;\r
1091                 uint64_t                                        h_ca;\r
1092                 TO_LONG_PTR(void* ,                             h_wait_obj) ;\r
1093                 TO_LONG_PTR(void* ,                             context) ;\r
1094                 uint32_t                                        size;\r
1095                 boolean_t                                       ev_notify;\r
1096 \r
1097         }       in;\r
1098         struct _ual_create_cq_ioctl_out\r
1099         {\r
1100                 ci_umv_buf_t                            umv_buf;\r
1101                 ib_api_status_t                         status;\r
1102                 uint64_t                                        h_cq;\r
1103                 uint32_t                                        size;\r
1104 \r
1105         }       out;\r
1106 \r
1107 }       ual_create_cq_ioctl_t;\r
1108 /*\r
1109 * FIELDS\r
1110 *       in.umv_buf\r
1111 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
1112 *               exchange private information with the kernel-mode HCA driver.\r
1113 *\r
1114 *       in.h_ca\r
1115 *               CA handle on which to create the CQ.\r
1116 *\r
1117 *       in.cq_create\r
1118 *               Attributes necessary for creating the cq.\r
1119 *\r
1120 *       in.cq_context\r
1121 *               UAL's cq context that needs to be returned on a callback.\r
1122 *\r
1123 *       in.ev_notify\r
1124 *               Boolean indicating whether asynchronous events should be\r
1125 *               forwared to user-mode.\r
1126 *\r
1127 *       out.umv_buf\r
1128 *               Returns the status from the HCA driver to the user-mode HCA library,\r
1129 *               along with any vendor specific output information.\r
1130 *\r
1131 *       out.status\r
1132 *               Status of the operation.\r
1133 *\r
1134 *       h_cq\r
1135 *               Handle to the newly created CQ.\r
1136 *\r
1137 *       size\r
1138 *               Actual size of the newly created CQ.\r
1139 *****/\r
1140 \r
1141 \r
1142 \r
1143 /****s* User-mode Access Layer/ual_modify_cq_ioctl_t\r
1144 * NAME\r
1145 *       ual_modify_cq_ioctl_t\r
1146 *\r
1147 * DESCRIPTION\r
1148 *       IOCTL structure containing the input and output parameters for\r
1149 *       ib_modify_cq\r
1150 *\r
1151 * SYNOPSIS\r
1152 */\r
1153 typedef union _ual_modify_cq_ioctl\r
1154 {\r
1155         struct _ual_modify_cq_ioctl_in\r
1156         {\r
1157                 ci_umv_buf_t                            umv_buf;\r
1158                 uint64_t                                        h_cq;\r
1159                 uint32_t                                        size;\r
1160 \r
1161         }       in;\r
1162         struct _ual_modify_cq_ioctl_out\r
1163         {\r
1164                 ci_umv_buf_t                            umv_buf;\r
1165                 ib_api_status_t                         status;\r
1166                 uint32_t                                        size;\r
1167 \r
1168         }       out;\r
1169 \r
1170 }       ual_modify_cq_ioctl_t;\r
1171 /*\r
1172 * FIELDS\r
1173 *       in.umv_buf\r
1174 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
1175 *               exchange private information with the kernel-mode HCA driver.\r
1176 *\r
1177 *       in.h_cq\r
1178 *               A handle to the CQ to modify.\r
1179 *\r
1180 *       in.size\r
1181 *               The requested new size of the CQ.\r
1182 *\r
1183 *       out.umv_buf\r
1184 *               Returns the status from the HCA driver to the user-mode HCA library,\r
1185 *               along with any vendor specific output information.\r
1186 *\r
1187 *       out.status\r
1188 *               Status of the operation.\r
1189 *\r
1190 *       out.size\r
1191 *               The actual size of the CQ.\r
1192 *****/\r
1193 \r
1194 \r
1195 \r
1196 /****s* User-mode Access Layer/ual_query_cq_ioctl_t\r
1197 * NAME\r
1198 *       ual_query_cq_ioctl_t\r
1199 *\r
1200 * DESCRIPTION\r
1201 *       IOCTL structure containing the input and output parameters for\r
1202 *       ib_query_cq\r
1203 *\r
1204 * SYNOPSIS\r
1205 */\r
1206 typedef union _ual_query_cq_ioctl\r
1207 {\r
1208         struct _ual_query_cq_ioctl_in\r
1209         {\r
1210                 ci_umv_buf_t                            umv_buf;\r
1211                 uint64_t                                        h_cq;\r
1212 \r
1213         }       in;\r
1214         struct _ual_query_cq_ioctl_out\r
1215         {\r
1216                 ci_umv_buf_t                            umv_buf;\r
1217                 ib_api_status_t                         status;\r
1218                 uint32_t                                        size;\r
1219 \r
1220         }       out;\r
1221 \r
1222 }       ual_query_cq_ioctl_t;\r
1223 /*\r
1224 * FIELDS\r
1225 *       in.umv_buf\r
1226 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
1227 *               exchange private information with the kernel-mode HCA driver.\r
1228 *\r
1229 *       in.h_cq\r
1230 *               A handle to an existing CQ.\r
1231 *\r
1232 *       out.umv_buf\r
1233 *               Returns the status from the HCA driver to the user-mode HCA library,\r
1234 *               along with any vendor specific output information.\r
1235 *\r
1236 *       out.status\r
1237 *               Status of the operation.\r
1238 *\r
1239 *       out.size\r
1240 *               The size of the CQ.\r
1241 *****/\r
1242 \r
1243 \r
1244 \r
1245 /****s* User-mode Access Layer/ual_destroy_cq_ioctl_t\r
1246 * NAME\r
1247 *       ual_destroy_cq_ioctl_t\r
1248 *\r
1249 * DESCRIPTION\r
1250 *       IOCTL structure containing the input and output parameters for\r
1251 *       ib_destroy_cq\r
1252 *\r
1253 * SYNOPSIS\r
1254 */\r
1255 typedef union _ual_destroy_cq_ioctl\r
1256 {\r
1257         struct _ual_destroy_cq_ioctl_in\r
1258         {\r
1259                 uint64_t                                        h_cq;\r
1260 \r
1261         }       in;\r
1262         struct _ual_destroy_cq_ioctl_out\r
1263         {\r
1264                 ib_api_status_t                         status;\r
1265 \r
1266         }       out;\r
1267 \r
1268 }       ual_destroy_cq_ioctl_t;\r
1269 /*\r
1270 * FIELDS\r
1271 *       in.h_cq\r
1272 *               Handle of the cq that needs to be destroyed.\r
1273 *\r
1274 *       out.status\r
1275 *               Status of the operation.\r
1276 *****/\r
1277 \r
1278 \r
1279 \r
1280 /****s* User-mode Access Layer/ual_reg_mem_ioctl_t\r
1281 * NAME\r
1282 *       ual_reg_mem_ioctl_t\r
1283 *\r
1284 * DESCRIPTION\r
1285 *       IOCTL structure containing the input and output parameters for\r
1286 *       ib_reg_mem\r
1287 *\r
1288 * SYNOPSIS\r
1289 */\r
1290 typedef union _ual_reg_mem_ioctl\r
1291 {\r
1292         struct _ual_reg_mem_ioctl_in\r
1293         {\r
1294                 uint64_t                                        h_pd;\r
1295                 ib_mr_create_t                          mem_create;\r
1296 \r
1297         }       in;\r
1298         struct _ual_reg_mem_ioctl_out\r
1299         {\r
1300                 ib_api_status_t                         status;\r
1301                 net32_t                                         lkey;\r
1302                 net32_t                                         rkey;\r
1303                 uint64_t                                        h_mr;\r
1304 \r
1305         }       out;\r
1306 \r
1307 }       ual_reg_mem_ioctl_t;\r
1308 /*\r
1309 * FIELDS\r
1310 *       in.h_pd\r
1311 *               Handle to the protection domain on which to register the memory.\r
1312 *\r
1313 *       in.mem_create\r
1314 *               Information for registering the memory region.\r
1315 *\r
1316 *       out.status\r
1317 *               Status of the operation.\r
1318 *\r
1319 *       out.lkey\r
1320 *               LKey value returned by verb.\r
1321 *\r
1322 *       out.rkey\r
1323 *               RKey value returned by verb.\r
1324 *\r
1325 *       h_mr\r
1326 *               Handle to the registered memory region.\r
1327 *****/\r
1328 \r
1329 \r
1330 \r
1331 /****s* User-mode Access Layer/ual_query_mr_ioctl_t\r
1332 * NAME\r
1333 *       ual_query_mr_ioctl_t\r
1334 *\r
1335 * DESCRIPTION\r
1336 *       IOCTL structure containing the input and output parameters for\r
1337 *       ib_query_mr\r
1338 *\r
1339 * SYNOPSIS\r
1340 */\r
1341 typedef union _ual_query_mr_ioctl\r
1342 {\r
1343         struct _ual_query_mr_ioctl_in\r
1344         {\r
1345                 uint64_t                                        h_mr;\r
1346 \r
1347         }       in;\r
1348         struct _ual_query_mr_ioctl_out\r
1349         {\r
1350                 ib_api_status_t                         status;\r
1351                 ib_mr_attr_t                            attr;\r
1352 \r
1353         }       out;\r
1354 \r
1355 }       ual_query_mr_ioctl_t;\r
1356 /*\r
1357 * FIELDS\r
1358 *       in.h_mr\r
1359 *               A handle to a registered memory region.\r
1360 *\r
1361 *       out.status\r
1362 *               Status of the operation.\r
1363 *\r
1364 *       out.attr\r
1365 *               Attributes of the registered memory region.\r
1366 *****/\r
1367 \r
1368 \r
1369 \r
1370 /****s* User-mode Access Layer/ual_rereg_mem_ioctl_t\r
1371 * NAME\r
1372 *       ual_rereg_mem_ioctl_t\r
1373 *\r
1374 * DESCRIPTION\r
1375 *       IOCTL structure containing the input and output parameters for\r
1376 *       ib_modify_mr\r
1377 *\r
1378 * SYNOPSIS\r
1379 */\r
1380 typedef union _ual_rereg_mem_ioctl\r
1381 {\r
1382         struct _ual_rereg_mem_ioctl_in\r
1383         {\r
1384                 uint64_t                                        h_mr;\r
1385                 ib_mr_mod_t                                     mem_mod_mask;\r
1386                 ib_mr_create_t                          mem_create;\r
1387                 uint64_t                                        h_pd;\r
1388 \r
1389         }       in;\r
1390         struct _ual_rereg_mem_ioctl_out\r
1391         {\r
1392                 ib_api_status_t                         status;\r
1393                 net32_t                                         lkey;\r
1394                 net32_t                                         rkey;\r
1395 \r
1396         }       out;\r
1397 \r
1398 }       ual_rereg_mem_ioctl_t;\r
1399 /*\r
1400 * FIELDS\r
1401 *       in.h_mr\r
1402 *               A handle to a registered memory region that is being modified.\r
1403 *\r
1404 *       in.mem_mod_mask\r
1405 *               The attributes to use when modifying the memory region.\r
1406 *\r
1407 *       in.mem_create\r
1408 *               Information to use for modifying the memory region.  Required only\r
1409 *               for changes other than the PD.\r
1410 *\r
1411 *       in.h_pd\r
1412 *               PD Handle for changing protection domains.\r
1413 *\r
1414 *       out.status\r
1415 *               Status of the operation.\r
1416 *\r
1417 *       out.l_key\r
1418 *               LKey of the memory region.\r
1419 *\r
1420 *       out.rkey\r
1421 *               RKey of the memory region.\r
1422 *****/\r
1423 \r
1424 \r
1425 \r
1426 /****s* User-mode Access Layer/ual_reg_shared_ioctl_t\r
1427 * NAME\r
1428 *       ual_reg_shared_ioctl_t\r
1429 *\r
1430 * DESCRIPTION\r
1431 *       IOCTL structure containing the input and output parameters for\r
1432 *       ib_reg_shared\r
1433 *\r
1434 * SYNOPSIS\r
1435 */\r
1436 typedef union _ual_reg_shared_ioctl\r
1437 {\r
1438         struct _ual_reg_shared_ioctl_in\r
1439         {\r
1440                 uint64_t                                        h_mr;\r
1441                 uint64_t                                        h_pd;\r
1442                 ib_access_t                                     access_ctrl;\r
1443                 uint64_t                                        vaddr;\r
1444 \r
1445         }       in;\r
1446         struct _ual_reg_shared_ioctl_out\r
1447         {\r
1448                 ib_api_status_t                         status;\r
1449                 uint64_t                                        vaddr;\r
1450                 net32_t                                         lkey;\r
1451                 net32_t                                         rkey;\r
1452                 uint64_t                                        h_new_mr;\r
1453 \r
1454         }       out;\r
1455 \r
1456 }       ual_reg_shared_ioctl_t;\r
1457 /*\r
1458 * FIELDS\r
1459 *       in.h_mr\r
1460 *               A handle to the existing registered memory region.\r
1461 *\r
1462 *       in.h_pd\r
1463 *               A handle to the PD on which memory is being registered.\r
1464 *\r
1465 *       in.access_ctrl\r
1466 *               Access control for the new memory region.\r
1467 *\r
1468 *       in.vaddr\r
1469 *               Requested virtual address.\r
1470 *\r
1471 *       out.status\r
1472 *               Status of the operation.\r
1473 *\r
1474 *       out.vaddr\r
1475 *               Actual virtual address of the registered region.\r
1476 *\r
1477 *       out.l_key\r
1478 *               LKey of the memory region.\r
1479 *\r
1480 *       out.rkey\r
1481 *               RKey of the memory region.\r
1482 *\r
1483 *       h_new_mr\r
1484 *               Handle to the registered memory region.\r
1485 *****/\r
1486 \r
1487 \r
1488 \r
1489 /****s* User-mode Access Layer/ual_dereg_mr_ioctl_t\r
1490 * NAME\r
1491 *       ual_dereg_mr_ioctl_t\r
1492 *\r
1493 * DESCRIPTION\r
1494 *       IOCTL structure containing the input and output parameters for\r
1495 *       ib_dereg_mr\r
1496 *\r
1497 * SYNOPSIS\r
1498 */\r
1499 typedef union _ual_dereg_mr_ioctl\r
1500 {\r
1501         struct _ual_dereg_mr_ioctl_in\r
1502         {\r
1503                 uint64_t                                        h_mr;\r
1504 \r
1505         }       in;\r
1506         struct _ual_dereg_mr_ioctl_out\r
1507         {\r
1508                 ib_api_status_t                         status;\r
1509         \r
1510         }       out;\r
1511 \r
1512 } ual_dereg_mr_ioctl_t;\r
1513 /*\r
1514 * FIELDS\r
1515 *       in.h_mr\r
1516 *               A handle to a registered memory region.\r
1517 *\r
1518 *       out.status\r
1519 *               Status of the operation.\r
1520 *****/\r
1521 \r
1522 \r
1523 \r
1524 /****s* User-mode Access Layer/ual_create_mw_ioctl_t\r
1525 * NAME\r
1526 *       ual_create_mw_ioctl_t\r
1527 *\r
1528 * DESCRIPTION\r
1529 *       IOCTL structure containing the input and output parameters for\r
1530 *       ib_create_mw\r
1531 *\r
1532 * SYNOPSIS\r
1533 */\r
1534 typedef union _ual_create_mw_ioctl\r
1535 {\r
1536         struct _ual_create_mw_ioctl_in\r
1537         {\r
1538                 ci_umv_buf_t                            umv_buf;\r
1539                 uint64_t                                        h_pd;\r
1540 \r
1541         }       in;\r
1542         struct _ual_create_mw_ioctl_out\r
1543         {\r
1544                 ci_umv_buf_t                            umv_buf;\r
1545                 ib_api_status_t                         status;\r
1546                 net32_t                                         rkey;\r
1547                 uint64_t                                        h_mw;\r
1548 \r
1549         }       out;\r
1550 \r
1551 }       ual_create_mw_ioctl_t;\r
1552 /*\r
1553 * FIELDS\r
1554 *       in.umv_buf\r
1555 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
1556 *               exchange private information with the kernel-mode HCA driver.\r
1557 *\r
1558 *       in.h_pd\r
1559 *               A handle to the protection domain on which the memory window should\r
1560 *               be created.\r
1561 *\r
1562 *       out.umv_buf\r
1563 *               Returns the status from the HCA driver to the user-mode HCA library,\r
1564 *               along with any vendor specific output information.\r
1565 *\r
1566 *       out.status\r
1567 *               Status of the operation.\r
1568 *\r
1569 *       out.rkey\r
1570 *               RKey associated with the memory window.\r
1571 *\r
1572 *       h_mw\r
1573 *               Handle to the newly created MW.\r
1574 *****/\r
1575 \r
1576 \r
1577 \r
1578 /****s* User-mode Access Layer/ual_query_mw_ioctl_t\r
1579 * NAME\r
1580 *       ual_query_mw_ioctl_t\r
1581 *\r
1582 * DESCRIPTION\r
1583 *       IOCTL structure containing the input and output parameters for\r
1584 *       ib_query_mw\r
1585 *\r
1586 * SYNOPSIS\r
1587 */\r
1588 typedef union _ual_query_mw_ioctl\r
1589 {\r
1590         struct _ual_query_mw_ioctl_in\r
1591         {\r
1592                 ci_umv_buf_t                            umv_buf;\r
1593                 uint64_t                                        h_mw;\r
1594 \r
1595         }       in;\r
1596         struct _ual_query_mw_ioctl_out\r
1597         {\r
1598                 ci_umv_buf_t                            umv_buf;\r
1599                 ib_api_status_t                         status;\r
1600                 TO_LONG_PTR(void* ,                             pd_context) ;\r
1601                 net32_t                                         rkey;\r
1602 \r
1603         }       out;\r
1604 \r
1605 }       ual_query_mw_ioctl_t;\r
1606 /*\r
1607 * FIELDS\r
1608 *       in.umv_buf\r
1609 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
1610 *               exchange private information with the kernel-mode HCA driver.\r
1611 *\r
1612 *       in.h_mw\r
1613 *               A handle to an existing memory window.\r
1614 *\r
1615 *       out.umv_buf\r
1616 *               Returns the status from the HCA driver to the user-mode HCA library,\r
1617 *               along with any vendor specific output information.\r
1618 *\r
1619 *       out.status\r
1620 *               Status of the operation.\r
1621 *\r
1622 *       pd_context\r
1623 *               This user-mode context for the protection domain\r
1624 *               associated with the memory window.\r
1625 *\r
1626 *       rkey\r
1627 *               RKey associated with the memory window.\r
1628 *****/\r
1629 \r
1630 \r
1631 \r
1632 /****s* User-mode Access Layer/ual_bind_mw_ioctl_t\r
1633 * NAME\r
1634 *       ual_bind_mw_ioctl_t\r
1635 *\r
1636 * DESCRIPTION\r
1637 *       IOCTL structure containing the input and output parameters for\r
1638 *       ib_bind_mw\r
1639 *\r
1640 * SYNOPSIS\r
1641 */\r
1642 typedef union _ual_bind_mw_ioctl\r
1643 {\r
1644         struct _ual_bind_mw_ioctl_in\r
1645         {\r
1646                 uint64_t                                        h_mw;\r
1647                 uint64_t                                        h_qp;\r
1648                 ib_bind_wr_t                            mw_bind;\r
1649 \r
1650         }       in;\r
1651         struct _ual_bind_mw_ioctl_out\r
1652         {\r
1653                 ib_api_status_t                         status;\r
1654                 uint32_t                                        r_key;\r
1655 \r
1656         }       out;\r
1657 \r
1658 }       ual_bind_mw_ioctl_t;\r
1659 /*\r
1660 * FIELDS\r
1661 *       in.h_mw\r
1662 *               A handle to an existing memory window.\r
1663 *\r
1664 *       in.h_qp\r
1665 *               The qp handle to post the bind request.\r
1666 *\r
1667 *       in.mw_bind\r
1668 *               Bind request.\r
1669 *\r
1670 *       out.status\r
1671 *               Status of the operation.\r
1672 *\r
1673 *       out.rkey\r
1674 *               RKey for the memory window.\r
1675 *****/\r
1676 \r
1677 \r
1678 \r
1679 /****s* User-mode Access Layer/ual_destroy_mw_ioctl_t\r
1680 * NAME\r
1681 *       ual_destroy_mw_ioctl_t\r
1682 *\r
1683 * DESCRIPTION\r
1684 *       IOCTL structure containing the input and output parameters for\r
1685 *       ib_destroy_mw\r
1686 *\r
1687 * SYNOPSIS\r
1688 */\r
1689 typedef union _ual_destroy_mw_ioctl\r
1690 {\r
1691         struct _ual_destroy_mw_ioctl_in\r
1692         {\r
1693                 uint64_t                                        h_mw;\r
1694 \r
1695         }       in;\r
1696         struct _ual_destroy_mw_ioctl_out\r
1697         {\r
1698                 ib_api_status_t                         status;\r
1699 \r
1700         }       out;\r
1701 \r
1702 }       ual_destroy_mw_ioctl_t;\r
1703 /*\r
1704 * FIELDS\r
1705 *       in.h_mw\r
1706 *               A handle to an existing memory window.\r
1707 *\r
1708 *       out.status\r
1709 *               Status of the operation\r
1710 *****/\r
1711 \r
1712 \r
1713 \r
1714 /****s* User-mode Access Layer/ual_post_send_ioctl_t\r
1715 * NAME\r
1716 *       ual_post_send_ioctl_t\r
1717 *\r
1718 * DESCRIPTION\r
1719 *       IOCTL structure containing the input and output parameters for\r
1720 *       ib_post_send\r
1721 *\r
1722 * SYNOPSIS\r
1723 */\r
1724 typedef union _ual_post_send_ioctl\r
1725 {\r
1726         struct _ual_post_send_ioctl_in\r
1727         {\r
1728                 uint64_t                                        h_qp;\r
1729                 uint32_t                                        num_wr;\r
1730                 uint32_t                                        num_ds;\r
1731                 ib_send_wr_t                            send_wr[1];\r
1732                 /* Additional work requests follow, followed by data segments. */\r
1733 \r
1734         }       in;\r
1735         struct _ual_post_send_ioctl_out\r
1736         {\r
1737                 ib_api_status_t                         status;\r
1738                 uint32_t                                        failed_cnt;\r
1739 \r
1740         }       out;\r
1741 \r
1742 }       ual_post_send_ioctl_t;\r
1743 /*\r
1744 * FIELDS\r
1745 *       in.h_qp\r
1746 *               A handle to QP where the work request is being posted.\r
1747 *\r
1748 *       in.num_wr\r
1749 *               Number of work request items in the array of work requests.\r
1750 *\r
1751 *       in.num_ds\r
1752 *               Number of data segments following the array of work requests.\r
1753 *\r
1754 *       in.send_wr\r
1755 *               First work request in the array of work requests being posted.\r
1756 *\r
1757 *       out.status\r
1758 *               Status of the operation.\r
1759 *\r
1760 *       out.failed_cnt\r
1761 *               Number of work request that failed.\r
1762 *****/\r
1763 \r
1764 \r
1765 /****s* User-mode Access Layer/ual_post_srq_recv_ioctl_t\r
1766 * NAME\r
1767 *       ual_post_srq_recv_ioctl_t\r
1768 *\r
1769 * DESCRIPTION\r
1770 *       IOCTL structure containing the input and output parameters for\r
1771 *       ib_post_srq_recv\r
1772 *\r
1773 * SYNOPSIS\r
1774 */\r
1775 typedef union _ual_post_srq_recv_ioctl\r
1776 {\r
1777         struct _ual_post_srq_recv_ioctl_in\r
1778         {\r
1779                 uint64_t                                        h_srq;\r
1780                 uint32_t                                        num_wr;\r
1781                 uint32_t                                        num_ds;\r
1782                 ib_recv_wr_t                            recv_wr[1];\r
1783                 /* Additional work requests follow, followed by data segments. */\r
1784 \r
1785         }       in;\r
1786         struct _ual_post_srq_recv_ioctl_out\r
1787         {\r
1788                 ib_api_status_t                 status;\r
1789                 uint32_t                                        failed_cnt;\r
1790 \r
1791         }       out;\r
1792 \r
1793 }       ual_post_srq_recv_ioctl_t;\r
1794 /*\r
1795 * FIELDS\r
1796 *       in.h_srq\r
1797 *               A handle to SRQ where the work request is being posted.\r
1798 *\r
1799 *       in.num_wr\r
1800 *               Number of work request items in the array of work requests.\r
1801 *\r
1802 *       in.num_ds\r
1803 *               Number of data segments following the array of work requests.\r
1804 *\r
1805 *       in.recv_wr\r
1806 *               First work request in the array of work requests being posted.\r
1807 *\r
1808 *       out.status\r
1809 *               Status of the operation.\r
1810 *\r
1811 *       failed_cnt\r
1812 *               Number of work request that failed.\r
1813 *****/\r
1814 \r
1815 \r
1816 \r
1817 /****s* User-mode Access Layer/ual_post_recv_ioctl_t\r
1818 * NAME\r
1819 *       ual_post_recv_ioctl_t\r
1820 *\r
1821 * DESCRIPTION\r
1822 *       IOCTL structure containing the input and output parameters for\r
1823 *       ib_post_recv\r
1824 *\r
1825 * SYNOPSIS\r
1826 */\r
1827 typedef union _ual_post_recv_ioctl\r
1828 {\r
1829         struct _ual_post_recv_ioctl_in\r
1830         {\r
1831                 uint64_t                                        h_qp;\r
1832                 uint32_t                                        num_wr;\r
1833                 uint32_t                                        num_ds;\r
1834                 ib_recv_wr_t                            recv_wr[1];\r
1835                 /* Additional work requests follow, followed by data segments. */\r
1836 \r
1837         }       in;\r
1838         struct _ual_post_recv_ioctl_out\r
1839         {\r
1840                 ib_api_status_t                         status;\r
1841                 uint32_t                                        failed_cnt;\r
1842 \r
1843         }       out;\r
1844 \r
1845 }       ual_post_recv_ioctl_t;\r
1846 /*\r
1847 * FIELDS\r
1848 *       in.h_qp\r
1849 *               A handle to QP where the work request is being posted.\r
1850 *\r
1851 *       in.num_wr\r
1852 *               Number of work request items in the array of work requests.\r
1853 *\r
1854 *       in.num_ds\r
1855 *               Number of data segments following the array of work requests.\r
1856 *\r
1857 *       in.recv_wr\r
1858 *               First work request in the array of work requests being posted.\r
1859 *\r
1860 *       out.status\r
1861 *               Status of the operation.\r
1862 *\r
1863 *       failed_cnt\r
1864 *               Number of work request that failed.\r
1865 *****/\r
1866 \r
1867 \r
1868 \r
1869 /****s* User-mode Access Layer/ual_peek_cq_ioctl_t\r
1870 * NAME\r
1871 *       ual_peek_cq_ioctl_t\r
1872 *\r
1873 * DESCRIPTION\r
1874 *       IOCTL structure containing the input and output parameters for\r
1875 *       ib_peek_cq\r
1876 *\r
1877 * SYNOPSIS\r
1878 */\r
1879 typedef union _ual_peek_cq_ioctl\r
1880 {\r
1881         struct _ual_peek_cq_ioctl_in\r
1882         {\r
1883                 uint64_t                                        h_cq;\r
1884 \r
1885         }       in;\r
1886         struct _ual_peek_cq_ioctl_out\r
1887         {\r
1888                 ib_api_status_t                         status;\r
1889                 uint32_t                                        n_cqes;\r
1890 \r
1891         }       out;\r
1892 \r
1893 } ual_peek_cq_ioctl_t;\r
1894 /*\r
1895 * FIELDS\r
1896 *       in.h_cq\r
1897 *               A handle to a CQ.\r
1898 *\r
1899 *       out.status\r
1900 *               Status of the operation.\r
1901 *\r
1902 *       out.n_cqes\r
1903 *               The number of completion queue entries currently on the CQ.\r
1904 *****/\r
1905 \r
1906 \r
1907 \r
1908 /****s* User-mode Access Layer/ual_poll_cq_ioctl_t\r
1909 * NAME\r
1910 *       ual_poll_cq_ioctl_t\r
1911 *\r
1912 * DESCRIPTION\r
1913 *       IOCTL structure containing the input and output parameters for\r
1914 *       ib_poll_cq\r
1915 *\r
1916 * SYNOPSIS\r
1917 */\r
1918 typedef union _ual_poll_cq_ioctl\r
1919 {\r
1920         struct _ual_poll_cq_ioctl_in\r
1921         {\r
1922                 uint64_t                                        h_cq;\r
1923                 uint32_t                                        num_wc;\r
1924 \r
1925         }       in;\r
1926         struct _ual_poll_cq_ioctl_out\r
1927         {\r
1928                 ib_api_status_t                         status;\r
1929                 uint32_t                                        num_wc;\r
1930                 ib_wc_t                                         wc[1];\r
1931                 /* Additional WC's follow. */\r
1932         }       out;\r
1933 \r
1934 }       ual_poll_cq_ioctl_t;\r
1935 /*\r
1936 * FIELDS\r
1937 *       in.h_cq\r
1938 *               A handle to cq that is going to be polled for completions.\r
1939 *\r
1940 *       in.num_wc\r
1941 *               Number of work completions in the output array.\r
1942 *\r
1943 *       out.status\r
1944 *               Status of the operation.\r
1945 *\r
1946 *       out.num_wc\r
1947 *               Number of work completions polled.\r
1948 *\r
1949 *       out.wc\r
1950 *               First work completion in the array to use for polling.\r
1951 *****/\r
1952 \r
1953 \r
1954 \r
1955 /****s* User-mode Access Layer/ual_rearm_cq_ioctl_t\r
1956 * NAME\r
1957 *       ual_rearm_cq_ioctl_t\r
1958 *\r
1959 * DESCRIPTION\r
1960 *       IOCTL structure containing the input and output parameters for\r
1961 *       ib_rearm_cq\r
1962 *\r
1963 * SYNOPSIS\r
1964 */\r
1965 typedef union _ual_rearm_cq_ioctl\r
1966 {\r
1967         struct _ual_rearm_cq_ioctl_in\r
1968         {\r
1969                 uint64_t                                        h_cq;\r
1970                 boolean_t                                       solicited;\r
1971 \r
1972         }       in;\r
1973         struct _ual_rearm_cq_ioctl_out\r
1974         {\r
1975                 ib_api_status_t                         status;\r
1976 \r
1977         }       out;\r
1978 \r
1979 }       ual_rearm_cq_ioctl_t;\r
1980 /*\r
1981 * FIELDS\r
1982 *       in.h_cq\r
1983 *               A handle to a CQ.\r
1984 *\r
1985 *       in.solicited\r
1986 *               Flag for rearm CQ.\r
1987 *\r
1988 *       out.status\r
1989 *               Status of the operation.\r
1990 *****/\r
1991 \r
1992 \r
1993 \r
1994 /****s* User-mode Access Layer/ual_rearm_n_cq_ioctl_t\r
1995 * NAME\r
1996 *       ual_rearm_n_cq_ioctl_t\r
1997 *\r
1998 * DESCRIPTION\r
1999 *       IOCTL structure containing the input and output parameters for\r
2000 *       ib_rearm_n_cq\r
2001 *\r
2002 * SYNOPSIS\r
2003 */\r
2004 typedef union _ual_rearm_n_cq_ioctl\r
2005 {\r
2006         struct _ual_rearm_n_cq_ioctl_in\r
2007         {\r
2008                 uint64_t                                        h_cq;\r
2009                 uint32_t                                        n_cqes;\r
2010 \r
2011         }       in;\r
2012         struct _ual_rearm_n_cq_ioctl_out\r
2013         {\r
2014                 ib_api_status_t                         status;\r
2015 \r
2016         }       out;\r
2017 \r
2018 }       ual_rearm_n_cq_ioctl_t;\r
2019 /*\r
2020 * FIELDS\r
2021 *       in.h_cq\r
2022 *               A handle to a CQ.\r
2023 *\r
2024 *       in.n_cqes\r
2025 *               Rearm the CQ to signal when the next N completions are added.\r
2026 *\r
2027 *       in.status\r
2028 *               Status of the operation.\r
2029 *****/\r
2030 \r
2031 \r
2032 \r
2033 /****s* User-mode Access Layer/ual_attach_mcast_ioctl_t\r
2034 * NAME\r
2035 *       ual_attach_mcast_ioctl_t\r
2036 *\r
2037 * DESCRIPTION\r
2038 *       IOCTL structure containing the input and output parameters for\r
2039 *       verbs attach multicast call.\r
2040 *\r
2041 * SYNOPSIS\r
2042 */\r
2043 typedef union _ual_attach_mcast_ioctl\r
2044 {\r
2045         struct _ual_attach_mcast_ioctl_in\r
2046         {\r
2047                 ci_umv_buf_t                            umv_buf;\r
2048                 uint64_t                                        h_qp;\r
2049                 ib_gid_t                                        mgid;\r
2050                 ib_net16_t                                      mlid;\r
2051 \r
2052         }       in;\r
2053         struct _ual_attach_mcast_ioctl_out\r
2054         {\r
2055                 ci_umv_buf_t                            umv_buf;\r
2056                 ib_api_status_t                         status;\r
2057                 uint64_t                                        h_attach;\r
2058 \r
2059         }       out;\r
2060 \r
2061 }       ual_attach_mcast_ioctl_t;\r
2062 /*\r
2063 * FIELDS\r
2064 *       in.umv_buf\r
2065 *               Opaque to IBAL buffer descriptor to allow the user-mode HCA library to\r
2066 *               exchange private information with the kernel-mode HCA driver.\r
2067 *\r
2068 *       in.h_qp\r
2069 *               Handle to the QP that is joining the multicast group.\r
2070 *\r
2071 *       in.mgid\r
2072 *               Multicast GID address for this multicast group.\r
2073 *\r
2074 *       in.mlid\r
2075 *               Multicast LID for this multicast group.\r
2076 *\r
2077 *       out.umv_buf\r
2078 *               Returns the status from the HCA driver to the user-mode HCA library,\r
2079 *               along with any vendor specific output information.\r
2080 *\r
2081 *       out.status\r
2082 *               Status of the operation.\r
2083 *\r
2084 *       h_attach\r
2085 *               Multicast group handle.\r
2086 *****/\r
2087 \r
2088 \r
2089 \r
2090 /****s* User-mode Access Layer/ual_detach_mcast_ioctl_t\r
2091 * NAME\r
2092 *       ual_detach_mcast_ioctl_t\r
2093 *\r
2094 * DESCRIPTION\r
2095 *       IOCTL structure containing the input and output parameters for\r
2096 *       verbs detach call.\r
2097 *\r
2098 * SYNOPSIS\r
2099 */\r
2100 typedef union _ual_detach_mcast_ioctl\r
2101 {\r
2102         struct _ual_detach_mcast_ioctl_in\r
2103         {\r
2104                 uint64_t                                        h_attach;\r
2105 \r
2106         }       in;\r
2107         struct _ual_detach_mcast_ioctl_out\r
2108         {\r
2109                 ib_api_status_t                         status;\r
2110 \r
2111         }       out;\r
2112 \r
2113 }       ual_detach_mcast_ioctl_t;\r
2114 /*\r
2115 * FIELDS\r
2116 *       in.h_attach\r
2117 *               A handle to the multicast group.\r
2118 *\r
2119 *       out.status\r
2120 *               Status of the operation.\r
2121 *****/\r
2122 \r
2123 \r
2124 \r
2125 /****s* User-mode Access Layer/ual_reg_mad_svc_ioctl_t\r
2126 * NAME\r
2127 *       ual_reg_mad_svc_ioctl_t\r
2128 *\r
2129 * DESCRIPTION\r
2130 *       IOCTL structure containing the input and output parameters for\r
2131 *       ib_reg_mad_svc\r
2132 *\r
2133 * SYNOPSIS\r
2134 */\r
2135 typedef union _ual_reg_mad_svc_ioctl\r
2136 {\r
2137         struct _ual_reg_mad_svc_ioctl_in\r
2138         {\r
2139                 uint64_t                                        h_qp;\r
2140                 ib_mad_svc_t                            mad_svc;\r
2141 \r
2142         }       in;\r
2143         struct _ual_reg_mad_svc_ioctl_out\r
2144         {\r
2145                 ib_api_status_t                         status;\r
2146                 uint64_t                                        h_mad_svc;\r
2147 \r
2148         }       out;\r
2149 \r
2150 }       ual_reg_mad_svc_ioctl_t;\r
2151 /*\r
2152 * FIELDS\r
2153 *       in.h_qp\r
2154 *               Handle to the special QP or MAD QP.\r
2155 *\r
2156 *       in.mad_svc\r
2157 *               Mad service definition.\r
2158 *\r
2159 *       out.status\r
2160 *               Status of the operation.\r
2161 *\r
2162 *       out.h_mad_svc\r
2163 *               Handle to the mad service.\r
2164 *****/\r
2165 \r
2166 \r
2167 \r
2168 /****s* User-mode Access Layer/ual_dereg_mad_svc_ioctl_t\r
2169 * NAME\r
2170 *       ual_dereg_mad_svc_ioctl_t\r
2171 *\r
2172 * DESCRIPTION\r
2173 *       IOCTL structure containing the input and output parameters for\r
2174 *       ib_dereg_mad_svc\r
2175 *\r
2176 * SYNOPSIS\r
2177 */\r
2178 typedef union _ual_dereg_mad_svc_ioctl\r
2179 {\r
2180         struct _ual_dereg_mad_svc_ioctl_in\r
2181         {\r
2182                 uint64_t                                        h_mad_svc;\r
2183 \r
2184         }       in;\r
2185         struct _ual_dereg_mad_svc_ioctl_out\r
2186         {\r
2187                 ib_api_status_t                         status;\r
2188 \r
2189         }       out;\r
2190 \r
2191 }       ual_dereg_mad_svc_ioctl_t;\r
2192 /*\r
2193 * FIELDS\r
2194 *       in.h_mad_svc\r
2195 *               Handle to the mad service.\r
2196 *\r
2197 *       out.status\r
2198 *               Status of the operation.\r
2199 *****/\r
2200 \r
2201 \r
2202 \r
2203 /****s* User-mode Access Layer/ual_reg_mad_pool_ioctl_t\r
2204 * NAME\r
2205 *       ual_reg_mad_pool_ioctl_t\r
2206 *\r
2207 * DESCRIPTION\r
2208 *       IOCTL structure containing the input and output parameters for\r
2209 *       registering a mad pool to be used with special qp. This ioctl\r
2210 *       will result in user-mode pool registered. Additionally,\r
2211 *       the kernel proxy will allocate a kernel mad pool and register it\r
2212 *       so that later mad_sends will have the appropriate pool in kernel.\r
2213 *\r
2214 * SYNOPSIS\r
2215 */\r
2216 typedef union _ual_reg_mad_pool_ioctl\r
2217 {\r
2218         struct _ual_reg_mad_pool_ioctl_in\r
2219         {\r
2220                 uint64_t                                        h_pd;\r
2221 \r
2222         }       in;\r
2223         struct _ual_reg_mad_pool_ioctl_out\r
2224         {\r
2225                 ib_api_status_t                         status;\r
2226                 uint64_t                                        pool_key;\r
2227 \r
2228         }       out;\r
2229 \r
2230 }       ual_reg_mad_pool_ioctl_t;\r
2231 /*\r
2232 * FIELDS\r
2233 *       in.h_pd\r
2234 *               PD associated with the pool\r
2235 *\r
2236 *       out.status\r
2237 *               Status of the operation.\r
2238 *\r
2239 *       out.pool_key\r
2240 *               Pool key to the mad pool in kernel space\r
2241 *****/\r
2242 \r
2243 \r
2244 \r
2245 /****s* User-mode Access Layer/ual_dereg_mad_pool_ioctl_t\r
2246 * NAME\r
2247 *       ual_dereg_mad_pool_ioctl_t\r
2248 *\r
2249 * DESCRIPTION\r
2250 *       IOCTL structure containing the input and output parameters for\r
2251 *       deregistering a mad pool to be used with special qp.\r
2252 *       The kernel proxy will deregister and destroy the mad pool\r
2253 *       created on behalf of the user process.\r
2254 *\r
2255 * SYNOPSIS\r
2256 */\r
2257 typedef union _ual_dereg_mad_pool_ioctl\r
2258 {\r
2259         struct _ual_dereg_mad_pool_ioctl_in\r
2260         {\r
2261                 uint64_t                                        pool_key;\r
2262 \r
2263         }       in;\r
2264         struct _ual_dereg_mad_pool_ioctl_out\r
2265         {\r
2266                 ib_api_status_t                         status;\r
2267 \r
2268         }       out;\r
2269 \r
2270 }       ual_dereg_mad_pool_ioctl_t;\r
2271 /*\r
2272 * FIELDS\r
2273 *       in.pool_key\r
2274 *               Pool key to the mad pool in kernel space.\r
2275 *\r
2276 *       out.status\r
2277 *               Status of the operation\r
2278 *****/\r
2279 \r
2280 \r
2281 \r
2282 /****s* User-mode Access Layer/ual_send_mad_ioctl_t\r
2283 * NAME\r
2284 *       ual_send_mad_ioctl_t\r
2285 *\r
2286 * DESCRIPTION\r
2287 *       IOCTL structure containing the input and output parameters for\r
2288 *       ib_send_mad\r
2289 *\r
2290 * SYNOPSIS\r
2291 */\r
2292 typedef union _ual_send_mad_ioctl\r
2293 {\r
2294         struct _ual_send_mad_ioctl_in\r
2295         {\r
2296                 uint64_t                                                h_mad_svc;\r
2297                 uint64_t                                                pool_key;\r
2298                 uint64_t                                                h_av;\r
2299                 TO_LONG_PTR(ib_mad_element_t* ,         p_mad_element) ;\r
2300                 uint32_t                                                size;\r
2301                 TO_LONG_PTR(void* *, /*__ptr64*/                ph_proxy) ;\r
2302 \r
2303         }       in;\r
2304         struct _ual_send_mad_ioctl_out\r
2305         {\r
2306                 ib_api_status_t                                 status;\r
2307 \r
2308         }       out;\r
2309 \r
2310 }       ual_send_mad_ioctl_t;\r
2311 /*\r
2312 * FIELDS\r
2313 *       in.h_mad_svc\r
2314 *               Handle to the mad service.\r
2315 *\r
2316 *       in.pool_key\r
2317 *               Pool key associated with the pool in kernel space.\r
2318 *\r
2319 *       in.h_av\r
2320 *               handle to address vector of MAD.\r
2321 *\r
2322 *       in.p_mad_element\r
2323 *               Pointer to the user-mode MAD element.  The proxy marshals this data.\r
2324 *\r
2325 *       in.size\r
2326 *               size of MAD buffer to send.\r
2327 *\r
2328 *       in.ph_proxy\r
2329 *               Location to which to write the context used to cancel the MAD.\r
2330 *\r
2331 *       out.status\r
2332 *               Status of the operation.\r
2333 *****/\r
2334 \r
2335 \r
2336 \r
2337 /****s* User-mode Access Layer/ual_cancel_mad_ioctl_t\r
2338 * NAME\r
2339 *       ual_cancel_mad_ioctl_t\r
2340 *\r
2341 * DESCRIPTION\r
2342 *       IOCTL structure containing the input and output parameters for\r
2343 *       ib_cancel_mad\r
2344 *\r
2345 * SYNOPSIS\r
2346 */\r
2347 typedef union _ual_cancel_mad_ioctl\r
2348 {\r
2349         struct _ual_cancel_mad_ioctl_in\r
2350         {\r
2351                 uint64_t                                        h_mad_svc;\r
2352                 TO_LONG_PTR(void* ,                             h_proxy_element) ;\r
2353 \r
2354         }       in;\r
2355         struct _ual_cancel_mad_ioctl_out\r
2356         {\r
2357                 ib_api_status_t                         status;\r
2358 \r
2359         }       out;\r
2360 \r
2361 }       ual_cancel_mad_ioctl_t;\r
2362 /*\r
2363 * FIELDS\r
2364 *       in.h_mad_svc\r
2365 *               contains the handle to the mad service\r
2366 *\r
2367 *       in.h_mad_send\r
2368 *               this references the handle to the sent MAD operation.\r
2369 *\r
2370 *       out.status\r
2371 *               Status of the operation.\r
2372 *****/\r
2373 \r
2374 \r
2375 \r
2376 /****s* User-mode Access Layer/ual_spl_qp_ioctl_t\r
2377 * NAME\r
2378 *       ual_spl_qp_ioctl_t\r
2379 *\r
2380 * DESCRIPTION\r
2381 *       IOCTL structure containing the input and output parameters to get\r
2382 *       the alias qp from KAL.\r
2383 *\r
2384 * SYNOPSIS\r
2385 */\r
2386 typedef union _ual_spl_qp_ioctl\r
2387 {\r
2388         struct _ual_spl_qp_ioctl_in\r
2389         {\r
2390                 ci_umv_buf_t                            umv_buf;\r
2391                 uint64_t                                        h_pd;\r
2392                 ib_net64_t                                      port_guid;\r
2393                 ib_qp_create_t                          qp_create;\r
2394                 TO_LONG_PTR(void* ,                             context) ;\r
2395 \r
2396         }       in;\r
2397         struct _ual_spl_qp_ioctl_out\r
2398         {\r
2399                 ci_umv_buf_t                            umv_buf;\r
2400                 ib_api_status_t                         status;\r
2401                 uint64_t                                        h_qp;\r
2402 \r
2403         }       out;\r
2404 \r
2405 }       ual_spl_qp_ioctl_t;\r
2406 /*\r
2407 * FIELDS\r
2408 *       in.h_pd\r
2409 *               Protection domain for the special qp.\r
2410 *\r
2411 *       in.port_guid\r
2412 *               Port GUID on which to allocate the special QP.\r
2413 *\r
2414 *       in.qp_create\r
2415 *               Special QP creation parameters.\r
2416 *\r
2417 *       in.qp_context\r
2418 *               Context to associate with the QP, to be used in any notifications.\r
2419 *\r
2420 *       out.status\r
2421 *               Status of the operation.\r
2422 *\r
2423 *       out.h_qp\r
2424 *               Handle to the special QP.\r
2425 *****/\r
2426 \r
2427 \r
2428 \r
2429 /****s* User-mode Access Layer/ual_mad_recv_ioctl_t\r
2430 * NAME\r
2431 *       ual_mad_recv_ioctl_t\r
2432 *\r
2433 * DESCRIPTION\r
2434 *       IOCTL structure containing the input and output parameters to get\r
2435 *       the mad_element information upon receiving MAD.\r
2436 *\r
2437 * SYNOPSIS\r
2438 */\r
2439 typedef union _ual_mad_recv_ioctl\r
2440 {\r
2441         struct _ual_mad_recv_comp_ioctl_in\r
2442         {\r
2443                 uint64_t                                        h_mad;\r
2444                 TO_LONG_PTR(ib_mad_element_t* , p_user_mad) ;\r
2445                 TO_LONG_PTR(ib_mad_t* ,                 p_mad_buf) ;\r
2446                 TO_LONG_PTR(ib_grh_t* ,                 p_grh) ;\r
2447 \r
2448         }       in;\r
2449         struct _ual_mad_recv_comp_ioctl_out\r
2450         {\r
2451                 ib_api_status_t                         status;\r
2452 \r
2453         }       out;\r
2454 \r
2455 } ual_mad_recv_ioctl_t;\r
2456 /*\r
2457 * FIELDS\r
2458 *       in.h_mad\r
2459 *               Received MAD handle handed to usermode in the MAD recv notification.\r
2460 *\r
2461 *       in.p_user_mad\r
2462 *               Pointer to a user-mode mad element.\r
2463 *\r
2464 *       in.p_mad_buf\r
2465 *               Pointer to the MAD element's user-mode buffer.\r
2466 *\r
2467 *       in.p_grh\r
2468 *               Ponter to the MAD element's user-mode GRH buffer.\r
2469 *\r
2470 *       out.status\r
2471 *               Status of the operation.\r
2472 *****/\r
2473 \r
2474 \r
2475 \r
2476 /****s* User-mode Access Layer/ual_local_mad_ioctl_t\r
2477 * NAME\r
2478 *       ual_local_mad_ioctl_t\r
2479 *\r
2480 * DESCRIPTION\r
2481 *       IOCTL structure containing the input and output parameters for\r
2482 *       ib_local_mad\r
2483 *\r
2484 * SYNOPSIS\r
2485 */\r
2486 typedef union _ual_local_mad_ioctl\r
2487 {\r
2488         struct _ual_local_mad_ioctl_in\r
2489         {\r
2490                 uint64_t                                        h_ca;\r
2491                 __declspec(align(8)) uint8_t mad_in[MAD_BLOCK_SIZE];\r
2492                 uint8_t                                         port_num;\r
2493                 \r
2494                 \r
2495         }       in;\r
2496         struct _ual_local_mad_ioctl_out\r
2497         {\r
2498                 ib_api_status_t                         status;\r
2499                 uint32_t                                        _pad; /* 8-byte alignment needed for ia64 */\r
2500                 __declspec(align(8)) uint8_t mad_out[MAD_BLOCK_SIZE];\r
2501 \r
2502         }       out;\r
2503 \r
2504 }       ual_local_mad_ioctl_t;\r
2505 /*\r
2506 ** FIELDS\r
2507 *       in.h_ca\r
2508 *               The handle to an open instance of CA returned via a\r
2509 *               ual_open_ca_ioctl structure.\r
2510 *       in.port_num\r
2511 *               Port number this MAD refere to.\r
2512 *       in.mad_in\r
2513 *               Mad structure from user mode to forward to local HCA.\r
2514 *\r
2515 **      out.status\r
2516 *               Status of the operation.\r
2517 *       out.mad_out\r
2518 *               Mad structure answer from local HCA for user mode.\r
2519 *****/\r
2520 \r
2521 \r
2522 \r
2523 /****s* User-mode Access Layer/ual_create_cep_ioctl_t\r
2524 * NAME\r
2525 *       ual_create_cep_ioctl_t\r
2526 *\r
2527 * DESCRIPTION\r
2528 *       IOCTL structure containing the output parameters to\r
2529 *       create a CEP.\r
2530 *\r
2531 * SYNOPSIS\r
2532 */\r
2533 typedef struct _ual_create_cep_ioctl\r
2534 {\r
2535         ib_api_status_t                         status;\r
2536         net32_t                                         cid;\r
2537 \r
2538 }       ual_create_cep_ioctl_t;\r
2539 /*\r
2540 * FIELDS\r
2541 *       status\r
2542 *               Status of the operation.\r
2543 *\r
2544 *       cid\r
2545 *               CID of the created CEP.\r
2546 *****/\r
2547 \r
2548 /****s* User-mode Access Layer/ual_create_cep_ioctl_in\r
2549 * NAME\r
2550 *       ual_create_cep_ioctl_in\r
2551 *\r
2552 * DESCRIPTION\r
2553 *       IOCTL structure containing the input parameters to\r
2554 *       create a CEP.\r
2555 *\r
2556 * SYNOPSIS\r
2557 */\r
2558 \r
2559 typedef struct _ual_create_cep_ioctl_in\r
2560 {\r
2561     TO_LONG_PTR(void* , context);\r
2562 } ual_create_cep_ioctl_in;\r
2563 \r
2564 /*\r
2565 * FIELDS\r
2566 *       context\r
2567 *               \r
2568 *               \r
2569 *****/\r
2570 \r
2571 \r
2572 /****s* User-mode Access Layer/ual_cep_listen_ioctl_t\r
2573 * NAME\r
2574 *       ual_cep_listen_ioctl_t\r
2575 *\r
2576 * DESCRIPTION\r
2577 *       IOCTL structure containing the input parameters to\r
2578 *       perform a CM listen request.\r
2579 *\r
2580 * SYNOPSIS\r
2581 */\r
2582 typedef struct _ual_cep_listen_ioctl\r
2583 {\r
2584         net32_t                                         cid;\r
2585         ib_cep_listen_t                         cep_listen;\r
2586         uint8_t                                         compare[IB_REQ_PDATA_SIZE];\r
2587 \r
2588 }       ual_cep_listen_ioctl_t;\r
2589 /*\r
2590 * FIELDS\r
2591 *       in.cid\r
2592 *               CID of an existing CEP.\r
2593 *\r
2594 *       in.cep_listen\r
2595 *               Information used to direct the listen request to match incoming\r
2596 *               connection requests.\r
2597 *****/\r
2598 \r
2599 \r
2600 \r
2601 /****s* User-mode Access Layer/ual_cm_req_ioctl_t\r
2602 * NAME\r
2603 *       ual_cm_req_ioctl_t\r
2604 *\r
2605 * DESCRIPTION\r
2606 *       IOCTL structure containing the input and output parameters for\r
2607 *       al_cep_pre_req call.\r
2608 *\r
2609 * SYNOPSIS\r
2610 */\r
2611 typedef union _ual_cep_req_ioctl\r
2612 {\r
2613         struct _ual_cep_req_ioctl_in\r
2614         {\r
2615                 net32_t                                         cid;\r
2616                 ib_cm_req_t                                     cm_req;\r
2617                 ib_path_rec_t                           paths[2];\r
2618                 uint8_t                                         pdata[IB_REQ_PDATA_SIZE];\r
2619                 uint8_t                                         compare[IB_REQ_PDATA_SIZE];\r
2620 \r
2621         }       in;\r
2622         struct _ual_cep_req_ioctl_out\r
2623         {\r
2624                 ib_api_status_t                         status;\r
2625                 ib_qp_mod_t                                     init;\r
2626 \r
2627         }       out;\r
2628 \r
2629 }       ual_cep_req_ioctl_t;\r
2630 /*\r
2631 * FIELDS\r
2632 *       in.cid\r
2633 *               CID of the target CEP.\r
2634 *\r
2635 *       in.cm_req\r
2636 *               CM REQ parameters.\r
2637 *\r
2638 *       in.paths\r
2639 *               Array of paths, the first being the primary path to use for the REQ.\r
2640 *\r
2641 *       out.status\r
2642 *               Status of the operation\r
2643 *\r
2644 *       out.init\r
2645 *               QP modify paramters for INIT state transition.\r
2646 *****/\r
2647 \r
2648 \r
2649 \r
2650 /****s* User-mode Access Layer/ual_cep_rep_ioctl_t\r
2651 * NAME\r
2652 *       ual_cep_rep_ioctl_t\r
2653 *\r
2654 * DESCRIPTION\r
2655 *       IOCTL structure containing the input and output parameters for\r
2656 *       al_cep_pre_rep call.\r
2657 *\r
2658 * SYNOPSIS\r
2659 */\r
2660 typedef union _ual_cep_rep_ioctl\r
2661 {\r
2662         struct _ual_cep_rep_ioctl_in\r
2663         {\r
2664                 TO_LONG_PTR(void* ,                             context) ;\r
2665                 net32_t                                         cid;\r
2666                 ib_cm_rep_t                                     cm_rep;\r
2667                 uint8_t                                         pdata[IB_REP_PDATA_SIZE];\r
2668 \r
2669         }       in;\r
2670         struct _ual_cep_rep_ioctl_out\r
2671         {\r
2672                 ib_api_status_t                         status;\r
2673                 ib_qp_mod_t                                     init;\r
2674 \r
2675         }       out;\r
2676 \r
2677 }       ual_cep_rep_ioctl_t;\r
2678 /*\r
2679 * FIELDS\r
2680 *       in.h_cm_req\r
2681 *               The cm_req connection handle got on the callback.\r
2682 *\r
2683 *       in.cm_rep\r
2684 *               CM REP parameters.\r
2685 *\r
2686 *       out.status\r
2687 *               Status of the operation.\r
2688 *\r
2689 *       out.init\r
2690 *               QP modify paramters for INIT state transition.\r
2691 *****/\r
2692 \r
2693 \r
2694 \r
2695 /****s* User-mode Access Layer/ual_cep_get_rtr_ioctl_t\r
2696 * NAME\r
2697 *       ual_cep_get_rtr_ioctl_t\r
2698 *\r
2699 * DESCRIPTION\r
2700 *       IOCTL structure containing the output parameters for\r
2701 *       al_cep_get_rtr_attr call.\r
2702 *\r
2703 * SYNOPSIS\r
2704 */\r
2705 typedef struct _ual_cep_get_rtr_ioctl\r
2706 {\r
2707         ib_api_status_t                         status;\r
2708         ib_qp_mod_t                                     rtr;\r
2709 \r
2710 }       ual_cep_get_rtr_ioctl_t;\r
2711 /*\r
2712 * FIELDS\r
2713 *       out.status\r
2714 *               Status of the operation.\r
2715 *\r
2716 *       out.rtr\r
2717 *               QP modify paramters for RTR state transition.\r
2718 *****/\r
2719 \r
2720 \r
2721 \r
2722 /****s* User-mode Access Layer/ual_cep_get_rts_ioctl_t\r
2723 * NAME\r
2724 *       ual_cep_get_rts_ioctl_t\r
2725 *\r
2726 * DESCRIPTION\r
2727 *       IOCTL structure containing the output parameters for\r
2728 *       al_cep_get_rts_attr call.\r
2729 *\r
2730 * SYNOPSIS\r
2731 */\r
2732 typedef struct _ual_cep_get_rts_ioctl\r
2733 {\r
2734         ib_api_status_t                         status;\r
2735         ib_qp_mod_t                                     rts;\r
2736 \r
2737 }       ual_cep_get_rts_ioctl_t;\r
2738 /*\r
2739 * FIELDS\r
2740 *       out.status\r
2741 *               Status of the operation.\r
2742 *\r
2743 *       out.rts\r
2744 *               QP modify paramters for RTS state transition.\r
2745 *****/\r
2746 \r
2747 \r
2748 \r
2749 /****s* User-mode Access Layer/ual_cep_rtu_ioctl_t\r
2750 * NAME\r
2751 *       ual_cep_rtu_ioctl_t\r
2752 *\r
2753 * DESCRIPTION\r
2754 *       IOCTL structure containing the input parameters for\r
2755 *       al_cep_rtu call.\r
2756 *\r
2757 * SYNOPSIS\r
2758 */\r
2759 typedef struct _ual_cep_rtu_ioctl\r
2760 {\r
2761         net32_t                                         cid;\r
2762         uint8_t                                         pdata_len;\r
2763         uint8_t                                         pdata[IB_RTU_PDATA_SIZE];\r
2764 \r
2765 }       ual_cep_rtu_ioctl_t;\r
2766 /*\r
2767 * FIELDS\r
2768 *       in.cid\r
2769 *               The cm_rep connection handle got on the callback.\r
2770 *\r
2771 *       in.pdata_len\r
2772 *               Length of private data.\r
2773 *\r
2774 *       in.pdata\r
2775 *               Private data.\r
2776 *****/\r
2777 \r
2778 \r
2779 \r
2780 /****s* User-mode Access Layer/ual_cep_rej_ioctl_t\r
2781 * NAME\r
2782 *       ual_cep_rej_ioctl_t\r
2783 *\r
2784 * DESCRIPTION\r
2785 *       IOCTL structure containing the input parameters for\r
2786 *       al_cep_rej\r
2787 *\r
2788 * SYNOPSIS\r
2789 */\r
2790 typedef struct _ual_cep_rej_ioctl\r
2791 {\r
2792         net32_t                                         cid;\r
2793 \r
2794         ib_rej_status_t                         rej_status;\r
2795         uint8_t                                         ari_len;\r
2796         uint8_t                                         pdata_len;\r
2797         uint8_t                                         ari[IB_ARI_SIZE];\r
2798         uint8_t                                         pdata[IB_REJ_PDATA_SIZE];\r
2799 \r
2800 }       ual_cep_rej_ioctl_t;\r
2801 /*\r
2802 * FIELDS\r
2803 *       in.cid\r
2804 *               The CID of the target CEP.\r
2805 *\r
2806 *       in.rej_status\r
2807 *               Rejection status as defined in IB spec.\r
2808 *\r
2809 *       in.ari_len\r
2810 *               Length of the ARI data.\r
2811 *\r
2812 *       in.pdata_len\r
2813 *               Length of the private data.\r
2814 *\r
2815 *       in.ari\r
2816 *               ARI data.\r
2817 *\r
2818 *       in.pdata\r
2819 *               Private data.\r
2820 *****/\r
2821 \r
2822 \r
2823 \r
2824 /****s* User-mode Access Layer/ual_cep_handoff_ioctl_t\r
2825 * NAME\r
2826 *       ual_cep_handoff_ioctl_t\r
2827 *\r
2828 * DESCRIPTION\r
2829 *       IOCTL structure containing the input and output parameters for\r
2830 *       ib_cm_handoff\r
2831 *\r
2832 * SYNOPSIS\r
2833 */\r
2834 typedef union _ual_cep_handoff_ioctl\r
2835 {\r
2836         struct _ual_cep_handoff_ioctl_in\r
2837         {\r
2838                 uint64_t                                        h_cm;\r
2839                 net64_t                                         sid;\r
2840 \r
2841         }       in;\r
2842         struct _ual_cep_handoff_ioctl_out\r
2843         {\r
2844                 ib_api_status_t                         status;\r
2845 \r
2846         }       out;\r
2847 \r
2848 }       ual_cep_handoff_ioctl_t;\r
2849 /*\r
2850 * FIELDS\r
2851 *       in.h_cm\r
2852 *               The connection handle got on the callback.\r
2853 *\r
2854 *       in.sid\r
2855 *               Service ID to which to handoff the listen.\r
2856 *\r
2857 *       out.status\r
2858 *               Status of the operation\r
2859 *****/\r
2860 \r
2861 \r
2862 \r
2863 /****s* User-mode Access Layer/ual_cep_mra_ioctl_t\r
2864 * NAME\r
2865 *       ual_cep_mra_ioctl_t\r
2866 *\r
2867 * DESCRIPTION\r
2868 *       IOCTL structure containing the input parameters for\r
2869 *       ib_cm_mra\r
2870 *\r
2871 * SYNOPSIS\r
2872 */\r
2873 typedef struct _ual_cep_mra_ioctl\r
2874 {\r
2875         net32_t                                         cid;\r
2876         ib_cm_mra_t                                     cm_mra;\r
2877         uint8_t                                         pdata[IB_MRA_PDATA_SIZE];\r
2878 \r
2879 }       ual_cep_mra_ioctl_t;\r
2880 /*\r
2881 * FIELDS\r
2882 *       in.cid\r
2883 *               The CID for the target CEP.\r
2884 *\r
2885 *       in.cm_mra\r
2886 *               CM MRA parameters.\r
2887 *****/\r
2888 \r
2889 \r
2890 \r
2891 /****s* User-mode Access Layer/ual_cep_lap_ioctl_t\r
2892 * NAME\r
2893 *       ual_cep_lap_ioctl_t\r
2894 *\r
2895 * DESCRIPTION\r
2896 *       IOCTL structure containing the input parameters for\r
2897 *       ib_cm_lap\r
2898 *\r
2899 * SYNOPSIS\r
2900 */\r
2901 typedef struct _ual_cep_lap_ioctl\r
2902 {\r
2903         net32_t                                         cid;\r
2904         ib_cm_lap_t                                     cm_lap;\r
2905         ib_path_rec_t                           alt_path;\r
2906         uint8_t                                         pdata[IB_LAP_PDATA_SIZE];\r
2907 \r
2908 }       ual_cep_lap_ioctl_t;\r
2909 /*\r
2910 * FIELDS\r
2911 *       in.cm_lap\r
2912 *               CM LAP parameters\r
2913 *\r
2914 *       in.alt_path\r
2915 *               Alternate path information.\r
2916 *****/\r
2917 \r
2918 \r
2919 \r
2920 /****s* User-mode Access Layer/ual_cep_apr_ioctl_t\r
2921 * NAME\r
2922 *       ual_cep_apr_ioctl_t\r
2923 *\r
2924 * DESCRIPTION\r
2925 *       IOCTL structure containing the input parameters for\r
2926 *       ib_cep_apr\r
2927 *\r
2928 * SYNOPSIS\r
2929 */\r
2930 typedef union _ual_cep_apr_ioctl\r
2931 {\r
2932         struct _ual_cep_apr_ioctl_in\r
2933         {\r
2934                 net32_t                                 cid;\r
2935                 ib_cm_apr_t                             cm_apr;\r
2936                 uint8_t                                 apr_info[IB_APR_INFO_SIZE];\r
2937                 uint8_t                                 pdata[IB_APR_PDATA_SIZE];\r
2938 \r
2939         }       in;\r
2940 \r
2941         struct _ual_cep_apr_ioctl_out\r
2942         {\r
2943                 ib_api_status_t                 status;\r
2944                 ib_qp_mod_t                             apr;\r
2945 \r
2946         }       out;\r
2947 \r
2948 }       ual_cep_apr_ioctl_t;\r
2949 /*\r
2950 * FIELDS\r
2951 *       in.h_cm_lap\r
2952 *               The cm_lap connection handle got on the LAP callback.\r
2953 *\r
2954 *       in.cm_apr\r
2955 *               CM APR parameters.\r
2956 *****/\r
2957 \r
2958 \r
2959 \r
2960 /****s* User-mode Access Layer/ual_force_apm_ioctl_t\r
2961 * NAME\r
2962 *       ual_force_apm_ioctl_t\r
2963 *\r
2964 * DESCRIPTION\r
2965 *       IOCTL structure containing the input and output parameters for\r
2966 *       ib_force_apm\r
2967 *\r
2968 * SYNOPSIS\r
2969 */\r
2970 typedef union _ual_force_apm_ioctl\r
2971 {\r
2972         union _ual_force_apm_ioctl_in\r
2973         {\r
2974                 uint64_t                                        h_qp;\r
2975 \r
2976         }       in;\r
2977         struct _ual_force_apm_ioctl_out\r
2978         {\r
2979                 ib_api_status_t                         status;\r
2980 \r
2981         }       out;\r
2982 \r
2983 }       ual_force_apm_ioctl_t;\r
2984 /*\r
2985 * FIELDS\r
2986 *       in.h_qp\r
2987 *               A handle to the QP to migrate.\r
2988 *\r
2989 *       out.status\r
2990 *               Status of the operation\r
2991 *****/\r
2992 \r
2993 \r
2994 \r
2995 /****s* User-mode Access Layer/ual_cep_dreq_ioctl_t\r
2996 * NAME\r
2997 *       ual_cep_dreq_ioctl_t\r
2998 *\r
2999 * DESCRIPTION\r
3000 *       IOCTL structure containing the input parameters for\r
3001 *       ib_cm_dreq\r
3002 *\r
3003 * SYNOPSIS\r
3004 */\r
3005 typedef struct _ual_cep_dreq_ioctl\r
3006 {\r
3007         net32_t                                         cid;\r
3008         uint8_t                                         pdata_len;\r
3009         uint8_t                                         pdata[IB_DREQ_PDATA_SIZE];\r
3010 \r
3011 }       ual_cep_dreq_ioctl_t;\r
3012 /*\r
3013 * FIELDS\r
3014 *       cm_dreq\r
3015 *               CM DREQ parameters.\r
3016 *****/\r
3017 \r
3018 \r
3019 \r
3020 /****s* User-mode Access Layer/ual_cep_drep_ioctl_t\r
3021 * NAME\r
3022 *       ual_cep_drep_ioctl_t\r
3023 *\r
3024 * DESCRIPTION\r
3025 *       IOCTL structure containing the input and output parameters for\r
3026 *       ib_cm_drep\r
3027 *\r
3028 * SYNOPSIS\r
3029 */\r
3030 typedef struct _ual_cep_drep_ioctl\r
3031 {\r
3032         net32_t                                         cid;\r
3033         uint8_t                                         pdata_len;\r
3034         uint8_t                                         pdata[IB_DREP_PDATA_SIZE];\r
3035 \r
3036 }       ual_cep_drep_ioctl_t;\r
3037 /*\r
3038 * FIELDS\r
3039 *       in.h_cm_dreq\r
3040 *               The cm_dreq connection handle got on the callback.\r
3041 *\r
3042 *       in.cm_drep\r
3043 *               CM DREP parameters.\r
3044 *****/\r
3045 \r
3046 \r
3047 \r
3048 /****s* User-mode Access Layer/ual_cep_get_timewait_ioctl_t\r
3049 * NAME\r
3050 *       ual_cep_get_timewait_ioctl_t\r
3051 *\r
3052 * DESCRIPTION\r
3053 *       IOCTL structure containing the output parameters for\r
3054 *       ib_cep_get_timewait\r
3055 *\r
3056 * SYNOPSIS\r
3057 */\r
3058 typedef struct _ual_cep_get_timewait_ioctl\r
3059 {\r
3060         ib_api_status_t                         status;\r
3061         uint64_t                                        timewait_us;\r
3062 \r
3063 }       ual_cep_get_timewait_ioctl_t;\r
3064 /*\r
3065 * FIELDS\r
3066 *       in.status\r
3067 *               Status of the request.\r
3068 *\r
3069 *       in.timewait_us\r
3070 *               Timewait value, in microseconds.\r
3071 *****/\r
3072 \r
3073 \r
3074 \r
3075 /****s* User-mode Access Layer/ual_cep_poll_ioctl_t\r
3076 * NAME\r
3077 *       ual_cep_poll_ioctl_t\r
3078 *\r
3079 * DESCRIPTION\r
3080 *       IOCTL structure containing the output parameters to\r
3081 *       poll for incoming events on a CEP.  The input parameter is the CID.\r
3082 *\r
3083 * SYNOPSIS\r
3084 */\r
3085 typedef struct _ual_cep_poll_ioctl\r
3086 {\r
3087         ib_api_status_t                         status;\r
3088         TO_LONG_PTR(void* ,                             context) ;\r
3089         net32_t                                         new_cid;\r
3090         ib_mad_element_t                        element;\r
3091         ib_grh_t                                        grh;\r
3092         uint8_t                                         mad_buf[MAD_BLOCK_SIZE];\r
3093 \r
3094 }       ual_cep_poll_ioctl_t;\r
3095 /*\r
3096 * FIELDS\r
3097 *       status\r
3098 *               Status of the operation.\r
3099 *\r
3100 *       new_cep\r
3101 *               For listen requests, CEP information of CEPs created in response\r
3102 *               to incoming REQs.\r
3103 *\r
3104 *       mad_buf\r
3105 *               Payload of a received MAD (or failed send)\r
3106 *****/\r
3107 \r
3108 \r
3109 \r
3110 /****s* User-mode Access Layer/ual_cep_get_pdata_t\r
3111 * NAME\r
3112 *       ual_cep_get_pdata_t\r
3113 *\r
3114 * DESCRIPTION\r
3115 *       IOCTL structure containing the input parameters for\r
3116 *       getting private data of CM RDMA request\r
3117 *\r
3118 * SYNOPSIS\r
3119 */\r
3120 typedef union _ual_cep_get_pdata_ioctl\r
3121 {\r
3122         struct _ual_cep_get_pdata_ioctl_in\r
3123         {\r
3124                 uint64_t                                h_qp;\r
3125                 net32_t                                 cid;\r
3126 \r
3127         }       in;\r
3128 \r
3129         struct _ual_cep_get_pdata_ioctl_out\r
3130         {\r
3131                 uint32_t                                pdata_len;\r
3132                 uint8_t                                 pdata[IB_REJ_PDATA_SIZE];\r
3133         uint8_t                 resp_res;\r
3134         uint8_t                 init_depth;\r
3135 \r
3136         }       out;\r
3137 \r
3138 }       ual_cep_get_pdata_ioctl_t;\r
3139 /*\r
3140 * FIELDS\r
3141 *       h_qp\r
3142 *               A handle to the QP to modify.\r
3143 *\r
3144 *       in.cid\r
3145 *               The CID for the target CEP.\r
3146 *\r
3147 *       out.pdata_len\r
3148 *               The size of the private data\r
3149 *\r
3150 *       out.pdata\r
3151 *               The private data.\r
3152 *****/\r
3153 \r
3154 \r
3155 \r
3156 /****s* User-mode Access Layer/ual_reg_shmid_ioctl_t\r
3157 * NAME\r
3158 *       ual_reg_shmid_ioctl_t\r
3159 *\r
3160 * DESCRIPTION\r
3161 *       IOCTL structure containing the input and output parameters for\r
3162 *       ib_create_shmid\r
3163 *\r
3164 * SYNOPSIS\r
3165 */\r
3166 typedef union _ual_reg_shmid_ioctl\r
3167 {\r
3168         struct _ual_reg_shmid_ioctl_in\r
3169         {\r
3170                 uint64_t                                        h_pd;\r
3171                 ib_shmid_t                                      shmid;\r
3172                 ib_mr_create_t                          mr_create;\r
3173 \r
3174         }       in;\r
3175         struct _ual_reg_shmid_ioctl_out\r
3176         {\r
3177                 ib_api_status_t                         status;\r
3178                 uint64_t                                        vaddr;\r
3179                 net32_t                                         lkey;\r
3180                 net32_t                                         rkey;\r
3181                 uint64_t                                        h_mr;\r
3182 \r
3183         }       out;\r
3184 \r
3185 }       ual_reg_shmid_ioctl_t;\r
3186 /*\r
3187 * PARAMETERS\r
3188 *       in.h_pd\r
3189 *               A handle to an existing protection domain that the memory\r
3190 *               should be registered with.\r
3191 *\r
3192 *       in.shmid\r
3193 *               An identifier to the shared memory region.\r
3194 *\r
3195 *       in.mr_create\r
3196 *               Information describing the attributes of the memory region to\r
3197 *               register.\r
3198 *\r
3199 *       out.status\r
3200 *               Status of the operation.\r
3201 *\r
3202 *       out.vaddr\r
3203 *               Assigned I/O virtual address for the memory region.\r
3204 *\r
3205 *       out.lkey\r
3206 *               The local access key associated with this registered memory\r
3207 *               region.\r
3208 *\r
3209 *       out.rkey\r
3210 *               A key that may be used by a remote end-point when performing RDMA\r
3211 *               or atomic operations to this registered memory region.\r
3212 *\r
3213 *       out.h_mr\r
3214 *               Upon successful completion of this call, this references a handle\r
3215 *               to the registered memory region.  This handle is used when performing\r
3216 *               data transfers and to deregister the memory.\r
3217 *****/\r
3218 \r
3219 \r
3220 \r
3221 /****s* User-mode Access Layer/ual_send_sa_req_t\r
3222 * NAME\r
3223 *       ual_send_sa_req_t\r
3224 *\r
3225 * DESCRIPTION\r
3226 *       IOCTL structure containing the input and output parameters for\r
3227 *       ib_create_shmid\r
3228 *\r
3229 * SYNOPSIS\r
3230 */\r
3231 typedef union _ual_send_sa_req_ioctl\r
3232 {\r
3233         struct _ual_send_sa_req_ioctl_in\r
3234         {\r
3235                 net64_t                                         port_guid;\r
3236                 uint32_t                                        timeout_ms;\r
3237                 uint32_t                                        retry_cnt;\r
3238                 ib_user_query_t                         sa_req;\r
3239                 uint8_t                                         attr[IB_SA_DATA_SIZE];\r
3240                 TO_LONG_PTR(uint64_t* ,                 ph_sa_req) ;\r
3241                 TO_LONG_PTR(ib_api_status_t* ,  p_status) ;\r
3242 \r
3243         }       in;\r
3244         struct _ual_send_sa_req_ioctl_out\r
3245         {\r
3246                 ib_api_status_t                         status;\r
3247                 uint64_t                                        h_resp;\r
3248                 uint32_t                                        resp_size;\r
3249 \r
3250         }       out;\r
3251 \r
3252 }       ual_send_sa_req_ioctl_t;\r
3253 /*\r
3254 * PARAMETERS\r
3255 *       in.sa_mad_data\r
3256 *               The SA request to send.\r
3257 *\r
3258 *       in.attr\r
3259 *               The SA attribute data to send.\r
3260 *\r
3261 *       in.ph_sa_req\r
3262 *               Pointer to UAL's query handle.  The proxy fills this in\r
3263 *               before returning from the IOCTL handler to allow cancelation.\r
3264 *\r
3265 *       in.p_status\r
3266 *               Pointer to status of the query.\r
3267 *\r
3268 *       out.status\r
3269 *               Status of the query if it was initiated successfully.\r
3270 *\r
3271 *       out.h_resp\r
3272 *               Handle to a response MAD.\r
3273 *\r
3274 *       out.resp_size\r
3275 *               Size, in bytes, of the response MAD's buffer.\r
3276 *****/\r
3277 \r
3278 \r
3279 \r
3280 /****s* User-mode Access Layer/ual_cancel_sa_req_ioctl_t\r
3281 * NAME\r
3282 *       ual_cancel_sa_req_ioctl_t\r
3283 *\r
3284 * DESCRIPTION\r
3285 *       IOCTL structure containing the input parameters for cancelling an\r
3286 *       SA request.\r
3287 *\r
3288 * SYNOPSIS\r
3289 */\r
3290 typedef struct _ual_cancel_sa_req_ioctl\r
3291 {\r
3292         uint64_t                        h_sa_req;\r
3293 \r
3294 }       ual_cancel_sa_req_ioctl_t;\r
3295 /*\r
3296 * PARAMETERS\r
3297 *       h_sa_req\r
3298 *               Handle to the query to cancel.\r
3299 *****/\r
3300 \r
3301 \r
3302 \r
3303 /****s* User-mode Access Layer/ual_reg_pnp_ioctl_in_t\r
3304 * NAME\r
3305 *       ual_reg_pnp_ioctl_in_t\r
3306 *\r
3307 * DESCRIPTION\r
3308 *       IOCTL structure containing the input parameters for registering\r
3309 *       for PnP events.\r
3310 *\r
3311 * SYNOPSIS\r
3312 */\r
3313 typedef struct _ual_reg_pnp_ioctl_in\r
3314 {\r
3315         ib_pnp_class_t                          pnp_class;\r
3316         TO_LONG_PTR(void* ,                             sync_event) ;\r
3317         TO_LONG_PTR(ib_api_status_t* ,  p_status) ;\r
3318         TO_LONG_PTR(uint64_t* ,                 p_hdl) ;\r
3319 \r
3320 }       ual_reg_pnp_ioctl_in_t;\r
3321 /*\r
3322 * NOTES\r
3323 *       This is an asynchronous IOCTL.\r
3324 *\r
3325 *       The output parameters are a ual_rearm_pnp_ioctl_out_t.\r
3326 *\r
3327 * PARAMETERS\r
3328 *       pnp_class\r
3329 *               Class of PnP events for which to register.\r
3330 *\r
3331 *       p_status\r
3332 *               Pointer to user-mode status variable to set in failure case.\r
3333 *\r
3334 *       p_hdl\r
3335 *               Pointer to user-mode handle variable to set in success case.\r
3336 *****/\r
3337 \r
3338 \r
3339 \r
3340 /****s* User-mode Access Layer/ual_poll_pnp_ioctl_t\r
3341 * NAME\r
3342 *       ual_poll_pnp_ioctl_t\r
3343 *\r
3344 * DESCRIPTION\r
3345 *       IOCTL structure containing the parameters for retriveing data for\r
3346 *       a PnP event.\r
3347 *\r
3348 * SYNOPSIS\r
3349 */\r
3350 typedef union _ual_poll_pnp_ioctl\r
3351 {\r
3352         struct _ual_poll_pnp_ioctl_in\r
3353         {\r
3354                 uint64_t                                        evt_hdl;\r
3355 \r
3356         }       in;\r
3357         struct _ual_poll_pnp_ioctl_out\r
3358         {\r
3359                 ib_pnp_rec_t                            pnp_rec;\r
3360 \r
3361         }       out;\r
3362 \r
3363 }       ual_poll_pnp_ioctl_t;\r
3364 /*\r
3365 * NOTES\r
3366 *       This is a synchronous IOCTL.\r
3367 *\r
3368 * PARAMETERS\r
3369 *       in.evt_hdl\r
3370 *               Handle to a new PnP event.\r
3371 *\r
3372 *       out.pnp_rec\r
3373 *               Buffer for the new PnP event.\r
3374 *****/\r
3375 \r
3376 \r
3377 \r
3378 /****s* User-mode Access Layer/ual_rearm_pnp_ioctl_in_t\r
3379 * NAME\r
3380 *       ual_rearm_pnp_ioctl_in_t\r
3381 *\r
3382 * DESCRIPTION\r
3383 *       IOCTL structure containing the input parameters for requesting\r
3384 *       notification of the next PnP event.\r
3385 *\r
3386 * SYNOPSIS\r
3387 */\r
3388 typedef struct _ual_rearm_pnp_ioctl_in\r
3389 {\r
3390         uint64_t                                        pnp_hdl;\r
3391         uint64_t                                        last_evt_hdl;\r
3392         TO_LONG_PTR(void* ,                             last_evt_context) ;\r
3393         ib_api_status_t                         last_evt_status;\r
3394 \r
3395 }       ual_rearm_pnp_ioctl_in_t;\r
3396 /*\r
3397 * NOTES\r
3398 *       This is an asynchronous IOCTL.\r
3399 *\r
3400 *       The output parameters are a ual_rearm_pnp_ioctl_out_t.\r
3401 *\r
3402 * PARAMETERS\r
3403 *       pnp_hdl\r
3404 *               Handle to the PnP registration to rearm.\r
3405 *\r
3406 *       last_evt_hdl\r
3407 *               Handle to the last PnP event processed.\r
3408 *\r
3409 *       last_evt_context\r
3410 *               Context value to set for the last reported PnP event.\r
3411 *\r
3412 *       last_evt_status\r
3413 *               Status value to return for the last reported PnP event.\r
3414 *****/\r
3415 \r
3416 \r
3417 \r
3418 /****s* User-mode Access Layer/ual_rearm_pnp_ioctl_out_t\r
3419 * NAME\r
3420 *       ual_rearm_pnp_ioctl_out_t\r
3421 *\r
3422 * DESCRIPTION\r
3423 *       IOCTL structure containing the output parameters for a PnP event.\r
3424 *\r
3425 * SYNOPSIS\r
3426 */\r
3427 typedef struct _ual_rearm_pnp_ioctl_out\r
3428 {\r
3429         uint64_t                                        evt_hdl;\r
3430         uint32_t                                        evt_size;\r
3431 \r
3432 }       ual_rearm_pnp_ioctl_out_t;\r
3433 /*\r
3434 * NOTES\r
3435 *       This is an asynchronous IOCTL.\r
3436 *\r
3437 *       The output parameters are identical to that of ual_reg_pnp_ioctl_t.\r
3438 *\r
3439 * PARAMETERS\r
3440 *       evt_hdl\r
3441 *               Handle to a new PnP event.\r
3442 *\r
3443 *       evt_size\r
3444 *               Buffer size needed to poll the new PnP event.\r
3445 *****/\r
3446 \r
3447 \r
3448 \r
3449 /****s* User-mode Access Layer/ual_dereg_pnp_ioctl_t\r
3450 * NAME\r
3451 *       ual_dereg_pnp_ioctl_t\r
3452 *\r
3453 * DESCRIPTION\r
3454 *       IOCTL structure containing the input parameters for cancelling an\r
3455 *       SA request.\r
3456 *\r
3457 * SYNOPSIS\r
3458 */\r
3459 typedef struct _ual_dereg_pnp_ioctl\r
3460 {\r
3461         uint64_t                        h_pnp;\r
3462 \r
3463 }       ual_dereg_pnp_ioctl_t;\r
3464 /*\r
3465 * NOTES\r
3466 *       This is an asynchronous IOCTL.\r
3467 *\r
3468 * PARAMETERS\r
3469 *       h_pnp\r
3470 *               Handle to the PnP registration to deregister.\r
3471 *****/\r
3472 \r
3473 /****s* User-mode Access Layer/ual_ndi_notify_cq_ioctl_in_t\r
3474 * NAME\r
3475 *       ual_ndi_notify_cq_ioctl_in_t\r
3476 *\r
3477 * DESCRIPTION\r
3478 *       IOCTL structure containing the input parameters for requesting\r
3479 *       notification of the next event on NDI CQ.\r
3480 *\r
3481 * SYNOPSIS\r
3482 */\r
3483 typedef struct _ual_ndi_notify_cq_ioctl_in\r
3484 {\r
3485         uint64_t                                        h_cq;\r
3486         boolean_t                                       notify_comps;\r
3487 \r
3488 }       ual_ndi_notify_cq_ioctl_in_t;\r
3489 /*\r
3490 * NOTES\r
3491 *       This is an asynchronous IOCTL.\r
3492 *\r
3493 * FIELDS\r
3494 *       h_cq\r
3495 *               A handle to the CQ to modify.\r
3496 *\r
3497 *       notify_comps\r
3498 *               Type of notification, requested. If TRUE - completion events, \r
3499 *               otherwise - errors.\r
3500 *\r
3501 *****/\r
3502 \r
3503 /****s* User-mode Access Layer/ual_ndi_req_cm_ioctl_in_t\r
3504 * NAME\r
3505 *       ual_ndi_req_cm_ioctl_in_t\r
3506 *\r
3507 * DESCRIPTION\r
3508 *       IOCTL structure containing the input parameters \r
3509 *       sending CM REQ .\r
3510 *\r
3511 * SYNOPSIS\r
3512 */\r
3513 typedef struct _ual_ndi_req_cm_ioctl_in\r
3514 {\r
3515     ib_gid_pair_t               gids;\r
3516         uint64_t                                        h_qp;\r
3517         net64_t                                         guid;\r
3518         uint16_t                                        dst_port;\r
3519     uint8_t                     resp_res;\r
3520     uint8_t                     init_depth;\r
3521         uint8_t                                         prot;\r
3522         uint8_t                                         pdata_size;\r
3523         ib_cm_rdma_req_t                        pdata;\r
3524 \r
3525 }       ual_ndi_req_cm_ioctl_in_t;\r
3526 /*\r
3527 * NOTES\r
3528 *       The output parameter is the new QP state (RTS).\r
3529 *\r
3530 * FIELDS\r
3531 *       h_qp\r
3532 *               A handle to the QP to modify.\r
3533 *\r
3534 *       guid\r
3535 *               Local port GUID to which to bind to.\r
3536 *\r
3537 *       dst_port\r
3538 *               Destination port number.\r
3539 *\r
3540 *   resp_res\r
3541 *       Responder resources for the QP.\r
3542 *\r
3543 *   init_depth\r
3544 *       Initiator depth for the QP.\r
3545 *\r
3546 *       prot\r
3547 *               Protocol.\r
3548 *\r
3549 *       pdata_size\r
3550 *               The size of following private RDMA CM data\r
3551 *\r
3552 *       pdata\r
3553 *               Private data in format RDMA CM\r
3554 *\r
3555 *****/\r
3556 \r
3557 /****s* User-mode Access Layer/ual_ndi_rep_cm_ioctl_in_t\r
3558 * NAME\r
3559 *       ual_ndi_rep_cm_ioctl_in_t\r
3560 *\r
3561 * DESCRIPTION\r
3562 *       IOCTL structure containing the input parameters \r
3563 *       sending CM REP response .\r
3564 *\r
3565 * SYNOPSIS\r
3566 */\r
3567 typedef struct _ual_ndi_rep_cm_ioctl_in\r
3568 {\r
3569         uint64_t                                        h_qp;\r
3570         net32_t                                         cid;\r
3571         uint8_t                                         init_depth;\r
3572         uint8_t                                         resp_res;\r
3573         uint8_t                                         pdata_size;\r
3574         uint8_t                                         pdata[IB_REJ_PDATA_SIZE];\r
3575 \r
3576 }       ual_ndi_rep_cm_ioctl_in_t;\r