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