inc/iba/ib_al_ioctl.h

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