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