Fixed Id keyword in source files
[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_cm_listen_ioctl_t\r
2232 * NAME\r
2233 *       ual_cm_listen_ioctl_t\r
2234 *\r
2235 * DESCRIPTION\r
2236 *       IOCTL structure containing the input and output parameters to\r
2237 *       perform a CM listen request.\r
2238 *\r
2239 * SYNOPSIS\r
2240 */\r
2241 typedef union _ual_cm_listen_ioctl\r
2242 {\r
2243         struct _ual_cm_listen_ioctl_in\r
2244         {\r
2245                 void* __ptr64                           context;\r
2246                 ib_cm_listen_t                          cm_listen;\r
2247                 /* Compare data buffer follows IOCTL buffer immediately. */\r
2248 \r
2249         }       in;\r
2250         struct _ual_cm_listen_ioctl_out\r
2251         {\r
2252                 ib_api_status_t                         status;\r
2253                 uint64_t                                        h_cm_listen;\r
2254 \r
2255         }       out;\r
2256 \r
2257 }       ual_cm_listen_ioctl_t;\r
2258 /*\r
2259 * FIELDS\r
2260 *       in.listen_context\r
2261 *               User-specified context information that is returned as a part of all\r
2262 *               connection requests through the pfn_cm_req_cb routine.  The context is\r
2263 *               also returned through the error and destroy callbacks.\r
2264 *\r
2265 *       in.cm_listen\r
2266 *               Information used to direct the listen request to match incoming\r
2267 *               connection requests.\r
2268 *\r
2269 *       out.status\r
2270 *               Status of the operation.\r
2271 *\r
2272 *       out.h_cm_listen\r
2273 *               Upon successful completion of this call, handle to the listen request.\r
2274 *               This handle may be used to cancel the listen operation.\r
2275 *****/\r
2276 \r
2277 \r
2278 \r
2279 /****s* User-mode Access Layer/ual_cm_cancel_ioctl_t\r
2280 * NAME\r
2281 *       ual_cm_cancel_ioctl_t\r
2282 *\r
2283 * DESCRIPTION\r
2284 *       IOCTL structure containing the input and output parameters for\r
2285 *       ib_cm_cancel\r
2286 *\r
2287 * SYNOPSIS\r
2288 */\r
2289 typedef union _ual_cm_cancel_ioctl\r
2290 {\r
2291         struct _ual_cm_cancel_ioctl_in\r
2292         {\r
2293                 uint64_t                                        h_cm_listen;\r
2294 \r
2295         }       in;\r
2296         struct _ual_cm_cancel_ioctl_out\r
2297         {\r
2298                 ib_api_status_t                         status;\r
2299 \r
2300         }       out;\r
2301 \r
2302 }       ual_cm_cancel_ioctl_t;\r
2303 /*\r
2304 * FIELDS\r
2305 *       in.h_cm_listen\r
2306 *               The listen handle that needs to be cancelled.\r
2307 *\r
2308 *       out.status\r
2309 *               Status of the operation.\r
2310 *****/\r
2311 \r
2312 \r
2313 \r
2314 /****s* User-mode Access Layer/ual_cm_req_ioctl_t\r
2315 * NAME\r
2316 *       ual_cm_req_ioctl_t\r
2317 *\r
2318 * DESCRIPTION\r
2319 *       IOCTL structure containing the input and output parameters for\r
2320 *       ib_cm_req\r
2321 *\r
2322 * SYNOPSIS\r
2323 */\r
2324 typedef union _ual_cm_req_ioctl\r
2325 {\r
2326         struct _ual_cm_req_ioctl_in\r
2327         {\r
2328                 uint64_t                                        h_qp;   /* for CM */\r
2329                 ib_cm_req_t                                     cm_req;\r
2330                 ib_path_rec_t                           paths[1];\r
2331                 /* If an alternate path is specified, it follows the primary path. */\r
2332                 /* private data follows the IOCTL buffer immediately. */\r
2333                 /* compare data follows private data immediately. */\r
2334 \r
2335         }       in;\r
2336         struct _ual_cm_req_ioctl_out\r
2337         {\r
2338                 ib_api_status_t                         status;\r
2339 \r
2340         }       out;\r
2341 \r
2342 }       ual_cm_req_ioctl_t;\r
2343 /*\r
2344 * FIELDS\r
2345 *       in.cm_req\r
2346 *               CM REQ parameters.\r
2347 *\r
2348 *       in.paths\r
2349 *               Array of paths, the first being the primary path to use for the REQ.\r
2350 *\r
2351 *       out.status\r
2352 *               Status of the operation\r
2353 *****/\r
2354 \r
2355 \r
2356 \r
2357 /****s* User-mode Access Layer/ual_cm_rep_ioctl_t\r
2358 * NAME\r
2359 *       ual_cm_rep_ioctl_t\r
2360 *\r
2361 * DESCRIPTION\r
2362 *       IOCTL structure containing the input and output parameters for\r
2363 *       ib_cm_rep\r
2364 *\r
2365 * SYNOPSIS\r
2366 */\r
2367 typedef union _ual_cm_rep_ioctl\r
2368 {\r
2369         struct _ual_cm_rep_ioctl_in\r
2370         {\r
2371                 uint64_t                                        h_cm_req;\r
2372                 uint64_t                                        h_qp;\r
2373                 ib_cm_rep_t                                     cm_rep;\r
2374                 /* Private data follows immediately. */\r
2375 \r
2376         }       in;\r
2377         struct _ual_cm_rep_ioctl_out\r
2378         {\r
2379                 ib_api_status_t                         status;\r
2380 \r
2381         }       out;\r
2382 \r
2383 }       ual_cm_rep_ioctl_t;\r
2384 /*\r
2385 * FIELDS\r
2386 *       in.h_cm_req\r
2387 *               The cm_req connection handle got on the callback.\r
2388 *\r
2389 *       in.cm_rep\r
2390 *               CM REP parameters.\r
2391 *\r
2392 *       out.status\r
2393 *               Status of the operation.\r
2394 *****/\r
2395 \r
2396 \r
2397 \r
2398 /****s* User-mode Access Layer/ual_cm_rtu_ioctl_t\r
2399 * NAME\r
2400 *       ual_cm_rtu_ioctl_t\r
2401 *\r
2402 * DESCRIPTION\r
2403 *       IOCTL structure containing the input and output parameters for\r
2404 *       ib_cm_rtu\r
2405 *\r
2406 * SYNOPSIS\r
2407 */\r
2408 typedef union _ual_cm_rtu_ioctl\r
2409 {\r
2410         struct _ual_cm_rtu_ioctl_in\r
2411         {\r
2412                 uint64_t                                        h_cm_rep;\r
2413                 ib_cm_rtu_t                                     cm_rtu;\r
2414                 /* Private data follows IOCTL buffer. */\r
2415 \r
2416         }       in;\r
2417         struct _ual_cm_rtu_ioctl_out\r
2418         {\r
2419                 ib_api_status_t                         status;\r
2420 \r
2421         }       out;\r
2422 \r
2423 }       ual_cm_rtu_ioctl_t;\r
2424 /*\r
2425 * FIELDS\r
2426 *       in.h_cm_rep\r
2427 *               The cm_rep connection handle got on the callback.\r
2428 *\r
2429 *       in.cm_rtu\r
2430 *               CM RTU parameters.\r
2431 *\r
2432 *       out.status\r
2433 *               Status of the operation\r
2434 *****/\r
2435 \r
2436 \r
2437 \r
2438 /****s* User-mode Access Layer/ual_cm_rej_ioctl_t\r
2439 * NAME\r
2440 *       ual_cm_rej_ioctl_t\r
2441 *\r
2442 * DESCRIPTION\r
2443 *       IOCTL structure containing the input and output parameters for\r
2444 *       ib_cm_rej\r
2445 *\r
2446 * SYNOPSIS\r
2447 */\r
2448 typedef union _ual_cm_rej_ioctl\r
2449 {\r
2450         struct _ual_cm_rej_ioctl_in\r
2451         {\r
2452                 uint64_t                                        h_cm;\r
2453                 ib_cm_rej_t                                     cm_rej;\r
2454                 /* ARI and private data data follow IOCTL buffer immediately. */\r
2455 \r
2456         }       in;\r
2457         struct _ual_cm_rej_ioctl_out\r
2458         {\r
2459                 ib_api_status_t                         status;\r
2460 \r
2461         }       out;\r
2462 \r
2463 }       ual_cm_rej_ioctl_t;\r
2464 /*\r
2465 * FIELDS\r
2466 *       in.h_cm\r
2467 *               The connection handle got on the callback.\r
2468 *\r
2469 *       in.cm_rej\r
2470 *               CM REJ parameters.\r
2471 *\r
2472 *       out.status\r
2473 *               Status of the operation.\r
2474 *****/\r
2475 \r
2476 \r
2477 \r
2478 /****s* User-mode Access Layer/ual_cm_handoff_ioctl_t\r
2479 * NAME\r
2480 *       ual_cm_handoff_ioctl_t\r
2481 *\r
2482 * DESCRIPTION\r
2483 *       IOCTL structure containing the input and output parameters for\r
2484 *       ib_cm_handoff\r
2485 *\r
2486 * SYNOPSIS\r
2487 */\r
2488 typedef union _ual_cm_handoff_ioctl\r
2489 {\r
2490         struct _ual_cm_handoff_ioctl_in\r
2491         {\r
2492                 uint64_t                                        h_cm;\r
2493                 net64_t                                         sid;\r
2494 \r
2495         }       in;\r
2496         struct _ual_cm_handoff_ioctl_out\r
2497         {\r
2498                 ib_api_status_t                         status;\r
2499 \r
2500         }       out;\r
2501 \r
2502 }       ual_cm_handoff_ioctl_t;\r
2503 /*\r
2504 * FIELDS\r
2505 *       in.h_cm\r
2506 *               The connection handle got on the callback.\r
2507 *\r
2508 *       in.sid\r
2509 *               Service ID to which to handoff the listen.\r
2510 *\r
2511 *       out.status\r
2512 *               Status of the operation\r
2513 *****/\r
2514 \r
2515 \r
2516 \r
2517 /****s* User-mode Access Layer/ual_cm_mra_ioctl_t\r
2518 * NAME\r
2519 *       ual_cm_mra_ioctl_t\r
2520 *\r
2521 * DESCRIPTION\r
2522 *       IOCTL structure containing the input and output parameters for\r
2523 *       ib_cm_mra\r
2524 *\r
2525 * SYNOPSIS\r
2526 */\r
2527 typedef union _ual_cm_mra_ioctl\r
2528 {\r
2529         struct _ual_cm_mra_ioctl_in\r
2530         {\r
2531                 uint64_t                                        h_cm;\r
2532                 ib_cm_mra_t                                     cm_mra;\r
2533                 /* Private data follows IOCTL buffer immediately. */\r
2534 \r
2535         }       in;\r
2536         struct _ual_cm_mra_ioctl_out\r
2537         {\r
2538                 ib_api_status_t                         status;\r
2539 \r
2540         }       out;\r
2541 \r
2542 }       ual_cm_mra_ioctl_t;\r
2543 /*\r
2544 * FIELDS\r
2545 *       in.h_cm\r
2546 *               The connection handle got on the callback.\r
2547 *\r
2548 *       cm_mra\r
2549 *               CM MRA parameters.\r
2550 *\r
2551 *       out.status\r
2552 *               Status of the operation\r
2553 *****/\r
2554 \r
2555 \r
2556 \r
2557 /****s* User-mode Access Layer/ual_cm_lap_ioctl_t\r
2558 * NAME\r
2559 *       ual_cm_lap_ioctl_t\r
2560 *\r
2561 * DESCRIPTION\r
2562 *       IOCTL structure containing the input and output parameters for\r
2563 *       ib_cm_lap\r
2564 *\r
2565 * SYNOPSIS\r
2566 */\r
2567 typedef union _ual_cm_lap_ioctl\r
2568 {\r
2569         struct _ual_cm_lap_ioctl_in\r
2570         {\r
2571                 uint64_t                                        h_qp;\r
2572                 ib_cm_lap_t                                     cm_lap;\r
2573                 ib_path_rec_t                           alt_path;\r
2574                 /* Private data follows IOCTL buffer immediately */\r
2575 \r
2576         }       in;\r
2577         struct _ual_cm_lap_ioctl_out\r
2578         {\r
2579                 ib_api_status_t                         status;\r
2580 \r
2581         }       out;\r
2582 \r
2583 }       ual_cm_lap_ioctl_t;\r
2584 /*\r
2585 * FIELDS\r
2586 *       in.cm_lap\r
2587 *               CM LAP parameters\r
2588 *\r
2589 *       in.alt_path\r
2590 *               Alternate path information.\r
2591 *\r
2592 *       out.status\r
2593 *               Status of the operation\r
2594 *****/\r
2595 \r
2596 \r
2597 \r
2598 /****s* User-mode Access Layer/ual_cm_apr_ioctl_t\r
2599 * NAME\r
2600 *       ual_cm_apr_ioctl_t\r
2601 *\r
2602 * DESCRIPTION\r
2603 *       IOCTL structure containing the input and output parameters for\r
2604 *       ib_cm_apr\r
2605 *\r
2606 * SYNOPSIS\r
2607 */\r
2608 typedef union _ual_cm_apr_ioctl\r
2609 {\r
2610         struct _ual_cm_apr_ioctl_in\r
2611         {\r
2612                 uint64_t                                        h_cm_lap;\r
2613                 uint64_t                                        h_qp;\r
2614                 ib_cm_apr_t                                     cm_apr;\r
2615                 /* Info and Private data follow IOCTL buffer immediately */\r
2616 \r
2617         }       in;\r
2618         struct _ual_cm_apr_ioctl_out\r
2619         {\r
2620                 ib_api_status_t                         status;\r
2621 \r
2622         }       out;\r
2623 \r
2624 }       ual_cm_apr_ioctl_t;\r
2625 /*\r
2626 * FIELDS\r
2627 *       in.h_cm_lap\r
2628 *               The cm_lap connection handle got on the LAP callback.\r
2629 *\r
2630 *       in.cm_apr\r
2631 *               CM APR parameters.\r
2632 *\r
2633 *       out.status\r
2634 *               Status of the operation.\r
2635 *****/\r
2636 \r
2637 \r
2638 \r
2639 /****s* User-mode Access Layer/ual_force_apm_ioctl_t\r
2640 * NAME\r
2641 *       ual_force_apm_ioctl_t\r
2642 *\r
2643 * DESCRIPTION\r
2644 *       IOCTL structure containing the input and output parameters for\r
2645 *       ib_force_apm\r
2646 *\r
2647 * SYNOPSIS\r
2648 */\r
2649 typedef union _ual_force_apm_ioctl\r
2650 {\r
2651         union _ual_force_apm_ioctl_in\r
2652         {\r
2653                 uint64_t                                        h_qp;\r
2654 \r
2655         }       in;\r
2656         struct _ual_force_apm_ioctl_out\r
2657         {\r
2658                 ib_api_status_t                         status;\r
2659 \r
2660         }       out;\r
2661 \r
2662 }       ual_force_apm_ioctl_t;\r
2663 /*\r
2664 * FIELDS\r
2665 *       in.h_qp\r
2666 *               A handle to the QP to migrate.\r
2667 *\r
2668 *       out.status\r
2669 *               Status of the operation\r
2670 *****/\r
2671 \r
2672 \r
2673 \r
2674 /****s* User-mode Access Layer/ual_cm_dreq_ioctl_t\r
2675 * NAME\r
2676 *       ual_cm_dreq_ioctl_t\r
2677 *\r
2678 * DESCRIPTION\r
2679 *       IOCTL structure containing the input and output parameters for\r
2680 *       ib_cm_dreq\r
2681 *\r
2682 * SYNOPSIS\r
2683 */\r
2684 typedef union _ual_cm_dreq_ioctl\r
2685 {\r
2686         struct _ual_cm_dreq_ioctl_in\r
2687         {\r
2688                 uint64_t                                        h_qp;\r
2689                 ib_cm_dreq_t                            cm_dreq;\r
2690                 /* Private data follows IOCTL buffer immediately */\r
2691 \r
2692         }       in;\r
2693         struct _ual_cm_dreq_ioctl_out\r
2694         {\r
2695                 ib_api_status_t                         status;\r
2696 \r
2697         }       out;\r
2698 \r
2699 }       ual_cm_dreq_ioctl_t;\r
2700 /*\r
2701 * FIELDS\r
2702 *       cm_dreq\r
2703 *               CM DREQ parameters.\r
2704 *\r
2705 *       out.status\r
2706 *               Status of the operation.\r
2707 *****/\r
2708 \r
2709 \r
2710 \r
2711 /****s* User-mode Access Layer/ual_cm_drep_ioctl_t\r
2712 * NAME\r
2713 *       ual_cm_drep_ioctl_t\r
2714 *\r
2715 * DESCRIPTION\r
2716 *       IOCTL structure containing the input and output parameters for\r
2717 *       ib_cm_drep\r
2718 *\r
2719 * SYNOPSIS\r
2720 */\r
2721 typedef union _ual_cm_drep_ioctl\r
2722 {\r
2723         struct _ual_cm_drep_ioctl_in\r
2724         {\r
2725                 uint64_t                                        h_cm_dreq;\r
2726                 ib_cm_drep_t                            cm_drep;\r
2727                 /* Private data follows IOCTL buffer immediately. */\r
2728 \r
2729         }       in;\r
2730         struct _ual_cm_drep_ioctl_out\r
2731         {\r
2732                 ib_api_status_t                         status;\r
2733 \r
2734         }       out;\r
2735 \r
2736 }       ual_cm_drep_ioctl_t;\r
2737 /*\r
2738 * FIELDS\r
2739 *       in.h_cm_dreq\r
2740 *               The cm_dreq connection handle got on the callback.\r
2741 *\r
2742 *       in.cm_drep\r
2743 *               CM DREP parameters.\r
2744 *\r
2745 *       out.status\r
2746 *               Status of the operation.\r
2747 *****/\r
2748 \r
2749 \r
2750 \r
2751 /****s* User-mode Access Layer/ual_reg_shmid_ioctl_t\r
2752 * NAME\r
2753 *       ual_reg_shmid_ioctl_t\r
2754 *\r
2755 * DESCRIPTION\r
2756 *       IOCTL structure containing the input and output parameters for\r
2757 *       ib_create_shmid\r
2758 *\r
2759 * SYNOPSIS\r
2760 */\r
2761 typedef union _ual_reg_shmid_ioctl\r
2762 {\r
2763         struct _ual_reg_shmid_ioctl_in\r
2764         {\r
2765                 uint64_t                                        h_pd;\r
2766                 ib_shmid_t                                      shmid;\r
2767                 ib_mr_create_t                          mr_create;\r
2768 \r
2769         }       in;\r
2770         struct _ual_reg_shmid_ioctl_out\r
2771         {\r
2772                 ib_api_status_t                         status;\r
2773                 uint64_t                                        vaddr;\r
2774                 net32_t                                         lkey;\r
2775                 net32_t                                         rkey;\r
2776                 uint64_t                                        h_mr;\r
2777 \r
2778         }       out;\r
2779 \r
2780 }       ual_reg_shmid_ioctl_t;\r
2781 /*\r
2782 * PARAMETERS\r
2783 *       in.h_pd\r
2784 *               A handle to an existing protection domain that the memory\r
2785 *               should be registered with.\r
2786 *\r
2787 *       in.shmid\r
2788 *               An identifier to the shared memory region.\r
2789 *\r
2790 *       in.mr_create\r
2791 *               Information describing the attributes of the memory region to\r
2792 *               register.\r
2793 *\r
2794 *       out.status\r
2795 *               Status of the operation.\r
2796 *\r
2797 *       out.vaddr\r
2798 *               Assigned I/O virtual address for the memory region.\r
2799 *\r
2800 *       out.lkey\r
2801 *               The local access key associated with this registered memory\r
2802 *               region.\r
2803 *\r
2804 *       out.rkey\r
2805 *               A key that may be used by a remote end-point when performing RDMA\r
2806 *               or atomic operations to this registered memory region.\r
2807 *\r
2808 *       out.h_mr\r
2809 *               Upon successful completion of this call, this references a handle\r
2810 *               to the registered memory region.  This handle is used when performing\r
2811 *               data transfers and to deregister the memory.\r
2812 *****/\r
2813 \r
2814 \r
2815 \r
2816 /****s* User-mode Access Layer/ual_send_sa_req_t\r
2817 * NAME\r
2818 *       ual_send_sa_req_t\r
2819 *\r
2820 * DESCRIPTION\r
2821 *       IOCTL structure containing the input and output parameters for\r
2822 *       ib_create_shmid\r
2823 *\r
2824 * SYNOPSIS\r
2825 */\r
2826 typedef union _ual_send_sa_req_ioctl\r
2827 {\r
2828         struct _ual_send_sa_req_ioctl_in\r
2829         {\r
2830                 net64_t                                         port_guid;\r
2831                 uint32_t                                        timeout_ms;\r
2832                 uint32_t                                        retry_cnt;\r
2833                 ib_user_query_t                         sa_req;\r
2834                 uint8_t                                         attr[IB_SA_DATA_SIZE];\r
2835                 uint64_t* __ptr64                       ph_sa_req;\r
2836                 ib_api_status_t* __ptr64        p_status;\r
2837 \r
2838         }       in;\r
2839         struct _ual_send_sa_req_ioctl_out\r
2840         {\r
2841                 ib_api_status_t                         status;\r
2842                 uint64_t                                        h_resp;\r
2843                 uint32_t                                        resp_size;\r
2844 \r
2845         }       out;\r
2846 \r
2847 }       ual_send_sa_req_ioctl_t;\r
2848 /*\r
2849 * PARAMETERS\r
2850 *       in.sa_mad_data\r
2851 *               The SA request to send.\r
2852 *\r
2853 *       in.attr\r
2854 *               The SA attribute data to send.\r
2855 *\r
2856 *       in.ph_sa_req\r
2857 *               Pointer to UAL's query handle.  The proxy fills this in\r
2858 *               before returning from the IOCTL handler to allow cancelation.\r
2859 *\r
2860 *       in.p_status\r
2861 *               Pointer to status of the query.\r
2862 *\r
2863 *       out.status\r
2864 *               Status of the query if it was initiated successfully.\r
2865 *\r
2866 *       out.h_resp\r
2867 *               Handle to a response MAD.\r
2868 *\r
2869 *       out.resp_size\r
2870 *               Size, in bytes, of the response MAD's buffer.\r
2871 *****/\r
2872 \r
2873 \r
2874 \r
2875 /****s* User-mode Access Layer/ual_cancel_sa_req_ioctl_t\r
2876 * NAME\r
2877 *       ual_cancel_sa_req_ioctl_t\r
2878 *\r
2879 * DESCRIPTION\r
2880 *       IOCTL structure containing the input parameters for cancelling an\r
2881 *       SA request.\r
2882 *\r
2883 * SYNOPSIS\r
2884 */\r
2885 typedef struct _ual_cancel_sa_req_ioctl\r
2886 {\r
2887         uint64_t                        h_sa_req;\r
2888 \r
2889 }       ual_cancel_sa_req_ioctl_t;\r
2890 /*\r
2891 * PARAMETERS\r
2892 *       h_sa_req\r
2893 *               Handle to the query to cancel.\r
2894 *****/\r
2895 \r
2896 \r
2897 \r
2898 /****s* User-mode Access Layer/ual_reg_pnp_ioctl_in_t\r
2899 * NAME\r
2900 *       ual_reg_pnp_ioctl_in_t\r
2901 *\r
2902 * DESCRIPTION\r
2903 *       IOCTL structure containing the input parameters for registering\r
2904 *       for PnP events.\r
2905 *\r
2906 * SYNOPSIS\r
2907 */\r
2908 typedef struct _ual_reg_pnp_ioctl_in\r
2909 {\r
2910         ib_pnp_class_t                          pnp_class;\r
2911         void* __ptr64                           sync_event;\r
2912         ib_api_status_t* __ptr64        p_status;\r
2913         uint64_t* __ptr64                       p_hdl;\r
2914 \r
2915 }       ual_reg_pnp_ioctl_in_t;\r
2916 /*\r
2917 * NOTES\r
2918 *       This is an asynchronous IOCTL.\r
2919 *\r
2920 *       The output parameters are a ual_rearm_pnp_ioctl_out_t.\r
2921 *\r
2922 * PARAMETERS\r
2923 *       pnp_class\r
2924 *               Class of PnP events for which to register.\r
2925 *\r
2926 *       p_status\r
2927 *               Pointer to user-mode status variable to set in failure case.\r
2928 *\r
2929 *       p_hdl\r
2930 *               Pointer to user-mode handle variable to set in success case.\r
2931 *****/\r
2932 \r
2933 \r
2934 \r
2935 /****s* User-mode Access Layer/ual_poll_pnp_ioctl_t\r
2936 * NAME\r
2937 *       ual_poll_pnp_ioctl_t\r
2938 *\r
2939 * DESCRIPTION\r
2940 *       IOCTL structure containing the parameters for retriveing data for\r
2941 *       a PnP event.\r
2942 *\r
2943 * SYNOPSIS\r
2944 */\r
2945 typedef union _ual_poll_pnp_ioctl\r
2946 {\r
2947         struct _ual_poll_pnp_ioctl_in\r
2948         {\r
2949                 uint64_t                                        evt_hdl;\r
2950 \r
2951         }       in;\r
2952         struct _ual_poll_pnp_ioctl_out\r
2953         {\r
2954                 ib_pnp_rec_t                            pnp_rec;\r
2955 \r
2956         }       out;\r
2957 \r
2958 }       ual_poll_pnp_ioctl_t;\r
2959 /*\r
2960 * NOTES\r
2961 *       This is a synchronous IOCTL.\r
2962 *\r
2963 * PARAMETERS\r
2964 *       in.evt_hdl\r
2965 *               Handle to a new PnP event.\r
2966 *\r
2967 *       out.pnp_rec\r
2968 *               Buffer for the new PnP event.\r
2969 *****/\r
2970 \r
2971 \r
2972 \r
2973 /****s* User-mode Access Layer/ual_rearm_pnp_ioctl_in_t\r
2974 * NAME\r
2975 *       ual_rearm_pnp_ioctl_in_t\r
2976 *\r
2977 * DESCRIPTION\r
2978 *       IOCTL structure containing the input parameters for requesting\r
2979 *       notification of the next PnP event.\r
2980 *\r
2981 * SYNOPSIS\r
2982 */\r
2983 typedef struct _ual_rearm_pnp_ioctl_in\r
2984 {\r
2985         uint64_t                                        pnp_hdl;\r
2986         uint64_t                                        last_evt_hdl;\r
2987         void* __ptr64                           last_evt_context;\r
2988         ib_api_status_t                         last_evt_status;\r
2989 \r
2990 }       ual_rearm_pnp_ioctl_in_t;\r
2991 /*\r
2992 * NOTES\r
2993 *       This is an asynchronous IOCTL.\r
2994 *\r
2995 *       The output parameters are a ual_rearm_pnp_ioctl_out_t.\r
2996 *\r
2997 * PARAMETERS\r
2998 *       pnp_hdl\r
2999 *               Handle to the PnP registration to rearm.\r
3000 *\r
3001 *       last_evt_hdl\r
3002 *               Handle to the last PnP event processed.\r
3003 *\r
3004 *       last_evt_context\r
3005 *               Context value to set for the last reported PnP event.\r
3006 *\r
3007 *       last_evt_status\r
3008 *               Status value to return for the last reported PnP event.\r
3009 *****/\r
3010 \r
3011 \r
3012 \r
3013 /****s* User-mode Access Layer/ual_rearm_pnp_ioctl_out_t\r
3014 * NAME\r
3015 *       ual_rearm_pnp_ioctl_out_t\r
3016 *\r
3017 * DESCRIPTION\r
3018 *       IOCTL structure containing the output parameters for a PnP event.\r
3019 *\r
3020 * SYNOPSIS\r
3021 */\r
3022 typedef struct _ual_rearm_pnp_ioctl_out\r
3023 {\r
3024         uint64_t                                        evt_hdl;\r
3025         uint32_t                                        evt_size;\r
3026 \r
3027 }       ual_rearm_pnp_ioctl_out_t;\r
3028 /*\r
3029 * NOTES\r
3030 *       This is an asynchronous IOCTL.\r
3031 *\r
3032 *       The output parameters are identical to that of ual_reg_pnp_ioctl_t.\r
3033 *\r
3034 * PARAMETERS\r
3035 *       evt_hdl\r
3036 *               Handle to a new PnP event.\r
3037 *\r
3038 *       evt_size\r
3039 *               Buffer size needed to poll the new PnP event.\r
3040 *****/\r
3041 \r
3042 \r
3043 \r
3044 /****s* User-mode Access Layer/ual_dereg_pnp_ioctl_t\r
3045 * NAME\r
3046 *       ual_dereg_pnp_ioctl_t\r
3047 *\r
3048 * DESCRIPTION\r
3049 *       IOCTL structure containing the input parameters for cancelling an\r
3050 *       SA request.\r
3051 *\r
3052 * SYNOPSIS\r
3053 */\r
3054 typedef struct _ual_dereg_pnp_ioctl\r
3055 {\r
3056         uint64_t                        h_pnp;\r
3057 \r
3058 }       ual_dereg_pnp_ioctl_t;\r
3059 /*\r
3060 * NOTES\r
3061 *       This is an asynchronous IOCTL.\r
3062 *\r
3063 * PARAMETERS\r
3064 *       h_pnp\r
3065 *               Handle to the PnP registration to deregister.\r
3066 *****/\r
3067 #endif /* __IB_UAL_IOCTL_H__ */\r