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