[IBAL, HW] Remove pointers from ci_umv_buf_t.
[mirror/winof/.git] / inc / iba / ib_ci.h
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved. \r
4  * Portions Copyright (c) 2008 Microsoft Corporation.  All rights reserved.\r
5  *\r
6  * This software is available to you under the OpenIB.org BSD license\r
7  * below:\r
8  *\r
9  *     Redistribution and use in source and binary forms, with or\r
10  *     without modification, are permitted provided that the following\r
11  *     conditions are met:\r
12  *\r
13  *      - Redistributions of source code must retain the above\r
14  *        copyright notice, this list of conditions and the following\r
15  *        disclaimer.\r
16  *\r
17  *      - Redistributions in binary form must reproduce the above\r
18  *        copyright notice, this list of conditions and the following\r
19  *        disclaimer in the documentation and/or other materials\r
20  *        provided with the distribution.\r
21  *\r
22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
25  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
26  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
27  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
28  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
29  * SOFTWARE.\r
30  *\r
31  * $Id$\r
32  */\r
33 \r
34 \r
35 #if !defined(__IB_CI_H__)\r
36 #define __IB_CI_H__\r
37 \r
38 #include <iba/ib_types.h>\r
39 \r
40 \r
41 #ifdef __cplusplus\r
42 extern "C"\r
43 {\r
44 #endif  /* __cplusplus */\r
45 \r
46 \r
47 /****h* IB_API/Verbs\r
48 * NAME\r
49 *       Verbs -- Verbs implements the hardware and software glue to the OS layer.\r
50 * COPYRIGHT\r
51 *       Copyright© 2001 Intel Corporation - All Rights Reserved.\r
52 * DESCRIPTION\r
53 *       The Verbs API definition defines the interface mechanism between an IHV\r
54 *       supplied driver component. It implements verbs functionality as defined\r
55 *       Volume 1, of the InfiniBand(tm) specifications.\r
56 * AUTHOR\r
57 *       Intel Corporation\r
58 * CREATION DATE\r
59 *       XX.XX.XX\r
60 * NOTES\r
61 *       Evolving Spec!!\r
62 *       Invalid Handle checks are a mere signature checks in kernel mode. Hence\r
63 *       passing invalid pointer would lead to panics in the kernel. For user mode\r
64 *       These are verified for most verbs that need to take a kernel transition.\r
65 *       Verbs those are entirely done in user mode that would affect speed path\r
66 *       do not perform consistency checks. So invalid pointers would lead to\r
67 *       application crash with core dumps.\r
68 ***********\r
69 */\r
70 \r
71 \r
72 /*\r
73  * Version that identifies this version of the header file for interface\r
74  * definition.\r
75  */\r
76 #define VERBS_MAJOR_VER                 (0x0002)\r
77 #define VERBS_MINOR_VER                 (0x0000)\r
78 \r
79 #define VERBS_VERSION                   (((VERBS_MAJOR_VER) << 16) | (VERBS_MINOR_VER))\r
80 #define MK_VERBS_VERSION(maj,min)       ((((maj) & 0xFFFF) << 16) | \\r
81                                                                         ((min) & 0xFFFF))\r
82 \r
83 /*\r
84  * TODO: The in and out buffers should be separated (usage can still make\r
85  * both point to the same actual memory region.\r
86  */\r
87 /****s* Verbs/ci_umv_buf_t\r
88 * NAME\r
89 *       ci_umv_buf_t -- Vendor specific structure to facilitate user mode IO\r
90 * DESCRIPTION\r
91 *       This structure is provided to assist the vendor specific user mode\r
92 *       library to exchange information with its kernel mode driver. The\r
93 *       user mode InfiniBand(tm) Access Layer will call the vendor specific\r
94 *       module before a call is made to the kernel mode driver. The kernel mode\r
95 *       driver is expected to know the format and data in the p_inout_buf,\r
96 *       and copy any necessary data that must be handed to the user mode\r
97 *       vendor library.\r
98 * PURPOSE\r
99 *       command\r
100 *               A command code that is understood by the vendor specific kernel\r
101 *               mode driver.\r
102 *       p_inout_buf\r
103 *               The user mode component of the vendor specific library allocates\r
104 *               this memory and passes information in this buffer. vendor is expected\r
105 *               to set both the input and output buffer sizes appropriately.\r
106 *               This information is required since the kernel mode proxy that passes\r
107 *               this buffer to the kernel mode vendor specific library will copy the\r
108 *               content of this buffer to a kernel mode buffer. The kernel mode\r
109 *               vendor specific driver would copy the data that needs to be returned\r
110 *               to the user mode component, and set the output size appropriately\r
111 *               so that the proxy can now copy the data back to user mode buffer.\r
112 *\r
113 *               In the Infiniband Access Layer, it is important to know the\r
114 *               usage of umv_buf and whether the contents of the p_inout_buf\r
115 *               can have embedded user-mode pointers. When invoked from an\r
116 *               arbitrary thread context, Vendor driver can NOT access user-mode\r
117 *               pointers of a user-process.\r
118 *       input_size\r
119 *               Size of the input buffer, must be set by the user mode vendor\r
120 *               specific library.\r
121 *       output_size\r
122 *               Size of the output buffer. Must be set by the user mode component\r
123 *               to specify the maximum size of the data expected from its kernel\r
124 *               mode driver. The kernel mode driver would set the size to the exact\r
125 *               size that needs to be returned to its user mode counterpart.\r
126 *       status\r
127 *               Indicates the status of the operation from the kernel mode vendor\r
128 *               specific driver. The caller is supposed to initialize it appropriately\r
129 *               to identify if an operation succeded, or failed. For e.g. when\r
130 *               the user mode library is called after a resource creation, the user\r
131 *               mode vendor specific code must be able to identify if there is\r
132 *               post processing required, or if any resource allocation failed.\r
133 * SOURCE\r
134 */\r
135 typedef struct _umv_buf\r
136 {\r
137         uint32_t                command;\r
138         uint32_t                status;\r
139         uint32_t                input_size;\r
140         uint32_t                output_size;\r
141         uint64_t                p_inout_buf;\r
142 } ci_umv_buf_t;\r
143 /******/\r
144 \r
145 /****f* Verbs/ci_completion_cb_t\r
146 * NAME\r
147 *       ci_completion_cb_t -- Completion Notification callback.\r
148 * SYNOPSIS\r
149 */\r
150 \r
151 typedef void\r
152 (*ci_completion_cb_t)(\r
153         IN      void    *cq_context );\r
154 \r
155 /*\r
156 * DESCRIPTION\r
157 *       This function prototype indicates the parameter passed to ci_open_ca()\r
158 *       to receive completion callbacks.\r
159 * PARAMETERS\r
160 *       cq_context\r
161 *               [in] Completion queue context passed during the ci_create_cq\r
162 * RETURN VALUE\r
163 *       None\r
164 * NOTES\r
165 *       The consumer only gets the cq_context and ca_context. It is the client\r
166 *       responsibility to store the cq_handle in the context after the creation\r
167 *       time. So it can call ci_poll_cq() after the arrival of the notification.\r
168 * SEE ALSO\r
169 *       ci_open_ca, ci_create_cq\r
170 ******\r
171 */\r
172 \r
173 \r
174 /****f* Verbs/ci_async_event_cb_t\r
175 * NAME\r
176 *       ci_async_event_cb_t\r
177 *\r
178 * DESCRIPTION\r
179 *       Asynchronous event notification routine.\r
180 *\r
181 * SYNOPSIS\r
182 */\r
183 typedef void\r
184 (*ci_async_event_cb_t)(\r
185         IN      const   ib_event_rec_t* const                   p_event_record );\r
186 /*\r
187 * PARAMETERS\r
188 *       p_event_record\r
189 *               [in] Information describing the type of event that has occurred.\r
190 *\r
191 * NOTES\r
192 *       This routine is called when an asynchronous event is generated by a\r
193 *       channel adapter.  The event notification record passed has relevant\r
194 *       information on the type of the event, the source that caused the event,\r
195 *       and the context associated.\r
196 *****/\r
197 \r
198 \r
199 /****f* Verbs/ci_open_ca\r
200 * NAME\r
201 *       ci_open_ca -- open and possibly obtain a handle to access the HCA.\r
202 * SYNOPSIS\r
203 */\r
204 \r
205 typedef ib_api_status_t\r
206 (*ci_open_ca) (\r
207         IN              const   ib_net64_t                                      ca_guid,\r
208         IN              const   ci_completion_cb_t                      pfn_completion_cb,\r
209         IN              const   ci_async_event_cb_t                     pfn_async_event_cb,\r
210         IN              const   void* const                                     ca_context,\r
211                 OUT                     ib_ca_handle_t                          *ph_ca );\r
212 /*\r
213 * DESCRIPTION\r
214 *       This routine returns a handle to an open instance of a HCA. Client can call\r
215 *       this routine to retrieve a new open instance. Only one instance of the\r
216 *       open call is active at any time. If a duplicate open is called by the\r
217 *       consumer or any other consumer, it IB_RESOURCE_BUSY error status is\r
218 *       returned.\r
219 * PARAMETERS\r
220 *       ca_guid\r
221 *               [in] The HCA adapter's EUI64 identifier. Clients would use other\r
222 *               enumeration API's to locate all available adapters and their\r
223 *               guids in a system, e.g. GetCaGuids(), maintained by the IB\r
224 *               Access Layer. User mode consumers also have the same mechanism\r
225 *               to retrieve this information.\r
226 *       pfn_completion_cb\r
227 *               [in] Completion Handler, one per open instance.\r
228 *       pfn_async_event_cb\r
229 *               [in] Asynchronous event handler, one per open instance.\r
230 *       ca_context\r
231 *               [in] Verbs consumer supplied value, which is returned on calls to\r
232 *               handlers which in turn is used by clients to identify the\r
233 *               open instance.\r
234 *       ph_ca\r
235 *               [out] Pointer to a handle to the newly open instance of the CA returned\r
236 *               by the Verbs Provider.\r
237 *\r
238 * RETURN VALUE\r
239 *       IB_SUCCESS\r
240 *               The HCA is successfully opened and returned handle is valid.\r
241 *       IB_INSUFFICIENT_RESOURCES\r
242 *               Insufficient resources to satisfy request.\r
243 *       IB_INVALID_PARAMETER\r
244 *               Callback routine are not provided, GUID value is zero, or ph_ca is NULL\r
245 *       IB_RESOURCE_BUSY\r
246 *               The interface is already open by another consumer.\r
247 *       IB_NOT_FOUND\r
248 *               ca_guid passed is not valid\r
249 *\r
250 * SEE ALSO\r
251 *       ci_query_ca, ci_modify_ca, ci_close_ca\r
252 *********/\r
253 \r
254 \r
255 /****f* Verbs/ci_um_open_ca\r
256 * NAME\r
257 *       ci_um_open_ca -- Create a CA context for use by user-mode processes.\r
258 * SYNOPSIS\r
259 */\r
260 typedef ib_api_status_t\r
261 (*ci_um_open_ca_t) (\r
262         IN              const   ib_ca_handle_t                          h_ca,\r
263         IN      OUT                     ci_umv_buf_t* const                     p_umv_buf,\r
264                 OUT                     ib_ca_handle_t* const           ph_um_ca );\r
265 /*\r
266 * DESCRIPTION\r
267 *       This routine is used called on behalf of a user-mode application to\r
268 *       establish a per-CA context in user-mode.\r
269 *\r
270 * PARAMETERS\r
271 *       h_ca\r
272 *               [in] Handle returned by an earlier call to ci_open_ca()\r
273 *       p_umv_buf\r
274 *               [in/out] Vendor specific parameter to support user mode IO.\r
275 *       ph_um_ca\r
276 *               [out] Handle to pass into ci_um_close_ca call to free any kernel\r
277 *               resources allocated for the user-mode appliation.\r
278 *\r
279 * RETURN VALUE\r
280 *       IB_SUCCESS\r
281 *               The user-mode context information is returned successfully.\r
282 *       IB_INSUFFICIENT_MEMORY\r
283 *               The size of the p_ca_attr buffer, specified through p_size, is\r
284 *               insufficient to store all of the CA attribute information.\r
285 *       IB_INVALID_CA_HANDLE\r
286 *               h_ca is invalid\r
287 *       IB_INVALID_PARAMETER\r
288 *               The p_umv_buf parameters are insufficient to complete the request.\r
289 *\r
290 * SEE ALSO\r
291 *       ci_query_ca, ci_modify_ca, ci_close_ca\r
292 *********/\r
293 \r
294 \r
295 /****f* Verbs/ci_query_ca\r
296 * NAME\r
297 *       ci_query_ca -- Query the attributes of the HCA\r
298 * SYNOPSIS\r
299 */\r
300 \r
301 typedef ib_api_status_t\r
302 (*ci_query_ca) (\r
303         IN              const   ib_ca_handle_t                          h_ca,\r
304                 OUT                     ib_ca_attr_t                            *p_ca_attr OPTIONAL,\r
305         IN      OUT                     uint32_t                                        *p_size,\r
306         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
307 /*\r
308 * DESCRIPTION\r
309 *       This routine retrieves vital information about this hca. It returns\r
310 *       necessary information about HCA guid, port guids, LID's assigned by\r
311 *       the master SM. Clients can use this information to communicate with the\r
312 *       Master SM node to perform path queries etc.\r
313 * PARAMETERS\r
314 *       h_ca\r
315 *               [in] Handle returned by an earlier call to ci_open_ca()\r
316 *       p_ca_attr\r
317 *               [out] CA attribute of this Host Channel adapter\r
318 *       p_size\r
319 *               [in/out] On input, this references the size of the data buffer\r
320 *               referenced by the p_ca_attr parameter.\r
321 *               On output, the number of bytes used or needed to copy all CA\r
322 *               attribute information.\r
323 *       p_umv_buf\r
324 *               [in out] Vendor specific parameter to support user mode IO.\r
325 * RETURN VALUE\r
326 *       IB_SUCCESS\r
327 *               The attribute structure is returned completely.\r
328 *       IB_INSUFFICIENT_MEMORY\r
329 *               The size of the p_ca_attr buffer, specified through p_size, is\r
330 *               insufficient to store all of the CA attribute information.\r
331 *       IB_INVALID_CA_HANDLE\r
332 *               h_ca is invalid\r
333 *       IB_INVALID_PARAMETER\r
334 *               p_size is NULL.\r
335 * NOTES\r
336 *       Users may obtain the size of the data buffer required to obtain the\r
337 *       CA attributes by calling this function with p_ca_attr set to NULL.\r
338 *       The channel interface will then return the necessary size in the\r
339 *       variable referenced by the p_size parameter.  The caller can then allocate\r
340 *       exact size and call this routine again. No partial information is returned\r
341 *       if the size is not sufficient.\r
342 * SEE ALSO\r
343 *       ci_open_ca, ci_modify_ca\r
344 ********/\r
345 \r
346 /****f* Verbs/ci_modify_ca\r
347 * NAME\r
348 *       ci_modify_ca -- Modify port attributes and error counters\r
349 * SYNOPSIS\r
350 */\r
351 \r
352 typedef ib_api_status_t\r
353 (*ci_modify_ca) (\r
354         IN      const ib_ca_handle_t            h_ca,\r
355         IN      const uint8_t                           port_num,\r
356         IN      const ib_ca_mod_t                       ca_mod,\r
357         IN      const ib_port_attr_mod_t        *p_port_attr_mod );\r
358 /*\r
359 * DESCRIPTION\r
360 *       Modifies either the P_KEY/Q_KEY violation counters, or sets the capability\r
361 *       mask in the port attributes. This is effectively translated to PORTINFO\r
362 *       values responded later when a MAD from SM or another node arrives to\r
363 *       retrieve port related attributes.\r
364 *\r
365 * PARAMETERS\r
366 *       h_ca\r
367 *               [in] Handle returned by previous call to ci_open_ca()\r
368 *       port_num\r
369 *               [in] Port number, which needs to be modified.\r
370 *       ca_mod\r
371 *               [in] Command mask to perform operations on.\r
372 *       p_port_attr_mod\r
373 *               [in] port attribute which needs this change to be performed.\r
374 *               if the capability bit is set, then that corresponding\r
375 *               port capability is turned on.\r
376 * RETURN VALUE\r
377 *       IB_SUCCESS\r
378 *               Modify port attributes was performed\r
379 *       IB_INVALID_PORT\r
380 *               Invalid port number supplied in port_att.\r
381 *       IB_INVALID_PARAMETER\r
382 *               Unknown Command supplied in port_attr.\r
383 *       IB_UNSUPPORTED\r
384 *               Optional Q_KEY and P_KEY violation counters are not supported.\r
385 *       IB_INVALID_CA_HANDLE\r
386 *               h_ca is invalid\r
387 * NOTES\r
388 * No ownership checks are performed in the Verbs Provider Driver.\r
389 * All such permission checks are to be performed by the IB access layer\r
390 * before passing requests down to the HCA driver. These operations can be\r
391 * performed only by the special QP owner. Either the QP0 or QP1. Since port\r
392 * attributes is really maintained by the QP0 for SMA to respond with correct\r
393 * values, but the agent capability is really a QP1 functionality.\r
394 * SEE ALSO\r
395 *       ci_open_ca, ci_query_ca, ci_close_ca\r
396 */\r
397 /********/\r
398 \r
399 /****f* Verbs/ci_close_ca\r
400 * NAME\r
401 *       ci_close_ca -- Close access to adapter via this h_ca\r
402 * SYNOPSIS\r
403 */\r
404 \r
405 typedef ib_api_status_t\r
406 (*ci_close_ca) (\r
407         IN              ib_ca_handle_t  h_ca );\r
408 /*\r
409 * DESCRIPTION\r
410 *       This routine is called when the client no longer wishes to use HCA\r
411 *       resources obtained via this h_ca. All resources allocated as part\r
412 *       this handle during the ci_open_ca are destroyed.\r
413 * PARAMETERS\r
414 *       h_ca\r
415 *               [in] CA handle returned via the ci_open_ca() call.\r
416 * RETURN VALUE\r
417 *       IB_SUCCESS\r
418 *               The intend to destroy is registered. No further calls for\r
419 *               completion or async event will be sent to this instance. When it is\r
420 *               appropriate to destroy this instance, the event h_kevent is signaled.\r
421 *       IB_RESOURCE_BUSY\r
422 *               Some resource allocated via this handle is not freed.\r
423 *       IB_INVALID_CA_HANDLE\r
424 *               h_ca is invalid\r
425 * NOTES\r
426 *       This call cannot be called from any of the notification functions invoked\r
427 *       by the Verbs driver. For e.g. the completion handler or the async error\r
428 *       callback provided during the ci_open_ca() call. The call will block until\r
429 *       all references to this adapter object is closed which includes all the\r
430 *       pending callbacks returning back to the verbs provider driver.\r
431 *\r
432 *       Resources allocated during the ci_open_ca() is deallocated. Other resource\r
433 *       cleanup are responsibility of the consumer .\r
434 * SEE ALSO\r
435 *       ci_open_ca\r
436 ********/\r
437 \r
438 /****f* Verbs/ci_um_close_ca_t\r
439 * NAME\r
440 *       ci_um_close_ca_t -- Close user-mode access to adapter via this h_ca\r
441 * SYNOPSIS\r
442 */\r
443 typedef void\r
444 (*ci_um_close_ca_t) (\r
445         IN                              ib_ca_handle_t                          h_ca,\r
446         IN                              ib_ca_handle_t                          h_um_ca );\r
447 /*\r
448 * DESCRIPTION\r
449 *       This routine is called when the client no longer wishes to use HCA\r
450 *       resources obtained via this h_ca. All resources allocated as part\r
451 *       this handle during the ci_um_open_ca are destroyed.\r
452 * PARAMETERS\r
453 *       h_ca\r
454 *               [in] CA handle returned via the ci_open_ca() call.\r
455 *       h_um_ca\r
456 *               [in] CA handle returned via the ci_um_open_ca() call.\r
457 *\r
458 * RETURN VALUE\r
459 *       This funtion does not return a value.\r
460 * NOTES\r
461 *       This call is invoked from the context of a UM application when such an\r
462 *       appliation closes the HCA in user-mode.\r
463 *\r
464 *       Resources allocated during the ci_um_open_ca() are deallocated.\r
465 *\r
466 * SEE ALSO\r
467 *       ci_um_open_ca\r
468 ********/\r
469 \r
470 /****f* Verbs/ci_allocate_pd\r
471 * NAME\r
472 *       ci_allocate_pd -- Allocate a protection domain for this adapter.\r
473 * SYNOPSIS\r
474 */\r
475 \r
476 typedef ib_api_status_t\r
477 (*ci_allocate_pd) (\r
478         IN              const   ib_ca_handle_t                          h_ca,\r
479         IN              const   ib_pd_type_t                            type,\r
480                 OUT                     ib_pd_handle_t                          *ph_pd,\r
481         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
482 /*\r
483 * DESCRIPTION\r
484 *       This routine allocates a protection domain handle, which is later\r
485 *       used to create QP's, Register Memory Regions, Bind Memory Windows\r
486 *       and address vectors. Protection domain has no InfiniBand architectural\r
487 *       attributes but the OS implements policy on its usage and allocation.\r
488 * PARAMETERS\r
489 *       h_ca\r
490 *               [in] Handle returned by ci_open_ca()\r
491 *\r
492 *       type\r
493 *               [in] Type of the protection domain.  CA vendors may use this\r
494 *               information to optimize how the PD is allocated.\r
495 *\r
496 *       ph_pd\r
497 *               [out] The handle to the newly created protection domain\r
498 *\r
499 *       p_umv_buf\r
500 *               [in/out] Vendor specific parameter to support user mode IO.\r
501 *\r
502 * RETURN VALUE\r
503 *       IB_SUCCESS\r
504 *               PD is successfully allocated and the ph_pd is valid.\r
505 *\r
506 *       IB_INSUFFICIENT_RESOURCES\r
507 *               No more PD's available for this adapter.\r
508 *\r
509 *       IB_INVALID_CA_HANDLE\r
510 *               HCA handle is not valid\r
511 *\r
512 * SEE ALSO\r
513 *       ci_deallocate_pd\r
514 *******/\r
515 \r
516 /****f* Verbs/ci_deallocate_pd\r
517 * NAME\r
518 *       ci_deallocate_pd -- Deallocate a protection domain object.\r
519 * SYNOPSIS\r
520 */\r
521 \r
522 typedef ib_api_status_t\r
523 (*ci_deallocate_pd) (\r
524         IN              ib_pd_handle_t          h_pd );\r
525 \r
526 /*\r
527 * DESCRIPTION\r
528 *       This routine deallocates a pd that is allocated via the ci_allocate_pd()\r
529 *       call. The PD cannot be deallocated if it is still bound to a QP, any memory\r
530 *       region, memory window or address vector.\r
531 * PARAMETERS\r
532 *       h_pd\r
533 *               [in] Handle allocated via the ci_allocate_pd()\r
534 * RETURN VALUE\r
535 *       IB_SUCCESS\r
536 *               PD is freed successfully\r
537 *       IB_INVALID_PD_HANDLE\r
538 *               pd_handle is invalid\r
539 *       IB_RESOURCE_BUSY\r
540 *               PD is probably still bound to some resource\r
541 * SEE ALSO\r
542 *       ci_allocate_pd\r
543 *******\r
544 */\r
545 \r
546 \r
547 /****f* Verbs/ci_create_av\r
548 * NAME\r
549 *       ci_create_av -- Create an address vector for use in UD.\r
550 * SYNOPSIS\r
551 */\r
552 \r
553 typedef ib_api_status_t\r
554 (*ci_create_av) (\r
555         IN              const   ib_pd_handle_t                          h_pd,\r
556         IN              const   ib_av_attr_t                            *p_av_attr,\r
557                 OUT                     ib_av_handle_t                          *ph_av,\r
558         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
559 \r
560 /*\r
561 * DESCRIPTION\r
562 *       This routine creates an address vector for use in unreliable datagram\r
563 *       queue pairs. The information necessary to create the address vector\r
564 *       handle is supplied in the ib_av_attr_t parameter.\r
565 * PARAMETERS\r
566 *       h_pd\r
567 *               [in] Protection domain to which this av is associated.\r
568 *       p_av_attr\r
569 *               [in] Parameters to create the address vector handle\r
570 *       ph_av\r
571 *               [out] Handle to use for datagram sends.\r
572 *       p_umv_buf\r
573 *               [in out] Vendor specific parameter to support user mode IO.\r
574 * RETURN VALUE\r
575 *       IB_SUCCESS\r
576 *               The create operation was successful\r
577 *       IB_INSUFFICIENT_RESOURCES\r
578 *               No more address handles are available\r
579 *       IB_INVALID_PD_HANDLE\r
580 *               The specified protection domain handle is invalid\r
581 *       IB_INVALID_PORT\r
582 *               Invalid port number supplied.\r
583 *       IB_INVALID_PARAMETER\r
584 *               One of the p_av_attr or p_av_attr was NULL.\r
585 * NOTES\r
586 *       The values in the p_av_attr is not validated for correctness. The values\r
587 *       in the attribute such as port number, protection domain etc are also\r
588 *       validated during processing by the channel adapter. If the attribute\r
589 *       validation fails a processing error IB_WCS_LOCAL_OP_ERR.\r
590 * SEE ALSO\r
591 *       ci_allocate_pd\r
592 ********/\r
593 \r
594 /****f* Verbs/ci_query_av\r
595 * NAME\r
596 *       ci_query_av -- Obtain the address vector associated with the handle\r
597 * SYNOPSIS\r
598 */\r
599 \r
600 typedef ib_api_status_t\r
601 (*ci_query_av) (\r
602         IN              const   ib_av_handle_t                          h_av,\r
603                 OUT                     ib_av_attr_t                            *p_av_attr,\r
604                 OUT                     ib_pd_handle_t                          *ph_pd,\r
605         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
606 \r
607 /*\r
608 * DESCRIPTION\r
609 *       This routine returns the address vector and pd_handle associated with the\r
610 *       av_handle.\r
611 * PARAMETERS\r
612 *       h_av\r
613 *               [in] Handle to the address vector\r
614 *       p_av_attr\r
615 *               [out] address vector data referred by the av_handle\r
616 *       ph_pd\r
617 *               [out] pd handle associated with the av_handle\r
618 *       p_umv_buf\r
619 *               [in out] Vendor specific parameter to support user mode IO.\r
620 * RETURN VALUE\r
621 *       IB_SUCCESS\r
622 *               returned values are valid\r
623 *       IB_INVALID_AV_HANDLE\r
624 *               The address vector handle was invalid\r
625 *       IB_INVALID_PARAMETER\r
626 *               One of the p_av_attr or ph_pd parameters was NULL.\r
627 *       IB_INVALID_PORT\r
628 *               Invalid port number passed in the Address Vector.\r
629 * SEE ALSO\r
630 *       ci_create_av, ci_modify_av\r
631 *******\r
632 */\r
633 \r
634 /****f* Verbs/ci_modify_av\r
635 * NAME\r
636 *       ci_modify_av -- Change the address vector referred by the av_handle\r
637 * SYNOPSIS\r
638 */\r
639 \r
640 typedef ib_api_status_t\r
641 (*ci_modify_av) (\r
642         IN              const   ib_av_handle_t                          h_av,\r
643         IN              const   ib_av_attr_t                            *p_av_attr,\r
644         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
645 /*\r
646 * DESCRIPTION\r
647 *       This routine allows a consumer to modify the address information\r
648 *       passed.\r
649 * PARAMETERS\r
650 *       h_av\r
651 *               [in] Address handle that needs to be updated with new info.\r
652 *       p_av_attr\r
653 *               [in] New address vector to associate with the addr_handle.\r
654 *       p_umv_buf\r
655 *               [in out] Vendor specific parameter to support user mode IO.\r
656 * RETURN VALUE\r
657 *       IB_SUCCESS\r
658 *               Operation was successful\r
659 *       IB_INVALID_AV_HANDLE\r
660 *               The address vector handle was invalid\r
661 *       IB_INVALID_PORT\r
662 *               Invalid port number passed in the Address Vector.\r
663 *       IB_INVALID_PARAMETER\r
664 *               The parameter p_av_attr is not valid.\r
665 * NOTES\r
666 *       The values in the p_av_attr is not validated for correctness. The values\r
667 *       in the attribute such as port number, protection domain etc are validated\r
668 *       during processing by the channel adapter. If the attribute validation fails\r
669 *       a processing error IB_WCS_LOCAL_OP_ERR.\r
670 * SEE ALSO\r
671 *       ci_create_av, ci_query_av\r
672 *********\r
673 */\r
674 \r
675 /****f* Verbs/ci_destroy_av\r
676 * NAME\r
677 *       ci_destroy_av -- Destroy the address vector\r
678 * SYNOPSIS\r
679 */\r
680 \r
681 typedef ib_api_status_t\r
682 (*ci_destroy_av) (\r
683         IN      const   ib_av_handle_t          h_av );\r
684 /*\r
685 * DESCRIPTION\r
686 *       This routine destroys the specified address handle. After the routine\r
687 *       returns, this address handle cannot be used to reference the destination.\r
688 * PARAMETERS\r
689 *       h_av\r
690 *               [in] Handle that needs to be destroyed.\r
691 * RETURN VALUE\r
692 *       IB_SUCCESS\r
693 *               Operation was successful.\r
694 *       IB_INVALID_AV_HANDLE\r
695 *               The address vector handle was invalid\r
696 * SEE ALSO\r
697 *       ci_create_av\r
698 *********\r
699 */\r
700 \r
701 /****f* Verbs/ci_create_srq\r
702 * NAME\r
703 *       ci_create_srq -- Create a Shared Queue Pair for the specified HCA\r
704 * SYNOPSIS\r
705 */\r
706 \r
707 typedef ib_api_status_t\r
708 (*ci_create_srq) (\r
709         IN              const   ib_pd_handle_t                  h_pd,\r
710         IN              const   void                                            *srq_context,\r
711         IN              const   ib_srq_attr_t * const           p_srq_attr,\r
712                 OUT                     ib_srq_handle_t                 *ph_srq,\r
713         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
714 /*\r
715 * DESCRIPTION\r
716 *       A new shared queue pair is created on the specified HCA. The initial set of\r
717 *       parameters is provided by the srq_attr_mask/p_srq_attr parameters. The newly created\r
718 *       queue pair  with its attributes is returned in the srq_query_attr structure.\r
719 * PARAMETERS\r
720 *       h_pd\r
721 *               [in] Handle to Protection Domain\r
722 *       srq_context\r
723 *               [in] A user specified context passed in a asynchronous error callback.\r
724 *       p_srq_attr\r
725 *               [in out] Initial attributes with which the srq must be created.\r
726 *       ph_srq\r
727 *               [out] Handle to the queue pair newly created.\r
728 *       p_umv_buf\r
729 *               [in out] Vendor specific parameter to support user mode IO.\r
730 * RETURN VALUE\r
731 *       IB_SUCCESS\r
732 *               The queue pair is successfully created with the provided initial\r
733 *               attributes.\r
734 *       IB_INSUFFICIENT_RESOURCES\r
735 *               Insufficient resources to complete request.\r
736 *       IB_INVALID_PD_HANDLE\r
737 *               pd_handle supplied in the qp_create_attr is invalid\r
738 *       IB_INVALID_SERVICE_TYPE\r
739 *               Invalid service type.\r
740 *       IB_INVALID_MAX_WRS\r
741 *               Max WRS capacity exceeded\r
742 *       IB_INVALID_MAX_SGE\r
743 *               Max Scatter gather element request exceeds HCA capability\r
744 *       IB_UNSUPPORTED\r
745 *               Unreliable datagram not supported\r
746 *       IB_INVALID_PARAMETER\r
747 *               The parameter p_create_attr is invalid.\r
748 * NOTES\r
749 *       If any of the initial parameters is not valid, the queue pair is not\r
750 *       created. If the routine call is not successful then the contents of\r
751 *       qp_query_attr and qp_handle is undefined.\r
752 * SEE ALSO\r
753 *       ci_query_qp, ci_modify_qp, ci_destroy_qp\r
754 ******\r
755 */\r
756 \r
757 \r
758 /****f* Verbs/ci_modify_srq\r
759 * NAME\r
760 *       ci_modify_srq -- Modify attributes of the specified SRQ.\r
761 * SYNOPSIS\r
762 */\r
763 \r
764 typedef ib_api_status_t\r
765 (*ci_modify_srq) (\r
766         IN              const   ib_srq_handle_t                         h_srq,\r
767         IN              const   ib_srq_attr_t* const                    p_srq_attr,\r
768         IN              const   ib_srq_attr_mask_t                      srq_attr_mask,\r
769         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
770 /*\r
771 * DESCRIPTION\r
772 *       This routine is used to modify the srq states or other attributes of the\r
773 *       srq. On successful completion, the requested state transition is performed\r
774 *       and the srq is transitioned to the required state.\r
775 * PARAMETERS\r
776 *       h_srq\r
777 *               [in] Handle to the queue pair whose state is to be modified.\r
778 *       p_srq_attr\r
779 *               [in] Initial attributes with which the srq must be created.\r
780 *       srq_attr_mask\r
781 *               [in] Flags, specifying valid fields in ib_srq_attr_t structure.\r
782 *       p_umv_buf\r
783 *               [in out] Vendor specific parameter to support user mode IO.\r
784 * RETURN VALUE\r
785 *       IB_SUCCESS\r
786 *               The operation was successful and the QP attributes are modified\r
787 *               to the requested state.\r
788 *       IB_INSUFFICIENT_RESOURCES\r
789 *               Insufficient resources to complete the requested operation.\r
790 *       IB_INVALID_QP_HANDLE\r
791 *               Invalid QP handle was passed.\r
792 *       IB_UNSUPPORTED\r
793 *               Requested operation is not supported, for e.g. Atomic operations.\r
794 *       IB_QP_INVALID_STATE\r
795 *               Invalid state transition request. Current QP state not in allowable\r
796 *               state.\r
797 *       IB_INVALID_PARAMETER\r
798 *               The parameter p_modify_attr is not valid.\r
799 * SEE ALSO\r
800 *       ci_create_qp, ci_destroy_qp, ci_query_qp\r
801 ******\r
802 */\r
803 \r
804 \r
805 /****f* Verbs/ci_query_srq\r
806 * NAME\r
807 *       ci_query_srq -- Query the current SRQ attributes\r
808 * SYNOPSIS\r
809 */\r
810 \r
811 typedef ib_api_status_t\r
812 (*ci_query_srq) (\r
813         IN              const   ib_srq_handle_t                         h_srq,\r
814                 OUT                     ib_srq_attr_t* const                    p_srq_attr,\r
815         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
816 /*\r
817 * DESCRIPTION\r
818 *       This routine queries the current attributes for the srq\r
819 *       corresponding to h_srq. The attributes are returned in p_query_attr.\r
820 *       Depending on the current state of the srq, some of the fields in the\r
821 *       attribute structure may not be valid.\r
822 * PARAMETERS\r
823 *       h_srq\r
824 *               [in] Handle to the srq for which the attributes are being retrieved\r
825 *       p_srq_attr\r
826 *               [out] Pointer to the ib_srq_query_t structure where the current\r
827 *               attributes of the srq is returned.\r
828 *       p_umv_buf\r
829 *               [in out] Vendor specific parameter to support user mode IO.\r
830 * RETURN VALUE\r
831 *       IB_SUCCESS\r
832 *               The values returned in p_qp_attr are valid.\r
833 *       IB_INVALID_QP_HANDLE\r
834 *               The h_qp supplied is not a valid handle.\r
835 *       IB_INVALID_PARAMETER\r
836 *               Parameter p_qp_attr is not valid.\r
837 * SEE ALSO\r
838 *       ci_create_qp, ci_destroy_qp, ci_modify_srq\r
839 *****\r
840 */\r
841 \r
842 \r
843 /****f* Verbs/ci_destroy_srq\r
844 * NAME\r
845 *       ci_destroy_srq -- Destroy the specified Shared Queue Pair.\r
846 * SYNOPSIS\r
847 */\r
848 \r
849 typedef ib_api_status_t\r
850 (*ci_destroy_srq) (\r
851         IN      const   ib_srq_handle_t         h_srq );\r
852 /*\r
853 * DESCRIPTION\r
854 *       Destroys the associated srq. The srq could have outstanding work requests\r
855 *       when this call is made. Any outstanding work requests *SHALL NOT* be\r
856 *       completed after this routine returns.\r
857 * PARAMETERS\r
858 *       h_srq\r
859 *               [in] Handle to the srq that needs to be destroyed.\r
860 * RETURN VALUE\r
861 *       IB_SUCCESS\r
862 *               The intend to destroy this queue pair is registered and no further\r
863 *               work requests will be processed. When no pending callbacks are in\r
864 *               progress, the destroy_callback function is invoked which marks the\r
865 *               destruction of the resource. The consumer can be guaranteed that\r
866 *               no future callbacks will be propagated on behalf of this resource.\r
867 *       IB_INVALID_QP_HANDLE\r
868 *               The handle passed is invalid.\r
869 *       IB_RESOURCE_BUSY\r
870 *               If the queue pair is a unreliable datagram service type, and\r
871 *               is still bound to a multicast group.\r
872 * NOTES\r
873 *       This call cannot be called from any of the notification functions invoked\r
874 *       by the Verbs driver. For e.g. the completion handler or the async error\r
875 *       callback provided during the ci_open_ca() call. The call will block until\r
876 *       all references to this adapter object is closed which includes all the\r
877 *       pending callbacks returning back to the verbs provider driver.\r
878 * SEE ALSO\r
879 *       ci_cquery_qp, ci_destroy_qp, ci_modify_srq\r
880 ******\r
881 */\r
882 \r
883 \r
884 /****f* Verbs/ci_create_qp\r
885 * NAME\r
886 *       ci_create_qp -- Create a Queue Pair for the specified HCA\r
887 * SYNOPSIS\r
888 */\r
889 \r
890 typedef ib_api_status_t\r
891 (*ci_create_qp) (\r
892         IN              const   ib_pd_handle_t                          h_pd,\r
893         IN              const   void                                            *qp_context,\r
894         IN              const   ib_qp_create_t                          *p_create_attr,\r
895                 OUT                     ib_qp_attr_t                            *p_qp_attr,\r
896                 OUT                     ib_qp_handle_t                          *ph_qp,\r
897         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
898 /*\r
899 * DESCRIPTION\r
900 *       A new queue pair is created on the specified HCA. The initial set of\r
901 *       parameters is provided by the qp_create_attr parameter. The newly created\r
902 *       queue pair, with its attributes such as the qp number is returned\r
903 *       in the qp_query_attr structure.\r
904 * PARAMETERS\r
905 *       h_pd\r
906 *               [in] Handle to Protection Domain\r
907 *       qp_context\r
908 *               [in] A user specified context passed in a asynchronous error callback.\r
909 *       p_create_attr\r
910 *               [in] Initial attributes with which the qp must be created.\r
911 *       p_qp_attr\r
912 *               [out] Attributes of the newly created queue pair.\r
913 *       ph_qp\r
914 *               [out] Handle to the queue pair newly created.\r
915 *       p_umv_buf\r
916 *               [in out] Vendor specific parameter to support user mode IO.\r
917 * RETURN VALUE\r
918 *       IB_SUCCESS\r
919 *               The queue pair is successfully created with the provided initial\r
920 *               attributes.\r
921 *       IB_INSUFFICIENT_RESOURCES\r
922 *               Insufficient resources to complete request.\r
923 *       IB_INVALID_PD_HANDLE\r
924 *               pd_handle supplied in the qp_create_attr is invalid\r
925 *       IB_INVALID_CQ_HANDLE\r
926 *               cq_handle supplied for send/receive is invalid.\r
927 *       IB_INVALID_SERVICE_TYPE\r
928 *               Invalid service type.\r
929 *       IB_INVALID_MAX_WRS\r
930 *               Max WRS capacity exceeded\r
931 *       IB_INVALID_MAX_SGE\r
932 *               Max Scatter gather element request exceeds HCA capability\r
933 *       IB_UNSUPPORTED\r
934 *               Unreliable datagram not supported\r
935 *       IB_INVALID_PARAMETER\r
936 *               The parameter p_create_attr is invalid.\r
937 * NOTES\r
938 *       If any of the initial parameters is not valid, the queue pair is not\r
939 *       created. If the routine call is not successful then the contents of\r
940 *       qp_query_attr and qp_handle is undefined.\r
941 * SEE ALSO\r
942 *       ci_create_spl_qp, ci_query_qp, ci_modify_qp, ci_destroy_qp\r
943 ******\r
944 */\r
945 \r
946 /****f* Verbs/ci_create_spl_qp\r
947 * NAME\r
948 *       ci_create_spl_qp -- Create a special queue pair.\r
949 * SYNOPSIS\r
950 */\r
951 \r
952 typedef ib_api_status_t\r
953 (*ci_create_spl_qp) (\r
954         IN              const   ib_pd_handle_t          h_pd,\r
955         IN              const   uint8_t                         port_num,\r
956         IN              const   void                            *qp_context,\r
957         IN              const   ib_qp_create_t          *p_create_attr,\r
958                 OUT                     ib_qp_attr_t            *p_qp_attr,\r
959                 OUT                     ib_qp_handle_t          *ph_qp );\r
960 /*\r
961 * DESCRIPTION\r
962 *       Create and return a handle to for the indicated service type on the\r
963 *       specified port. QP service types can be one of SMI, GSI, Raw IPv6 or\r
964 *       Raw ether type as specified in qp_type_t.\r
965 * PARAMETERS\r
966 *       h_pd\r
967 *               [in] Handle to the PD on which the special queue pair is to be created.\r
968 *       port_num\r
969 *               [in] Port number for which this special queue pair is created.\r
970 *       qp_context\r
971 *               [in] User specified context passed during the async error callback\r
972 *               routine.\r
973 *       p_create_attr\r
974 *               [in] Initial set of attributes with which the queue pair is to be\r
975 *               created.\r
976 *       p_qp_attr\r
977 *               [out] QP attributes after the qp is successfully created.\r
978 *\r
979 *       ph_qp\r
980 *               [out] Handle to the special qp after its creation.\r
981 * RETURN VALUE\r
982 *       IB_SUCCESS\r
983 *               The special queue pair of the requested service type is created.\r
984 *       IB_INSUFFICIENT_RESOURCES\r
985 *               Insufficient resources to satisfy the request.\r
986 *       IB_NOT_FOUND\r
987 *               Indicated port guid is not found on this HCA.\r
988 *       IB_INVALID_CQ_HANDLE\r
989 *               Invalid cq handle passed to send/receive side.\r
990 *       IB_INVALID_MAX_WRS\r
991 *               Max WRS capacity exceeded\r
992 *       IB_INVALID_MAX_SGE\r
993 *               Max Scatter gather element request exceeds HCA capability\r
994 *       IB_RESOURCE_BUSY\r
995 *               Applicable to SMI/GSI qp's. This return code means that the SMI/GSI\r
996 *               QP is already allocated.\r
997 *       IB_INVALID_PD\r
998 *               Invalid protection domain supplied.\r
999 *       IB_INVALID_PORT\r
1000 *               Invalid port number supplied.\r
1001 *       IB_UNSUPPORTED\r
1002 *               Raw datagram unsupported.\r
1003 *       IB_INVALID_PARAMETER\r
1004 *               The parameter p_create_attr is not valid.\r
1005 * NOTES\r
1006 *       This verb is privileged and only available in kernel mode. The User mode\r
1007 *       clients that need access to SMI/GSI qp's is recommended to do this via\r
1008 *       a higher level of abstraction.\r
1009 * SEE ALSO\r
1010 *       ci_create_qp, ci_query_qp, ci_modify_qp, ci_destroy_qp\r
1011 ******\r
1012 */\r
1013 \r
1014 /****f* Verbs/ci_modify_qp\r
1015 * NAME\r
1016 *       ci_modify_qp -- Modify attributes of the specified QP.\r
1017 * SYNOPSIS\r
1018 */\r
1019 \r
1020 typedef ib_api_status_t\r
1021 (*ci_modify_qp) (\r
1022         IN              const   ib_qp_handle_t                          h_qp,\r
1023         IN              const   ib_qp_mod_t                                     *p_modify_attr,\r
1024                 OUT                     ib_qp_attr_t                            *p_qp_attr OPTIONAL,\r
1025         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
1026 /*\r
1027 * DESCRIPTION\r
1028 *       This routine is used to modify the qp states or other attributes of the\r
1029 *       QP. On successful completion, the requested state transition is performed\r
1030 *       and the QP is transitioned to the required state.\r
1031 * PARAMETERS\r
1032 *       h_qp\r
1033 *               [in] Handle to the queue pair whose state is to be modified.\r
1034 *       p_modify_attr\r
1035 *               [in] Specifies what attributes need to be modified in the qp.\r
1036 *       p_qp_attr\r
1037 *               [out] QP attributes after the qp is successfully created.\r
1038 *       p_umv_buf\r
1039 *               [in out] Vendor specific parameter to support user mode IO.\r
1040 * RETURN VALUE\r
1041 *       IB_SUCCESS\r
1042 *               The operation was successful and the QP attributes are modified\r
1043 *               to the requested state.\r
1044 *       IB_INSUFFICIENT_RESOURCES\r
1045 *               Insufficient resources to complete the requested operation.\r
1046 *       IB_INVALID_QP_HANDLE\r
1047 *               Invalid QP handle was passed.\r
1048 *       IB_UNSUPPORTED\r
1049 *               Requested operation is not supported, for e.g. Atomic operations.\r
1050 *       IB_QP_INVALID_STATE\r
1051 *               Invalid state transition request. Current QP state not in allowable\r
1052 *               state.\r
1053 *       IB_INVALID_PKEY\r
1054 *               Pkey specified in modify request not valid entry in P_KEY table. Or\r
1055 *               index is out of range.\r
1056 *       IB_INVALID_APM_STATE\r
1057 *               Invalid automatic path migration state specified in the request.\r
1058 *       IB_INVALID_PARAMETER\r
1059 *               The parameter p_modify_attr is not valid.\r
1060 * NOTES\r
1061 *       Refer to Table 79 in chapter 11, Volume 1 of the InfiniBand Specifications.\r
1062 * SEE ALSO\r
1063 *       ci_create_qp, ci_create_spl_qp, ci_query_qp\r
1064 ******\r
1065 */\r
1066 \r
1067 /****f* Verbs/ci_ndi_modify_qp\r
1068 * NAME\r
1069 *       ci_ndi_modify_qp -- Modify attributes of the specified QP.\r
1070 * SYNOPSIS\r
1071 */\r
1072 \r
1073 typedef ib_api_status_t\r
1074 (*ci_ndi_modify_qp) (\r
1075         IN              const   ib_qp_handle_t                          h_qp,\r
1076         IN              const   ib_qp_mod_t                                     *p_modify_attr,\r
1077                 OUT                     ib_qp_attr_t                            *p_qp_attr OPTIONAL,\r
1078         IN              const   uint32_t                                        buf_size,\r
1079         IN      OUT                     uint8_t* const                          p_outbuf);\r
1080 /*\r
1081 * DESCRIPTION\r
1082 *       This routine is used to modify the qp states or other attributes of the\r
1083 *       QP. On successful completion, the requested state transition is performed\r
1084 *       and the QP is transitioned to the required state.\r
1085 * PARAMETERS\r
1086 *       h_qp\r
1087 *               [in] Handle to the queue pair whose state is to be modified.\r
1088 *       p_modify_attr\r
1089 *               [in] Specifies what attributes need to be modified in the qp.\r
1090 *       p_qp_attr\r
1091 *               [out] QP attributes after the qp is successfully created.\r
1092 *       buf_size\r
1093 *               [in] Size of the output buffer\r
1094 *       p_outbuf\r
1095 *               [in out] Output buffer\r
1096 *\r
1097 * RETURN VALUE\r
1098 *       IB_SUCCESS\r
1099 *               The operation was successful and the QP attributes are modified\r
1100 *               to the requested state.\r
1101 *       IB_INSUFFICIENT_RESOURCES\r
1102 *               Insufficient resources to complete the requested operation.\r
1103 *       IB_INVALID_QP_HANDLE\r
1104 *               Invalid QP handle was passed.\r
1105 *       IB_UNSUPPORTED\r
1106 *               Requested operation is not supported, for e.g. Atomic operations.\r
1107 *       IB_QP_INVALID_STATE\r
1108 *               Invalid state transition request. Current QP state not in allowable\r
1109 *               state.\r
1110 *       IB_INVALID_PKEY\r
1111 *               Pkey specified in modify request not valid entry in P_KEY table. Or\r
1112 *               index is out of range.\r
1113 *       IB_INVALID_APM_STATE\r
1114 *               Invalid automatic path migration state specified in the request.\r
1115 *       IB_INVALID_PARAMETER\r
1116 *               The parameter p_modify_attr is not valid.\r
1117 * NOTES\r
1118 *       Refer to Table 79 in chapter 11, Volume 1 of the InfiniBand Specifications.\r
1119 * SEE ALSO\r
1120 *       ci_create_qp, ci_create_spl_qp, ci_query_qp\r
1121 ******\r
1122 */\r
1123 \r
1124 /****f* Verbs/ci_query_qp\r
1125 * NAME\r
1126 *       ci_query_qp -- Query the current QP attributes\r
1127 * SYNOPSIS\r
1128 */\r
1129 \r
1130 typedef ib_api_status_t\r
1131 (*ci_query_qp) (\r
1132         IN              const   ib_qp_handle_t                          h_qp,\r
1133                 OUT                     ib_qp_attr_t* const                     p_qp_attr,\r
1134         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
1135 /*\r
1136 * DESCRIPTION\r
1137 *       This routine queries the current attributes for the QP\r
1138 *       corresponding to h_qp. The attributes are returned in p_query_attr.\r
1139 *       Depending on the current state of the QP, some of the fields in the\r
1140 *       attribute structure may not be valid.\r
1141 * PARAMETERS\r
1142 *       h_qp\r
1143 *               [in] Handle to the QP for which the attributes are being retrieved\r
1144 *       p_qp_attr\r
1145 *               [out] Pointer to the ib_qp_query_t structure where the current\r
1146 *               attributes of the QP is returned.\r
1147 *       p_umv_buf\r
1148 *               [in out] Vendor specific parameter to support user mode IO.\r
1149 * RETURN VALUE\r
1150 *       IB_SUCCESS\r
1151 *               The values returned in p_qp_attr are valid.\r
1152 *       IB_INVALID_QP_HANDLE\r
1153 *               The h_qp supplied is not a valid handle.\r
1154 *       IB_INVALID_PARAMETER\r
1155 *               Parameter p_qp_attr is not valid.\r
1156 * SEE ALSO\r
1157 *       ci_create_qp\r
1158 *****\r
1159 */\r
1160 \r
1161 /****f* Verbs/ci_destroy_qp\r
1162 * NAME\r
1163 *       ci_destroy_qp -- Destroy the specified Queue Pair.\r
1164 * SYNOPSIS\r
1165 */\r
1166 \r
1167 typedef ib_api_status_t\r
1168 (*ci_destroy_qp) (\r
1169         IN      const   ib_qp_handle_t          h_qp,\r
1170         IN      const   uint64_t                        timewait );\r
1171 /*\r
1172 * DESCRIPTION\r
1173 *       Destroys the associated QP. The QP could have outstanding work requests\r
1174 *       when this call is made. Any outstanding work requests *SHALL NOT* be\r
1175 *       completed after this routine returns.\r
1176 * PARAMETERS\r
1177 *       h_qp\r
1178 *               [in] Handle to the qp that needs to be destroyed.\r
1179 *       timewait\r
1180 *               [in] Time (in microseconds) at which the QP should leave\r
1181 *               the timewait state and can be reused.\r
1182 *\r
1183 * RETURN VALUE\r
1184 *       IB_SUCCESS\r
1185 *               The intend to destroy this queue pair is registered and no further\r
1186 *               work requests will be processed. When no pending callbacks are in\r
1187 *               progress, the destroy_callback function is invoked which marks the\r
1188 *               destruction of the resource. The consumer can be guaranteed that\r
1189 *               no future callbacks will be propagated on behalf of this resource.\r
1190 *       IB_INVALID_QP_HANDLE\r
1191 *               The handle passed is invalid.\r
1192 *       IB_RESOURCE_BUSY\r
1193 *               If the queue pair is a unreliable datagram service type, and\r
1194 *               is still bound to a multicast group.\r
1195 * NOTES\r
1196 *       This call cannot be called from any of the notification functions invoked\r
1197 *       by the Verbs driver. For e.g. the completion handler or the async error\r
1198 *       callback provided during the ci_open_ca() call. The call will block until\r
1199 *       all references to this adapter object is closed which includes all the\r
1200 *       pending callbacks returning back to the verbs provider driver.\r
1201 *\r
1202 *       If the CQ associated with this QP is still not destroyed, the completions\r
1203 *       on behalf of this QP can still be pulled via the ci_poll_cq() call. Any\r
1204 *       resources allocated by the Channel Interface must be deallocated as part\r
1205 *       of this call.\r
1206 * SEE ALSO\r
1207 *       ci_create_qp, ci_create_spl_qp\r
1208 ******\r
1209 */\r
1210 \r
1211 /****f* Verbs/ci_create_cq\r
1212 * NAME\r
1213 *       ci_create_cq -- Create a completion queue (CQ) on the specified HCA.\r
1214 * SYNOPSIS\r
1215 */\r
1216 \r
1217 typedef ib_api_status_t\r
1218 (*ci_create_cq) (\r
1219         IN              const   ib_ca_handle_t                          h_ca,\r
1220         IN              const   void                                            *cq_context,\r
1221         IN      OUT                     uint32_t* const                         p_size,\r
1222                 OUT                     ib_cq_handle_t                          *ph_cq,\r
1223         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
1224 /*\r
1225 * DESCRIPTION\r
1226 *       The consumer must specify the minimum number of entries in the CQ. The\r
1227 *       exact number of entries the Channel Interface created is returned to the\r
1228 *       client. If the requested number of entries is larger than what this\r
1229 *       HCA can support, an error is returned.\r
1230 * PARAMETERS\r
1231 *       h_ca\r
1232 *               [in] A handle to the open HCA\r
1233 *       cq_context\r
1234 *               [in] The context that is passed during the completion callbacks.\r
1235 *       p_size\r
1236 *               [in out] Points to a variable containing the number of CQ entries\r
1237 *               requested by the consumer. On completion points to the size of the\r
1238 *               CQ that was created by the provider.\r
1239 *       ph_cq\r
1240 *               [out] Handle to the newly created CQ on successful creation.\r
1241 *       p_umv_buf\r
1242 *               [in out] Vendor specific parameter to support user mode IO.\r
1243 * RETURN VALUE\r
1244 *       IB_SUCCESS\r
1245 *               The operation was successful.\r
1246 *       IB_INVALID_CA_HANDLE\r
1247 *               The h_ca passed is invalid.\r
1248 *       IB_INSUFFICIENT_RESOURCES\r
1249 *               Insufficient resources to complete request.\r
1250 *       IB_INVALID_CQ_SIZE\r
1251 *               Requested CQ Size is not supported.\r
1252 *       IB_INVALID_PARAMETER\r
1253 *               one of the parameters was NULL.\r
1254 * NOTES\r
1255 *       The consumer would need a way to retrieve the cq_handle associated with\r
1256 *       context being returned, so it can perform ci_poll_cq() to retrieve\r
1257 *       completion queue entries. The handle as such is not being passed, since\r
1258 *       there is no information in the handle that is visible to the consumer.\r
1259 *       Passing a context directly would help avoid any reverse lookup that the\r
1260 *       consumer would need to perform in order to identify it's own internal\r
1261 *       data-structures needed to process this completion completely.\r
1262 * SEE ALSO\r
1263 *       ci_destroy_cq, ci_query_cq, ci_resize_cq\r
1264 ******\r
1265 */\r
1266 \r
1267 /****f* Verbs/ci_resize_cq\r
1268 * NAME\r
1269 *       ci_resize_cq -- Modify the maximum number of entries the CQ could hold.\r
1270 * SYNOPSIS\r
1271 */\r
1272 \r
1273 typedef ib_api_status_t\r
1274 (*ci_resize_cq) (\r
1275         IN              const   ib_cq_handle_t                          h_cq,\r
1276         IN      OUT                     uint32_t* const                         p_size,\r
1277         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
1278 /*\r
1279 * DESCRIPTION\r
1280 *       This routine allows the caller to modify the maximum number of entries\r
1281 *       the CQ could hold. It is possible to resize the CQ while there are\r
1282 *       entries in the CQ, and with outstanding work requests that will generate\r
1283 *       completions. If the entries in the CQ are more than the new size which is\r
1284 *       being created, an error is returned.\r
1285 * PARAMETERS\r
1286 *       h_cq\r
1287 *               [in] Completion Queue handle\r
1288 *       p_size\r
1289 *               [in out] This parameter indicates the requested size of the CQ. On\r
1290 *               successful completion, the current size allocated is returned in\r
1291 *               this same parameter.\r
1292 *       p_umv_buf\r
1293 *               [in out] Vendor specific parameter to support user mode IO.\r
1294 * RETURN VALUE\r
1295 *       IB_SUCCESS\r
1296 *               The resize operation was successful.\r
1297 *       IB_INVALID_CQ_HANDLE\r
1298 *               The CQ handle is invalid.\r
1299 *       IB_INSUFFICIENT_RESOURCES\r
1300 *               Insufficient resources to complete request.\r
1301 *       IB_INVALID_PARAMETER\r
1302 *               one of the parameters was NULL.\r
1303 *       IB_INVALID_CQ_SIZE\r
1304 *               Requested CQ Size is not supported.\r
1305 *       IB_OVERFLOW\r
1306 *               The CQ has more entries than the resize request. The CQ is not\r
1307 *               modified, and old entries still exist.\r
1308 * NOTES\r
1309 *       If the consumer wishes to resize the CQ smaller than originally created,\r
1310 *       it is recommended to retrieve all entries before performing a CQ resize\r
1311 *       operation. It is left to the verb implementer on resize operations, to\r
1312 *       actually reduce the entries, or leave it as it. The consumer must make no\r
1313 *       assumptions on the successful completion, and should only rely on the\r
1314 *       size returned in p_size.\r
1315 * SEE ALSO\r
1316 *       ci_create_cq\r
1317 ******\r
1318 */\r
1319 \r
1320 /****f* Verbs/ci_query_cq\r
1321 * NAME\r
1322 *       ci_query_cq -- Query the number of entries configured for the CQ.\r
1323 * SYNOPSIS\r
1324 */\r
1325 \r
1326 typedef ib_api_status_t\r
1327 (*ci_query_cq) (\r
1328         IN              const   ib_cq_handle_t                          h_cq,\r
1329                 OUT                     uint32_t                                        *p_size,\r
1330         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
1331 /*\r
1332 * DESCRIPTION\r
1333 *       This routine returns the maximum number of entries this completion\r
1334 *       queue is configured.\r
1335 * PARAMETERS\r
1336 *       h_cq\r
1337 *               [in] Handle to the completion queue\r
1338 *       p_size\r
1339 *               [out] The number of entries the completion queue is configured to hold\r
1340 *       p_umv_buf\r
1341 *               [in out] Vendor specific parameter to support user mode IO.\r
1342 * RETURN VALUE\r
1343 *       IB_SUCCESS\r
1344 *               The call completed successfully, and the returned values are valid\r
1345 *       IB_INVALID_CQ_HANDLE\r
1346 *               The cq_handle passed is invalid.\r
1347 *       IB_INVALID_PARAMETER\r
1348 *               one of the parameters was NULL.\r
1349 * SEE ALSO\r
1350 *       ci_create_cq, ci_resize_cq\r
1351 ******\r
1352 */\r
1353 \r
1354 /****f* Verbs/ci_destroy_cq\r
1355 * NAME\r
1356 *       ci_destroy_cq -- Destroy a completion queue.\r
1357 * SYNOPSIS\r
1358 */\r
1359 \r
1360 typedef ib_api_status_t\r
1361 (*ci_destroy_cq) (\r
1362         IN      const   ib_cq_handle_t          h_cq );\r
1363 /*\r
1364 * DESCRIPTION\r
1365 *       Destroys a completion queue. If any queue pairs are still bound\r
1366 *       to this CQ, the attempt to destroy will fail, and the CQ and associated\r
1367 *       resources are *NOT* destroyed.\r
1368 * PARAMETERS\r
1369 *       cq_handle\r
1370 *               [in] Handle to the cq that is to be destroyed.\r
1371 * RETURN VALUE\r
1372 *       IB_SUCCESS\r
1373 *               The intend to destroy the completion queue is registered successfully.\r
1374 *               The destroy_callback function will be invoked when it is safe and\r
1375 *               guarantees that no more completion callbacks will be invoked for\r
1376 *               this CQ. Any pending CQ notifications are discarded.\r
1377 *       IB_INVALID_CQ_HANDLE\r
1378 *               The CQ handle is invalid.\r
1379 *       IB_RESOURCE_BUSY\r
1380 *               Queue pairs may still be bound to this completion queue.\r
1381 *       IB_INVALID_PARAMETER\r
1382 *               one of the parameters was NULL.\r
1383 * SEE ALSO\r
1384 *       ci_create_cq\r
1385 * NOTES\r
1386 *       This call cannot be called from any of the notification functions invoked\r
1387 *       by the Verbs driver. For e.g. the completion handler or the async error\r
1388 *       callback provided during the ci_open_ca() call. The call will block until\r
1389 *       all references to this adapter object is closed which includes all the\r
1390 *       pending callbacks returning back to the verbs provider driver.\r
1391 ******\r
1392 */\r
1393 \r
1394 \r
1395 \r
1396 /****f* Verbs/ci_register_mr\r
1397 * NAME\r
1398 *       ci_register_mr -- Register a memory region with the HCA.\r
1399 * SYNOPSIS\r
1400 */\r
1401 \r
1402 typedef ib_api_status_t\r
1403 (*ci_register_mr) (\r
1404         IN              const   ib_pd_handle_t                          h_pd,\r
1405         IN              const   ib_mr_create_t* const           p_mr_create,\r
1406                 OUT                     net32_t* const                          p_lkey,\r
1407                 OUT                     net32_t* const                          p_rkey,\r
1408                 OUT                     ib_mr_handle_t *        const           ph_mr,\r
1409         IN                              boolean_t                                       um_call );\r
1410 /*\r
1411 * DESCRIPTION\r
1412 *       This routine registers a virtually contiguous region of memory with the\r
1413 *       HCA. All memory regions that need to be used by the HCA must be registered\r
1414 *       prior to use in data transfer operations. On successful completion\r
1415 *       the region handle, lkey are returned. If remote access rights are specified\r
1416 *       then the rkey is also returned.\r
1417 * PARAMETERS\r
1418 *       h_pd\r
1419 *               [in] Handle to the PD on which memory is being registered\r
1420 *       p_mr_create\r
1421 *               [in] Holds attributes for the region being registered. Look at\r
1422 *               ib_mr_create_t for more details.\r
1423 *       p_lkey\r
1424 *               [out] Local Key Attributes of the registered memory region\r
1425 *       p_rkey\r
1426 *               [out] Remote key of the registered memory region. The verbs provider\r
1427 *               is required to give this in the expected ordering on the wire. When\r
1428 *               rkey's are exchanged between remote nodes, no swapping of this data\r
1429 *               will be performed.\r
1430 *       ph_mr\r
1431 *               [out] Handle to the registered memory region. This handle is used when\r
1432 *               submitting work requests to refer to this region of memory.\r
1433 *       um_call\r
1434 *               [in] Boolean indicating whether the registration originated in user-mode.\r
1435 * RETURN VALUE\r
1436 *       IB_SUCCESS\r
1437 *               Registration with the adapter was successful.\r
1438 *       IB_INSUFFICIENT_RESOURCES\r
1439 *               Insufficient resources to satisfy request.\r
1440 *       IB_INVALID_PARAMETER\r
1441 *               One of the input pointers was NULL.\r
1442 *       IB_INVALID_PD_HANDLE\r
1443 *               Invalid mr_pdhandle\r
1444 *       IB_INVALID_PERMISSION\r
1445 *               Invalid access rights.\r
1446 * NOTES\r
1447 *       In addition to registration, the routine also pins memory, so that the\r
1448 *       physical page associated with the virtual address does not get swapped\r
1449 *       out during the time the HCA is attempting to transfer data to this\r
1450 *       address. If the memory is not pinned, this could lead to data-corruption\r
1451 *       and unpredictable behavior by the operating environment.\r
1452 *\r
1453 * SEE ALSO\r
1454 *       ci_deregister_mr, ci_query_mr, ci_register_pmr, ci_modify_mr,\r
1455 *       ci_register_smr\r
1456 ******\r
1457 */\r
1458 \r
1459 /****f* Verbs/ci_register_pmr\r
1460 * NAME\r
1461 *       ci_register_pmr -- Register a physical memory region with the HCA.\r
1462 * SYNOPSIS\r
1463 */\r
1464 \r
1465 typedef ib_api_status_t\r
1466 (*ci_register_pmr) (\r
1467         IN              const   ib_pd_handle_t                          h_pd,\r
1468         IN              const   ib_phys_create_t*const          p_pmr_create,\r
1469         IN      OUT                     uint64_t* const                         p_vaddr,\r
1470                 OUT                     net32_t* const                          p_lkey,\r
1471                 OUT                     net32_t* const                          p_rkey,\r
1472                 OUT                     ib_mr_handle_t* const           ph_mr,\r
1473         IN                              boolean_t                                       um_call );\r
1474 /*\r
1475 * DESCRIPTION\r
1476 *       This routine registers an array of physical pages as a single virtually\r
1477 *       contiguous region with the HCA. All memory regions that need to be used by\r
1478 *       the HCA must be registered prior to use in data transfer operations.\r
1479 *       On successful completion the region handle, lkey and rkey used for\r
1480 *       local and remote access authentication are returned.\r
1481 * PARAMETERS\r
1482 *       h_pd\r
1483 *               [in] Handle to the PD on which memory is being registered\r
1484 *       p_pmr_create\r
1485 *               [in] Holds attributes for the region being registered.\r
1486 *       p_vaddr\r
1487 *               [in/out] On input, references the requested virtual address for the\r
1488 *               start of the physical region.  On output, references the actual\r
1489 *               virtual address assigned to the registered region.\r
1490 *       p_lkey\r
1491 *               [out] Local key of the registered memory region\r
1492 *       p_rkey\r
1493 *               [out] Remote key of the registered memory region.The verbs provider\r
1494 *               is required to give this in the expected ordering on the wire. When\r
1495 *               rkey's are exchanged between remote nodes, no swapping of this data\r
1496 *               will be performed.\r
1497 *       ph_mr\r
1498 *               [out] Handle to the registered memory region. This handle is used when\r
1499 *               submitting work requests to refer to this region of memory.\r
1500 *       um_call\r
1501 *               [in] Boolean indicating whether the registration originated in user-mode.\r
1502 * RETURN VALUE\r
1503 *       IB_SUCCESS\r
1504 *               Registration with the adapter was successful.\r
1505 *       IB_INSUFFICIENT_RESOURCES\r
1506 *               Insufficient resources to satisfy request.\r
1507 *       IB_INVALID_PARAMETER\r
1508 *               Invalid length or address in p_mr_create. Also returned if the page_size\r
1509 *               passed is not one of supported page sizes by the HCA.\r
1510 *       IB_INVALID_PD_HANDLE\r
1511 *               Invalid mr_pdhandle\r
1512 *       IB_INVALID_PERMISSION\r
1513 *               Invalid access rights.\r
1514 * PORTABILITY\r
1515 *       Kernel Mode only\r
1516 * NOTES\r
1517 *       Remote and Atomic access settings in ib_access_ctrl_t, requires local\r
1518 *       write access to be enabled, otherwise IB_INVALID_PERMISSION is returned.\r
1519 *       The p_vaddr returned could be different from the vaddr specified in\r
1520 *       p_pmr_create.  If the requested virtual addr offset in a page does not\r
1521 *       match, the channel interface is free to pick and assign a pseudo virtual\r
1522 *       address. The address constructed is not a system virtual address, and only\r
1523 *       meaningful to the adapter to which this registration is targeted.\r
1524 * SEE ALSO\r
1525 *       ci_deregister_mr, ci_query_mr, ci_register_mr, ci_modify_mr,\r
1526 *       ci_register_smr\r
1527 ******\r
1528 */\r
1529 \r
1530 /****f* Verbs/ci_query_mr\r
1531 * NAME\r
1532 *       ci_query_mr -- Query attributes of a registered memory region\r
1533 * SYNOPSIS\r
1534 */\r
1535 \r
1536 typedef ib_api_status_t\r
1537 (*ci_query_mr) (\r
1538         IN              const   ib_mr_handle_t                  h_mr,\r
1539                 OUT                     ib_mr_attr_t*   const   p_mr_query );\r
1540 /*\r
1541 * DESCRIPTION\r
1542 *       This routine retrieves the memory region attributed of a\r
1543 *       registered memory region. The memory handle could have been\r
1544 *       obtained via ci_register_mr or ci_register_pmr.\r
1545 * PARAMETERS\r
1546 *       h_mr\r
1547 *               [in] Memory handle for which the attributes need to be retrieved.\r
1548 *       p_mr_query\r
1549 *               [out] Attributes of the memory region associated with memory handle.\r
1550 * RETURN VALUE\r
1551 *       IB_SUCCESS\r
1552 *               The routine completed successfully and attributes returned\r
1553 *               are valid.\r
1554 *       IB_INVALID_MR_HANDLE\r
1555 *               The memory handle is not valid.\r
1556 *       IB_INVALID_PARAMETER\r
1557 *               One of the input pointers was NULL.\r
1558 * NOTES\r
1559 *       Invalid handle checks are a mere signature checks in kernel mode.\r
1560 *       Drivers in kernel are expected to be good corporate citizens.\r
1561 *       In user mode, proper ownership is determined before passing handles\r
1562 *       down to kernel to protect from rogue applications.\r
1563 * SEE ALSO\r
1564 *       ci_register_mr, ci_register_pmr\r
1565 ******\r
1566 */\r
1567 \r
1568 /****f* Verbs/ci_modify_mr\r
1569 * NAME\r
1570 *       ci_modify_mr -- Modify some or all parameters of a memory region.\r
1571 * SYNOPSIS\r
1572 */\r
1573 \r
1574 typedef ib_api_status_t\r
1575 (*ci_modify_mr) (\r
1576         IN              const   ib_mr_handle_t                          h_mr,\r
1577         IN              const   ib_mr_mod_t                                     mr_modify_mask,\r
1578         IN              const   ib_mr_create_t* const           p_mr_create OPTIONAL,\r
1579                 OUT                     net32_t* const                          p_lkey,\r
1580                 OUT                     net32_t* const                          p_rkey,\r
1581         IN              const   ib_pd_handle_t                          h_pd OPTIONAL,\r
1582         IN                              boolean_t                                       um_call );\r
1583 /*\r
1584 * DESCRIPTION\r
1585 *       This routine modifies attributes of the specified memory region\r
1586 *       irrespective of whether the handle was obtained via ci_register_mr\r
1587 *       or ci_register_pmr. This verb conceptually performs a de-registration\r
1588 *       followed by a ci_register_mr.\r
1589 * PARAMETERS\r
1590 *       h_mr\r
1591 *               [in] Handle to the memory region whose attributes are to be modified.\r
1592 *       mr_modify_mask\r
1593 *               [in] Command specifying which parts of the mem_region is valid. The\r
1594 *               command is specified as a bit mask.\r
1595 *       p_mr_create\r
1596 *               [in] Desired attributes that need to be modified for mem_handle.\r
1597 *               This is an optional parameter which can be NULL if mr_modify_mask\r
1598 *               is set to IB_MR_MOD_PD.\r
1599 *       p_lkey\r
1600 *               [out] The new l_key for this newly registered memory region.\r
1601 *       p_rkey\r
1602 *               [out] The new r_key for this newly registered memory region.\r
1603 *               The verbs provider is required to give this in the expected ordering\r
1604 *               on the wire. When rkey's are exchanged between remote nodes, no\r
1605 *               swapping of this data will be performed.\r
1606 *       h_pd\r
1607 *               [in] This parameter is valid only if the IB_MR_MOD_PD flag is set\r
1608 *               in the mr_modify_req parameter. This field supplies the new\r
1609 *               protection domain to which the modified region should be\r
1610 *               associated with.\r
1611 *       um_call\r
1612 *               [in] Boolean indicating whether the registration originated in user-mode.\r
1613 * RETURN VALUE\r
1614 *       IB_SUCCESS\r
1615 *               The modify memory region request completed successfully.\r
1616 *       IB_RESOURCE_BUSY\r
1617 *               The memory region has windows bound to it.\r
1618 *       IB_INSUFFICIENT_RESOURCES\r
1619 *               Insufficient resources to complete the request.\r
1620 *       IB_INVALID_MR_HANDLE\r
1621 *               The memory handle supplied is not a valid memory region handle.\r
1622 *       IB_INVALID_PERMISSION\r
1623 *               Invalid access rights specified.\r
1624 *       IB_INVALID_PARAMETER\r
1625 *               A reference to the lkey or rkey was not provided or the specified\r
1626 *               modify mask is invalid.\r
1627 *       IB_INVALID_SETTING\r
1628 *               The specified memory region attributes are invalid.\r
1629 *       IB_INVALID_PD_HANDLE\r
1630 *               Protection domain handle supplied is not valid.\r
1631 * NOTES\r
1632 *       Remote and Atomic access settings in ib_access_ctrl_t, requires local\r
1633 *       write access to be enabled.\r
1634 *       TBD: How to handle shared memory region being passed to modify_mem?\r
1635 * SEE ALSO\r
1636 *       ci_register_mr, ci_register_pmr, ci_register_smr\r
1637 *******\r
1638 */\r
1639 \r
1640 /****f* Verbs/ci_modify_pmr\r
1641 * NAME\r
1642 *       ci_modify_pmr -- Modify some or all parameters of a memory region.\r
1643 * SYNOPSIS\r
1644 */\r
1645 \r
1646 typedef ib_api_status_t\r
1647 (*ci_modify_pmr) (\r
1648         IN              const   ib_mr_handle_t                          h_mr,\r
1649         IN              const   ib_mr_mod_t                                     mr_modify_mask,\r
1650         IN              const   ib_phys_create_t* const         p_pmr_create,\r
1651         IN      OUT                     uint64_t* const                         p_vaddr,\r
1652                 OUT                     net32_t* const                          p_lkey,\r
1653                 OUT                     net32_t* const                          p_rkey,\r
1654         IN              const   ib_pd_handle_t                          h_pd OPTIONAL,\r
1655         IN                              boolean_t                                       um_call );\r
1656 /*\r
1657 * DESCRIPTION\r
1658 *       This routine modifies attributes of the specified memory region\r
1659 *       irrespective of whether the handle was obtained via ci_register_mr\r
1660 *       or ci_register_pmr. This verb conceptually performs a de-registration\r
1661 *       followed by a ci_register_pmr.\r
1662 * PARAMETERS\r
1663 *       h_mr\r
1664 *               [in] Handle to the memory region whose attributes are to be modified.\r
1665 *       mr_modify_mask\r
1666 *               [in] Command specifying which parts of the mem_region is valid. The\r
1667 *               command is specified as a bit mask.\r
1668 *       p_pmr_create\r
1669 *               [in] Desired attributes that need to be modified for mem_handle.\r
1670 *       p_vaddr\r
1671 *               [in/out] On input, references the requested virtual address for the\r
1672 *               start of the physical region.  On output, references the actual\r
1673 *               virtual address assigned to the registered region.\r
1674 *       p_lkey\r
1675 *               [out] The new l_key for this newly registered physical memory region.\r
1676 *       p_rkey\r
1677 *               [out] The new r_key for this newly registered physical memory region.\r
1678 *               VPD is required to give this in the expected ordering on the wire. When\r
1679 *               rkey's are exchanged between remote nodes, no swapping of this data\r
1680 *               will be performed.\r
1681 *       h_pd\r
1682 *               [in] This parameter is valid only if the IB_MR_MOD_PD flag is set\r
1683 *               in the mr_modify_req parameter. This field supplies the new\r
1684 *               protection domain to which the modified region should be\r
1685 *               associated with.\r
1686 *       um_call\r
1687 *               [in] Boolean indicating whether the registration originated in user-mode.\r
1688 * RETURN VALUE\r
1689 *       IB_SUCCESS\r
1690 *               The modify memory region request completed successfully.\r
1691 *       IB_RESOURCE_BUSY\r
1692 *               The memory region has windows bound to it.\r
1693 *       IB_INSUFFICIENT_RESOURCES\r
1694 *               Insufficient resources to complete the request.\r
1695 *       IB_INVALID_MR_HANDLE\r
1696 *               The memory handle supplied is not a valid memory region handle.\r
1697 *       IB_INVALID_PERMISSION\r
1698 *               Invalid access rights specified.\r
1699 *       IB_INVALID_PARAMETER\r
1700 *               A reference to the virtual address, lkey, rkey was not provided or\r
1701 *               the specified modify mask is invalid.\r
1702 *       IB_INVALID_SETTING\r
1703 *               The specified memory region attributes are invalid.\r
1704 * PORTABILITY\r
1705 *       Kernel Mode only\r
1706 * NOTES\r
1707 *       Remote and Atomic access settings in ib_access_ctrl_t, requires local\r
1708 *       write access to be enabled.\r
1709 * SEE ALSO\r
1710 *       ci_register_mr, ci_register_pmr, ci_register_smr\r
1711 *********\r
1712 */\r
1713 \r
1714 /****f* Verbs/ci_register_smr\r
1715 * NAME\r
1716 *       ci_register_smr -- Register a memory region using same physical pages as\r
1717 *                      an existing memory region.\r
1718 * SYNOPSIS\r
1719 */\r
1720 \r
1721 typedef ib_api_status_t\r
1722 (*ci_register_smr) (\r
1723         IN              const   ib_mr_handle_t                          h_mr,\r
1724         IN              const   ib_pd_handle_t                          h_pd,\r
1725         IN              const   ib_access_t                                     access_ctrl,\r
1726         IN      OUT                     uint64_t* const                         p_vaddr,\r
1727                 OUT                     net32_t* const                          p_lkey,\r
1728                 OUT                     net32_t* const                          p_rkey,\r
1729                 OUT                     ib_mr_handle_t* const           ph_mr,\r
1730         IN                              boolean_t                                       um_call );\r
1731 /*\r
1732 * DESCRIPTION\r
1733 *       This routine registers a new memory region but shares the same set of\r
1734 *       physical pages associated with memory handle. For user mode applications\r
1735 *       the process *must* be owning memory handle for this call to be successful.\r
1736 * PARAMETERS\r
1737 *       h_mr\r
1738 *               [in] Handle to memory region whose physical pages are being registered\r
1739 *               by this shared registration.\r
1740 *       h_pd\r
1741 *               [in] Handle to the PD on which memory is being registered\r
1742 *       access_ctrl\r
1743 *               [in] Memory access restrictions on the registered memory.\r
1744 *       p_vaddr\r
1745 *               [in/out] On input, references the requested virtual address for the\r
1746 *               start of the physical region.  On output, references the actual\r
1747 *               virtual address assigned to the registered region.\r
1748 *       p_lkey\r
1749 *               [out] L_KEY for this memory region.\r
1750 *       p_rkey\r
1751 *               [out] R_KEY for this memory region. This is valid only when remote\r
1752 *               access is enabled for this region. The verbs provider\r
1753 *               is required to give this in the expected ordering on the wire. When\r
1754 *               rkey's are exchanged between remote nodes, no swapping of this data\r
1755 *               will be performed.\r
1756 *       ph_mr\r
1757 *               [out] Handle to the registered memory region. This handle is used when\r
1758 *               submitting work requests to refer to this region of memory.\r
1759 *       um_call\r
1760 *               [in] Boolean indicating whether the registration originated in user-mode.\r
1761 * RETURN VALUE\r
1762 *       IB_SUCCESS\r
1763 *               The call is successful and a new region handle returned is valid.\r
1764 *       IB_INVALID_MR_HANDLE\r
1765 *               mr_handle is invalid.\r
1766 *       IB_INVALID_PD_HANDLE\r
1767 *               mr_pdhandle supplied is invalid.\r
1768 *       IB_INVALID_PERMISSION\r
1769 *               Invalid access rights passed in mr_access.\r
1770 * NOTES\r
1771 *       ISSUE: how to deal with ci_deregister_mr, ci_modify_mr, ci_modify_pmr\r
1772 *       should we treat them as memory windows and fail those if a shared region\r
1773 *       was registered?\r
1774 * SEE ALSO\r
1775 *       ci_register_mr, ci_register_pmr, ci_modify_mr, ci_modify_pmr\r
1776 ******\r
1777 */\r
1778 \r
1779 /****f* Verbs/ci_deregister_mr\r
1780 * NAME\r
1781 *       ci_deregister_mr -- Deregister a memory region\r
1782 * SYNOPSIS\r
1783 */\r
1784 \r
1785 typedef ib_api_status_t\r
1786 (*ci_deregister_mr) (\r
1787         IN      const   ib_mr_handle_t          h_mr );\r
1788 /*\r
1789 * DESCRIPTION\r
1790 *       This routine deregisters  a memory region from the HCA. The region can\r
1791 *       de-registered only if there are no existing memory windows bound to\r
1792 *       this region, and if no existing shared memory regions were registered\r
1793 *       that refers to the same set of physical pages associated with the memory\r
1794 *       handle.  If there are outstanding work requests referring to this memory\r
1795 *       region, then after this call is successful, those work requests will\r
1796 *       complete with WRS_LOCAL_PROTECTION_ERR.\r
1797 * PARAMETERS\r
1798 *       h_mr\r
1799 *               [in] Memory handle that is being de-registered.\r
1800 * RETURN VALUE\r
1801 *       IB_SUCCESS\r
1802 *               The memory de-registration was successful\r
1803 *       IB_INVALID_MR_HANDLE\r
1804 *               The memory handle supplied is not a valid memory handle.\r
1805 *       IB_RESOURCE_BUSY\r
1806 *               The memory region has active windows bound.\r
1807 * NOTES\r
1808 * SEE ALSO\r
1809 *       ci_register_mr, ci_register_pmr, ci_register_smr\r
1810 ******\r
1811 */\r
1812 \r
1813 \r
1814 #ifdef CL_KERNEL\r
1815 /****f* Verbs/ci_alloc_mlnx_fmr\r
1816 * NAME\r
1817 *       ci_alloc_mlnx_fmr -- Allocate a Mellanox fast memory region with the HCA.\r
1818 * SYNOPSIS\r
1819 */\r
1820 typedef ib_api_status_t\r
1821 (*ci_alloc_mlnx_fmr) (\r
1822         IN              const   ib_pd_handle_t                          h_pd,\r
1823         IN                              mlnx_fmr_create_t const         *p_fmr_ctreate,\r
1824                 OUT                     mlnx_fmr_handle_t* const        ph_fmr);\r
1825 /*\r
1826 * DESCRIPTION\r
1827 *       //TODO \r
1828 * PARAMETERS\r
1829 *       h_pd\r
1830 *               [in] Handle to the PD on which fast memory is being registered\r
1831 *       mr_access_flags\r
1832 *               [in] mask of the access rights to the memory region\r
1833 *       p_fmr_attr\r
1834 *               [in] attribute of this fmr\r
1835 *       ph_fmr\r
1836 *               [out] Handle to the fast memory region. This handle is used when\r
1837 *               mapin/unmaping fmr\r
1838\r
1839 * RETURN VALUE\r
1840 *       IB_SUCCESS\r
1841 *               Registration with the adapter was successful.\r
1842 *       IB_INSUFFICIENT_RESOURCES\r
1843 *               Insufficient resources to satisfy request.\r
1844 *       IB_INVALID_PARAMETER\r
1845 *               One of the input pointers was NULL.\r
1846 *       IB_INVALID_PD_HANDLE\r
1847 *               Invalid pd handle\r
1848 *       IB_INVALID_PERMISSION\r
1849 *               Invalid access rights.\r
1850 *\r
1851 * NOTES\r
1852 *       The Alloc operation does not map nor pinned any memory.\r
1853 *       In order to use the FMR the user need to call map\r
1854 *\r
1855 *       This is a Mellanox specific extension to verbs.\r
1856 *\r
1857 * SEE ALSO\r
1858 *       ci_dealloc_mlnx_fmr, ci_map_phys_mlnx_fmr, ci_unmap_mlnx_fmr\r
1859 ******\r
1860 */\r
1861 \r
1862 \r
1863 /****f* Verbs/ci_map_phys_mlnx_fmr\r
1864 * NAME\r
1865 *       ci_map_phys_mlnx_fmr -- Map a Mellanox fast memory region with a\r
1866 *       given page list.\r
1867 *\r
1868 * SYNOPSIS\r
1869 */\r
1870 typedef ib_api_status_t\r
1871 (*ci_map_phys_mlnx_fmr) (\r
1872         IN              const   mlnx_fmr_handle_t                       h_fmr,\r
1873         IN              const   uint64_t* const                         paddr_list,\r
1874         IN              const   int                                                     list_len,\r
1875         IN      OUT                     uint64_t* const                         p_vaddr,\r
1876                 OUT                     net32_t* const                          p_lkey,\r
1877                 OUT                     net32_t* const                          p_rkey);\r
1878 /*\r
1879 * DESCRIPTION\r
1880 *       //TODO\r
1881 *\r
1882 * PARAMETERS\r
1883 *       h_fmr\r
1884 *               [in] Handle to the fast memory region that  these pages map to \r
1885 *       page_list\r
1886 *               [in] array of phys address\r
1887 *       list_len\r
1888 *               [in] number of pages in the list\r
1889 *       p_vaddr\r
1890 *               [in/out] On input, references the requested virtual address for the\r
1891 *               start of the FMR.  On output, references the actual\r
1892 *               virtual address assigned to the FMR.\r
1893 *       p_lkey\r
1894 *               [out] The local access key associated with this registered memory\r
1895 *               region.\r
1896 *       p_rkey\r
1897 *               [out] A key that may be used by a remote end-point when performing\r
1898 *               RDMA or atomic operations to this registered memory region.\r
1899 *\r
1900 * RETURN VALUE\r
1901 *       IB_SUCCESS\r
1902 *               Registration with the adapter was successful.\r
1903 *       IB_INSUFFICIENT_RESOURCES\r
1904 *               Insufficient resources to satisfy request.\r
1905 *       IB_INVALID_PARAMETER\r
1906 *               One of the input pointers was NULL.\r
1907 *       IB_INVALID_PD_HANDLE\r
1908 *               Invalid pd handle\r
1909 *       IB_INVALID_PERMISSION\r
1910 *               Invalid access rights.\r
1911 *\r
1912 * NOTES\r
1913 *       The Alloc operation does not map nor pinned any memory.\r
1914 *       In order to use the FMR the user need to call map \r
1915 *\r
1916 *       This is a Mellanox specific extension to verbs.\r
1917 *\r
1918 * SEE ALSO\r
1919 *       ci_dealloc_mlnx_fmr, ci_alloc_mlnx_fmr, ci_unmap_mlnx_fmr\r
1920 ******\r
1921 */\r
1922 \r
1923 \r
1924 /****f* Verbs/ci_unmap_mlnx_fmr\r
1925 * NAME\r
1926 *       ci_unmap_mlnx_fmr -- UnMap a Mellanox fast memory region.\r
1927 * SYNOPSIS\r
1928 */\r
1929 typedef ib_api_status_t\r
1930 (*ci_unmap_mlnx_fmr) (\r
1931         IN              const   mlnx_fmr_handle_t                       *ph_fmr);\r
1932 /*\r
1933 * DESCRIPTION\r
1934 *       //TODO\r
1935 *\r
1936 * PARAMETERS\r
1937 *       h_fmr\r
1938 *               [in] Handle to the fast memory region that  these pages map to \r
1939 *\r
1940 * RETURN VALUE\r
1941 *       IB_SUCCESS\r
1942 *               Registration with the adapter was successful.\r
1943 *       IB_INSUFFICIENT_RESOURCES\r
1944 *               Insufficient resources to satisfy request.\r
1945 *       IB_INVALID_PARAMETER\r
1946 *               One of the input pointers was NULL.\r
1947 *       IB_INVALID_PD_HANDLE\r
1948 *               Invalid pd handle\r
1949 *       IB_INVALID_PERMISSION\r
1950 *               Invalid access rights.\r
1951 *\r
1952 * NOTES\r
1953 *       The Alloc operation does not map nor pinned any memory.\r
1954 *       In order to use the FMR the user need to call map \r
1955 *\r
1956 *       This is a Mellanox specific extension to verbs.\r
1957 *\r
1958 * SEE ALSO\r
1959 *       ci_dealloc_mlnx_fmr, ci_alloc_mlnx_fmr, ci_map_phy_mlnx_fmr\r
1960 ******\r
1961 */\r
1962 \r
1963 \r
1964 /****f* Verbs/ci_dealloc_mlnx_fmr\r
1965 * NAME\r
1966 *       ci_dealloc_mlnx_fmr -- Deallocate a Mellanox fast memory region.\r
1967 *\r
1968 * SYNOPSIS\r
1969 */\r
1970 typedef ib_api_status_t\r
1971 (*ci_dealloc_mlnx_fmr) (\r
1972         IN                      mlnx_fmr_handle_t       const           h_fmr);\r
1973 /*\r
1974 * DESCRIPTION\r
1975 *       //TODO\r
1976 *\r
1977 * PARAMETERS\r
1978 *       h_fmr\r
1979 *               [in] Handle to the fast memory region. This handle is used when\r
1980 *               mapin/unmaping fmr\r
1981 *\r
1982 * RETURN VALUE\r
1983 *       IB_SUCCESS\r
1984 *               Registration with the adapter was successful.\r
1985 *       IB_INSUFFICIENT_RESOURCES\r
1986 *               Insufficient resources to satisfy request.\r
1987 *       IB_INVALID_PARAMETER\r
1988 *               One of the input pointers was NULL.\r
1989 *       IB_INVALID_PD_HANDLE\r
1990 *               Invalid pd handle\r
1991 *       IB_INVALID_PERMISSION\r
1992 *               Invalid access rights.\r
1993 *\r
1994 * NOTES\r
1995 *       This is a Mellanox specific extension to verbs.\r
1996 *\r
1997 * SEE ALSO\r
1998 *       ci_dealloc_mlnx_fmr, ci_map_phys_mlnx_fmr, ci_unmap_mlnx_fmr\r
1999 ******\r
2000 */\r
2001 #endif\r
2002 \r
2003 \r
2004 /****f* Verbs/ci_create_mw\r
2005 * NAME\r
2006 *       ci_create_mw -- Create a memory window entry for later use\r
2007 * SYNOPSIS\r
2008 */\r
2009 \r
2010 typedef ib_api_status_t\r
2011 (*ci_create_mw) (\r
2012         IN              const   ib_pd_handle_t                          h_pd,\r
2013                 OUT                     net32_t* const                          p_rkey,\r
2014                 OUT                     ib_mw_handle_t                          *ph_mw,\r
2015         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
2016 /*\r
2017 * DESCRIPTION\r
2018 *       This routine allocates a memory window. This window entry cannot be used\r
2019 *       for remote access unless this window is bound to a memory region\r
2020 *       via the ci_bind_mw call.\r
2021 * PARAMETERS\r
2022 *       h_pd\r
2023 *               [in] Protection domain handle to use for this memory window\r
2024 *       p_rkey\r
2025 *               [out] Remote access key that can be exchanged with a remote node to\r
2026 *               perform RDMA transactions on this memory window. This R_KEY is still not\r
2027 *               bound to any memory regions, until a successful call to ci_bind_mw.\r
2028 *               VPD is required to give this in the expected ordering on the wire. When\r
2029 *               rkey's are exchanged between remote nodes, no swapping of this data\r
2030 *               will be performed.\r
2031 *       ph_mw\r
2032 *               [out] Handle to the newly created memory window.\r
2033 *       p_umv_buf\r
2034 *               [in out] Vendor specific parameter to support user mode IO.\r
2035 * RETURN VALUE\r
2036 *       IB_SUCCESS\r
2037 *               The memory window allocation completed successfully.\r
2038 *       IB_INSUFFICIENT_RESOURCES\r
2039 *               Not enough resources to complete the request.\r
2040 *       IB_INVALID_PD_HANDLE\r
2041 *               pd_handle supplied is invalid.\r
2042 *       IB_INVALID_PARAMETER\r
2043 *               One of the pointers was not valid.\r
2044 * SEE ALSO\r
2045 *       ci_destroy_mw, ci_query_mw, ci_bind_mw\r
2046 ******\r
2047 */\r
2048 \r
2049 /****f* Verbs/ci_query_mw\r
2050 * NAME\r
2051 *       ci_query_mw -- Query memory window attributes for memory window handle\r
2052 * SYNOPSIS\r
2053 */\r
2054 \r
2055 typedef ib_api_status_t\r
2056 (*ci_query_mw) (\r
2057         IN              const   ib_mw_handle_t                          h_mw,\r
2058                 OUT                     ib_pd_handle_t                          *ph_pd,\r
2059                 OUT                     net32_t* const                          p_rkey,\r
2060         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
2061 /*\r
2062 * DESCRIPTION\r
2063 *       This routine retrieves the current R_KEY and protection domain\r
2064 *       handle associated with this mw_handle.\r
2065 * PARAMETERS\r
2066 *       h_mw\r
2067 *               [in] Memory window handle whose attributes are being retrieved.\r
2068 *       ph_pd\r
2069 *               [out] Protection domain handle associated with this mw_handle\r
2070 *       p_rkey\r
2071 *               [out] Current R_KEY associated with this mw_handle.The verbs provider\r
2072 *               is required to give this in the expected ordering on the wire. When\r
2073 *               rkey's are exchanged between remote nodes, no swapping of this data\r
2074 *               will be performed.\r
2075 *       p_umv_buf\r
2076 *               [in out] Vendor specific parameter to support user mode IO.\r
2077 * RETURN VALUE\r
2078 *       IB_SUCCESS\r
2079 *               The query operation completed successfully.\r
2080 *       IB_INVALID_MW_HANDLE\r
2081 *               mw_handle supplied is an invalid handle\r
2082 *       IB_INVALID_PARAMETER\r
2083 *               One of the pointers was not valid.\r
2084 * SEE ALSO\r
2085 *       ci_create_mw, ci_bind_mw\r
2086 ******\r
2087 */\r
2088 \r
2089 /****f* Verbs/ci_bind_mw\r
2090 * NAME\r
2091 *       ci_bind_mw -- Bind a memory window to a memory region.\r
2092 * SYNOPSIS\r
2093 */\r
2094 \r
2095 typedef ib_api_status_t\r
2096 (*ci_bind_mw) (\r
2097         IN              const   ib_mw_handle_t                          h_mw,\r
2098         IN              const   ib_qp_handle_t                          h_qp,\r
2099         IN                              ib_bind_wr_t* const                     p_mw_bind,\r
2100                 OUT                     net32_t* const                          p_rkey );\r
2101 /*\r
2102 * DESCRIPTION\r
2103 *       This routine posts a request to bind a memory window to a registered\r
2104 *       memory region. If the queue pair was created with selectable signaling,\r
2105 *       once the operation is completed successfully then a completion queue entry\r
2106 *       is generated indicating the bind operation has completed. The IB_POST_FENCE\r
2107 *       option could be specified to cause the requestor to wait until outstanding\r
2108 *       RDMA operations can be completed.\r
2109 * PARAMETERS\r
2110 *       h_mw\r
2111 *               [in] Handle to memory window that needs to be bound to a memory region.\r
2112 *       h_qp\r
2113 *               [in] Queue Pair to which this bind request is to be posted.\r
2114 *       p_mw_bind\r
2115 *               [in] Input parameters for this bind request, consisting of virtual\r
2116 *               addr range of bind request etc.\r
2117 *       p_rkey\r
2118 *               [out] On successful completion, the new R_KEY is returned.\r
2119 *               VPD is required to give this in the expected ordering on the wire. When\r
2120 *               rkey's are exchanged between remote nodes, no swapping of this data\r
2121 *               will be performed.\r
2122 * RETURN VALUE\r
2123 *       IB_SUCCESS\r
2124 *               The memory bind operation was posted successfully.\r
2125 *       IB_INSUFFICIENT_RESOURCES\r
2126 *               Insufficient resources to complete the request.\r
2127 *               No more WQE's to post this request\r
2128 *               No more free WQE's to post this request\r
2129 *       IB_INVALID_MW_HANDLE\r
2130 *               memw_handle supplied is an invalid memory window handle.\r
2131 *       IB_INVALID_PERMISSION\r
2132 *               Invalid access rights specified in request\r
2133 *       IB_INVALID_SERVICE_TYPE\r
2134 *               Invalid service type for this qp_handle.\r
2135 *       IB_INVALID_PARAMETER\r
2136 *               One of the pointers was not valid.\r
2137 *       IB_INVALID_RKEY\r
2138 *               R_KEY specified is invalid for the memory region being bound.\r
2139 *       IB_INVALID_QP_HANDLE\r
2140 *               h_qp supplied was an invalid QP handle.\r
2141 * NOTES\r
2142 *       - A previously bound memory window can be bound to the same or different\r
2143 *       memory region.\r
2144 *\r
2145 *       - A bind operation with length of 0, invalidates any previous binding\r
2146 *       and returns an R_KEY in the unbound state.\r
2147 * SEE ALSO\r
2148 *       ci_create_mw\r
2149 ******\r
2150 */\r
2151 \r
2152 /****f* Verbs/ci_destroy_mw\r
2153 * NAME\r
2154 *       ci_destroy_mw -- Destroy a memory window.\r
2155 * SYNOPSIS\r
2156 */\r
2157 \r
2158 typedef ib_api_status_t\r
2159 (*ci_destroy_mw) (\r
2160         IN      const   ib_mw_handle_t          h_mw );\r
2161 /*\r
2162 * DESCRIPTION\r
2163 *       This routine deallocates a window entry created via a ci_create_mw.\r
2164 *       Once this operation is complete, the channel interface guarantees that\r
2165 *       no future remote accesses will be permitted to this window entry.\r
2166 * PARAMETERS\r
2167 *       h_mw\r
2168 *               [in] Handle to the memory window that is being destroyed.\r
2169 * RETURN VALUE\r
2170 *       IB_SUCCESS\r
2171 *               The destroy window request completed successfully.\r
2172 *       IB_INVALID_MW_HANDLE\r
2173 *               memw_handle supplied is invalid.\r
2174 * NOTES\r
2175 *       Deallocate memory window implicitly means the window is also unbound\r
2176 *       once the call completes successfully. Any future remote access with\r
2177 *       the same R_KEY should fail with protection violation.\r
2178 * SEE ALSO\r
2179 *       ci_create_mw\r
2180 ******\r
2181 */\r
2182 \r
2183 /****f* Verbs/ci_post_send\r
2184 * NAME\r
2185 *       ci_post_send -- Post a work request to the send side of a queue pair.\r
2186 * SYNOPSIS\r
2187 */\r
2188 \r
2189 typedef ib_api_status_t\r
2190 (*ci_post_send) (\r
2191         IN              const   ib_qp_handle_t                  h_qp,\r
2192         IN                              ib_send_wr_t*   const   p_send_wr,\r
2193                 OUT                     ib_send_wr_t                    **pp_failed );\r
2194 /*\r
2195 * DESCRIPTION\r
2196 *       This routine posts a work request to the send side of the queue pair.\r
2197 *       The different types of work request that can be posted are explained in\r
2198 *       the ib_wr_t structure. For exact details on ordering rules please consult\r
2199 *       the Volume 1, of the InfiniBand Specifications. If there is more\r
2200 *       outstanding requests posted that what the queue is configured for, an\r
2201 *       immediate error is returned.\r
2202 * PARAMETERS\r
2203 *       h_qp\r
2204 *               [in] The queue pair to which this work request is being submitted.\r
2205 *       p_send_wr\r
2206 *               [in] A pointer to the head of the list that must be posted to the\r
2207 *               Send Queue.\r
2208 *       pp_failed\r
2209 *               [out] A pointer to the head of the list that holds the failed WRs.\r
2210 *               If all the entries provided are posted with the CI, then this parameter\r
2211 *               would be set to NULL.\r
2212 * RETURN VALUE\r
2213 *       Any unsuccessful status indicates the status of the first failed request.\r
2214 *\r
2215 *       IB_SUCCESS\r
2216 *               All the work requests are completed successfully\r
2217 *       IB_INVALID_QP_HANDLE\r
2218 *               The qp_handle supplied is invalid.\r
2219 *       IB_INSUFFICIENT_RESOURCES\r
2220 *               Insufficient resources to complete the request.\r
2221 *               There are no more work elements in the channel interface to\r
2222 *               process this request, and the total outstanding work request has\r
2223 *               been exceeded.\r
2224 *       IB_INVALID_WR_TYPE\r
2225 *               The work request type was not valid.\r
2226 *       IB_INVALID_QP_STATE\r
2227 *               The queue pair is either in Reset, Init, RTR or Error state.\r
2228 *       IB_INVALID_MAX_SGE\r
2229 *               The work request has too many scatter gather elements than what the\r
2230 *               QP is configured.\r
2231 *       IB_UNSUPPORTED\r
2232 *               Atomics or Reliable datagram request is not supported by this HCA.\r
2233 *       IB_INVALID_ADDR_HANDLE\r
2234 *               Address handle supplied in the work request is invalid.\r
2235 * NOTES\r
2236 *       Please refer to Table 81 and Table 82 for allowed operation types\r
2237 *       on different types of queue pairs, and the different modifiers\r
2238 *       acceptable for the work request for different QP service types.\r
2239 * SEE ALSO\r
2240 *       ci_post_recv, ci_poll_cq\r
2241 ******\r
2242 */\r
2243 \r
2244 /****f* Verbs/ci_post_srq_recv\r
2245 * NAME\r
2246 *       ci_post_srq_recv -- Post a work request to the receive queue of a queue pair.\r
2247 * SYNOPSIS\r
2248 */\r
2249 \r
2250 typedef ib_api_status_t\r
2251 (*ci_post_srq_recv) (\r
2252         IN              const   ib_srq_handle_t                 h_srq,\r
2253         IN                              ib_recv_wr_t*   const   p_recv_wr,\r
2254                 OUT                     ib_recv_wr_t                    **pp_failed );\r
2255 /*\r
2256 * DESCRIPTION\r
2257 *       This routine allows to queue a work request to the receive side of a\r
2258 *       shared queue pair. The work_req holds necessary data to satisfy an incoming\r
2259 *       receive message. If an attempt is made to queue more work requests than\r
2260 *       what is available, an error is returned.\r
2261 * PARAMETERS\r
2262 *       h_srq\r
2263 *               [in] Handle to the queue pair to which the receive work request is being\r
2264 *               posted.\r
2265 *       p_recv_wr\r
2266 *               [in] Holds the WRs to be posted to the receive queue.\r
2267 *       pp_failed\r
2268 *               [out] If any entry could not be posted with the CI, then this points\r
2269 *               to the first WR that completed unsuccessfully. If all entries are\r
2270 *               posted, then this field is set to NULL on successful exit.\r
2271 * RETURN VALUE\r
2272 *       Any unsuccessful status indicates the status of the first failed request.\r
2273 *\r
2274 *       IB_SUCCESS\r
2275 *               The work request was successfully queued to the receive side of the QP.\r
2276 *       IB_INVALID_SRQ_HANDLE\r
2277 *               srq_handle supplied is not valid.\r
2278 *       IB_INSUFFICIENT_RESOURCES\r
2279 *               The qp has exceeded its receive queue depth than what is has been\r
2280 *               configured.\r
2281 *       IB_INVALID_WR_TYPE\r
2282 *               Invalid work request type found in the request.\r
2283 * SEE ALSO\r
2284 ******\r
2285 */\r
2286 \r
2287 \r
2288 \r
2289 /****f* Verbs/ci_post_recv\r
2290 * NAME\r
2291 *       ci_post_recv -- Post a work request to the receive queue of a queue pair.\r
2292 * SYNOPSIS\r
2293 */\r
2294 \r
2295 typedef ib_api_status_t\r
2296 (*ci_post_recv) (\r
2297         IN              const   ib_qp_handle_t                  h_qp,\r
2298         IN                              ib_recv_wr_t*   const   p_recv_wr,\r
2299                 OUT                     ib_recv_wr_t                    **pp_failed );\r
2300 /*\r
2301 * DESCRIPTION\r
2302 *       This routine allows to queue a work request to the receive side of a\r
2303 *       queue pair. The work_req holds necessary data to satisfy an incoming\r
2304 *       receive message. If an attempt is made to queue more work requests than\r
2305 *       what is available, an error is returned.\r
2306 * PARAMETERS\r
2307 *       h_qp\r
2308 *               [in] Handle to the queue pair to which the receive work request is being\r
2309 *               posted.\r
2310 *       p_recv_wr\r
2311 *               [in] Holds the WRs to be posted to the receive queue.\r
2312 *       pp_failed\r
2313 *               [out] If any entry could not be posted with the CI, then this points\r
2314 *               to the first WR that completed unsuccessfully. If all entries are\r
2315 *               posted, then this field is set to NULL on successful exit.\r
2316 * RETURN VALUE\r
2317 *       Any unsuccessful status indicates the status of the first failed request.\r
2318 *\r
2319 *       IB_SUCCESS\r
2320 *               The work request was successfully queued to the receive side of the QP.\r
2321 *       IB_INVALID_QP_HANDLE\r
2322 *               qp_handle supplied is not valid.\r
2323 *       IB_INSUFFICIENT_RESOURCES\r
2324 *               The qp has exceeded its receive queue depth than what is has been\r
2325 *               configured.\r
2326 *       IB_INVALID_WR_TYPE\r
2327 *               Invalid work request type found in the request.\r
2328 *       IB_INVALID_QP_STATE\r
2329 *               QP was in reset or init state.\r
2330 *               (TBD: there may be an errata that allows posting in init state)\r
2331 * SEE ALSO\r
2332 *       ci_post_send, ci_poll_cq.\r
2333 ******\r
2334 */\r
2335 \r
2336 /****f* Verbs/ci_peek_cq\r
2337 * NAME\r
2338 *       ci_peek_cq\r
2339 *\r
2340 * DESCRIPTION\r
2341 *       Returns the number of entries currently on the completion queue.\r
2342 *\r
2343 * SYNOPSIS\r
2344 */\r
2345 typedef ib_api_status_t\r
2346 (*ci_peek_cq) (\r
2347         IN              const   ib_cq_handle_t                          h_cq,\r
2348         OUT                             uint32_t* const                         p_n_cqes );\r
2349 /*\r
2350 * PARAMETERS\r
2351 *       h_cq\r
2352 *               [in] Handle to the completion queue to peek.\r
2353 *\r
2354 *       p_n_cqes\r
2355 *               [out] The number of completion entries on the CQ.\r
2356 *\r
2357 * RETURN VALUES\r
2358 *       IB_SUCCESS\r
2359 *               The peek operation completed successfully.\r
2360 *       IB_INVALID_CQ_HANDLE\r
2361 *               The completion queue handle was invalid.\r
2362 *       IB_INVALID_PARAMETER\r
2363 *               A reference to the completion queue entry count was not provided.\r
2364 *       IB_UNSUPPORTED\r
2365 *               This operation is not supported by the channel adapter.\r
2366 *\r
2367 * NOTES\r
2368 *       The value returned is a snapshot of the number of compleiton queue\r
2369 *       entries curently on the completion queue.  Support for this operation\r
2370 *       is optional by a channel adapter vendor.\r
2371 *\r
2372 * SEE ALSO\r
2373 *       ci_create_cq, ci_poll_cq, ci_enable_cq_notify, ci_enable_ncomp_cq_notify\r
2374 *****/\r
2375 \r
2376 /****f* Verbs/ci_poll_cq\r
2377 * NAME\r
2378 *       ci_poll_cq -- Retrieve a work completion record from a completion queue\r
2379 * SYNOPSIS\r
2380 */\r
2381 \r
2382 typedef ib_api_status_t\r
2383 (*ci_poll_cq) (\r
2384         IN              const   ib_cq_handle_t                          h_cq,\r
2385         IN      OUT                     ib_wc_t** const                         pp_free_wclist,\r
2386                 OUT                     ib_wc_t** const                         pp_done_wclist );\r
2387 /*\r
2388 * DESCRIPTION\r
2389 *       This routine retrieves a work completion entry from the specified\r
2390 *       completion queue. The contents of the data returned in a work completion\r
2391 *       is specified in ib_wc_t.\r
2392 * PARAMETERS\r
2393 *       h_cq\r
2394 *               [in] Handle to the completion queue being polled.\r
2395 *       pp_free_wclist\r
2396 *               [in out] A list of work request structures provided by the consumer\r
2397 *               for the channel interface to return completed Completion Queue\r
2398 *               entries.  If not all the entries are consumed, this list holds the\r
2399 *               list of un-utilized completion entries provided back to the consumer.\r
2400 *       pp_done_wclist\r
2401 *               [out] A list of work completions retrieved from the completion queue\r
2402 *               and successfully processed.\r
2403 * RETURN VALUE\r
2404 *       IB_SUCCESS\r
2405 *               Poll completed successfully and found one or more entries. If on\r
2406 *               completion the pp_free_wclist is empty, then there are potentially more\r
2407 *               entries and the consumer must continue to retrieve entries.\r
2408 *       IB_INVALID_CQ_HANDLE\r
2409 *               The cq_handle supplied is not valid.\r
2410 *       IB_NOT_FOUND\r
2411 *               There were no completion entries found in the specified CQ.\r
2412 * SEE ALSO\r
2413 *       ci_create_cq, ci_post_send, ci_post_recv, ci_bind_mw\r
2414 ******\r
2415 */\r
2416 \r
2417 /****f* Verbs/ci_enable_cq_notify\r
2418 * NAME\r
2419 *       ci_enable_cq_notify -- Invoke the Completion handler, on next entry added.\r
2420 * SYNOPSIS\r
2421 */\r
2422 \r
2423 typedef ib_api_status_t\r
2424 (*ci_enable_cq_notify) (\r
2425         IN      const   ib_cq_handle_t          h_cq,\r
2426         IN      const   boolean_t                       solicited );\r
2427 /*\r
2428 * DESCRIPTION\r
2429 *       This routine instructs the channel interface to invoke the completion\r
2430 *       handler when the next completion queue entry is added to this CQ.\r
2431 *       Please refer to Volume 1, of the InfiniBand specification for a complete\r
2432 *       description.\r
2433 * PARAMETERS\r
2434 *       h_cq\r
2435 *               [in] Handle to the CQ on which the notification is being enabled.\r
2436 *       solicited\r
2437 *               [in] A boolean flag indicating whether the request is to generate a\r
2438 *               notification on the next entry or on the next solicited entry\r
2439 *               being added to the completion queue.\r
2440 * RETURN VALUE\r
2441 *       IB_SUCCESS\r
2442 *               The notification request was registered successfully.\r
2443 *       IB_INVALID_CQ_HANDLE\r
2444 *               cq_handle supplied is not a valid handle.\r
2445 * NOTES\r
2446 *       The consumer cannot call a request for notification without emptying\r
2447 *       entries from the CQ. i.e if a consumer registers for a notification\r
2448 *       request in the completion callback before pulling entries from the\r
2449 *       CQ via ci_poll_cq, the notification is not generated for completions\r
2450 *       already in the CQ. For e.g. in the example below, if there are no calls\r
2451 *   to ci_poll_cq()     after the ci_enable_cq_notify(). For any CQ entries added\r
2452 *       before calling this ci_enable_cq_notify() call, the consumer does not\r
2453 *       get a completion notification callback. In order to comply with the verb\r
2454 *       spec, consumer is supposed to perform a ci_poll_cq() after the\r
2455 *       ci_enable_cq_notify() is made to retrive any entries that might have\r
2456 *       been added to the CQ before the CI registers the notification enable.\r
2457 *\r
2458 *                       while ((ret_val = ci_poll_cq(cq_handle, &free_list, &done_list)\r
2459 *                               == FSUCCESS))\r
2460 *                       {\r
2461 *                               process entries;\r
2462 *                       }\r
2463 *                       if (ret_val == IB_NOT_FOUND)\r
2464 *                               ci_enable_cq_notify(cq_handle);\r
2465 *                       // Need to perform a ci_poll_cq()\r
2466 *           // after the enable.\r
2467 * SEE ALSO\r
2468 *       ci_create_cq, ci_peek_cq, ci_poll_cq, ci_enable_ncomp_cq_notify\r
2469 ******\r
2470 */\r
2471 \r
2472 /****f* Verbs/ci_enable_ncomp_cq_notify\r
2473 * NAME\r
2474 *       ci_enable_ncomp_cq_notify -- Invoke the Completion handler when the next\r
2475 *       N completions are added.\r
2476 * SYNOPSIS\r
2477 */\r
2478 \r
2479 typedef ib_api_status_t\r
2480 (*ci_enable_ncomp_cq_notify) (\r
2481         IN              const   ib_cq_handle_t                          h_cq,\r
2482         IN              const   uint32_t                                        n_cqes );\r
2483 /*\r
2484 * DESCRIPTION\r
2485 *       This routine instructs the channel interface to invoke the completion\r
2486 *       handler when the next N completions have been added to this CQ.\r
2487 * PARAMETERS\r
2488 *       h_cq\r
2489 *               [in] Handle to the CQ on which the notification is being enabled.\r
2490 *       n_cqes\r
2491 *               [in] The number of completion queue entries to be added to the\r
2492 *               completion queue before notifying the client.  This value must\r
2493 *               greater than or equal to one and less than or equal to the size\r
2494 *               of the completion queue.\r
2495 *\r
2496 * RETURN VALUE\r
2497 *       IB_SUCCESS\r
2498 *               The notification request was registered successfully.\r
2499 *       IB_INVALID_CQ_HANDLE\r
2500 *               cq_handle supplied is not a valid handle.\r
2501 *       IB_INVALID_PARAMETER\r
2502 *               The requested number of completion queue entries was invalid.\r
2503 *       IB_UNSUPPORTED\r
2504 *               This operation is not supported by the channel adapter.\r
2505 *\r
2506 * NOTES\r
2507 *       This routine instructs the channel interface to invoke the completion\r
2508 *       handler when the next N completions have been added to this CQ regardless\r
2509 *       of the completion type (solicited or unsolicited).  Any CQ entries that\r
2510 *       existed before the rearm is enabled will not result in a call to the\r
2511 *       handler.  Support for this operation is optional by a channel adapter\r
2512 *       vendor.\r
2513 *\r
2514 * SEE ALSO\r
2515 *       ci_create_cq, ci_peek_cq, ci_poll_cq, ci_enable_cq_notify\r
2516 ******\r
2517 */\r
2518 \r
2519 /****f* Verbs/ci_attach_mcast\r
2520 * NAME\r
2521 *       ci_attach_mcast -- Attach a queue pair to a multicast group\r
2522 * SYNOPSIS\r
2523 */\r
2524 \r
2525 typedef ib_api_status_t\r
2526 (*ci_attach_mcast) (\r
2527         IN              const   ib_qp_handle_t                          h_qp,\r
2528         IN              const   ib_gid_t                                        *p_mcast_gid,\r
2529         IN              const   ib_net16_t                                      mcast_lid,\r
2530                 OUT                     ib_mcast_handle_t                       *ph_mcast,\r
2531         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
2532 /*\r
2533 * DESCRIPTION\r
2534 *       This routine attaches the given qp_handle to a multicast gid as specified\r
2535 *       by mcast_gid parameter.\r
2536 * PARAMETERS\r
2537 *       h_qp\r
2538 *               [in] Queue pair handle which needs to be added to the multicast group\r
2539 *               on the adapter.\r
2540 *       mcast_lid\r
2541 *               [in] The multicast group LID value.\r
2542 *       p_mcast_gid\r
2543 *               [in] IPv6 address associated with this multicast group.\r
2544 *       ph_mcast\r
2545 *               [out] Multicast handle holding the association of this queue pair\r
2546 *               to the multicast group.\r
2547 *       p_umv_buf\r
2548 *               [in out] Vendor specific parameter to support user mode IO.\r
2549 * RETURN VALUE\r
2550 *       IB_SUCCESS\r
2551 *               The queue pair handle was successfully added to the multicast\r
2552 *               group.\r
2553 *       IB_INVALID_QP_HANDLE\r
2554 *               qp_handle supplied is invalid.\r
2555 *       IB_INVALID_SERVICE_TYPE\r
2556 *               Queue pair handle supplied is not of unreliable datagram type.\r
2557 *       IB_INVALID_GID\r
2558 *               The supplied addr is not a valid multicast ipv6 address.\r
2559 *       IB_INVALID_LID\r
2560 *               The supplied lid is not a valid multicast lid.\r
2561 *       IB_UNSUPPORTED\r
2562 *               Multicast is not supported by this HCA.\r
2563 *       IB_INSUFFICIENT_RESOURCES\r
2564 *               Insufficient resources to complete request.\r
2565 *       IB_INVALID_PARAMETER\r
2566 *               One of the parameters was NULL.\r
2567 * SEE ALSO\r
2568 *       ci_create_qp, ci_detach_mcast\r
2569 ******\r
2570 */\r
2571 \r
2572 \r
2573 /****f* Verbs/ci_detach_mcast\r
2574 * NAME\r
2575 *       ci_detach_mcast -- Detach a queue pair from a multicast group\r
2576 * SYNOPSIS\r
2577 */\r
2578 \r
2579 typedef ib_api_status_t\r
2580 (*ci_detach_mcast) (\r
2581         IN      const   ib_mcast_handle_t               h_mcast );\r
2582 /*\r
2583 * DESCRIPTION\r
2584 *       This routine detaches a queue pair from its previously associated multicast\r
2585 *       group.\r
2586 * PARAMETERS\r
2587 *       h_mcast\r
2588 *               [in] The multicast handle passed back to consumer after the\r
2589 *               ci_mcast_attach call.\r
2590 * RETURN VALUE\r
2591 *       IB_SUCCESS\r
2592 *               The qp was successfully detached from the multicast group.\r
2593 *       IB_INVALID_MCAST_HANDLE\r
2594 *               mcast_handle supplied is an invalid handle\r
2595 *       IB_INVALID_PARAMETER\r
2596 *               One of the parameters was NULL.\r
2597 * SEE ALSO\r
2598 *       ci_attach_mcast\r
2599 ******\r
2600 */\r
2601 \r
2602 /****f* Verbs/ci_local_mad\r
2603 * NAME\r
2604 *       ci_local_mad -- Request a mad to be processed by the local adapter.\r
2605 * SYNOPSIS\r
2606 */\r
2607 \r
2608 typedef ib_api_status_t\r
2609 (*ci_local_mad) (\r
2610         IN              const   ib_ca_handle_t          h_ca,\r
2611         IN              const   uint8_t                         port_num,\r
2612         IN              const   ib_av_attr_t                    *p_src_av_attr,\r
2613         IN              const   ib_mad_t                        *p_mad_in,\r
2614         OUT                     ib_mad_t                        *p_mad_out );\r
2615 /*\r
2616 * DESCRIPTION\r
2617 *       This routine is OPTIONAL for the channel interface. This is required\r
2618 *       for adapters which do not have the agents such as Subnet Management\r
2619 *       agent (SMA) Or the GSA in the Verbs Provider driver.\r
2620 *       hardware, for all such adapters the exact queue pair management of\r
2621 *       special queue pairs happen above the channel interface. This routine\r
2622 *       is used to perform local operations, since there is no agent below the\r
2623 *       channel interface. For e.g: If a Subnet Management packet (SMP) to\r
2624 *       set PORT_STATE is received, this reception is processed above the channel\r
2625 *       interface, then this call is done to set the port state on the local\r
2626 *       adapter. On successful return, the response is generated and sent to the\r
2627 *       Subnet Manager.\r
2628 * PARAMETERS\r
2629 *       h_ca\r
2630 *               [in] A handle to the channel adapter that should process the MAD.\r
2631 *               This must be the same adapter that the MAD was received on.\r
2632 *       port_num\r
2633 *               [in] port number to which this request is directed is to be sent.\r
2634 *       p_mad_in\r
2635 *               [in] pointer to a management datagram (MAD) structure containing\r
2636 *               the command to be processed.\r
2637 *       p_mad_out\r
2638 *               [out] Response packet after processing the command. The storage to this\r
2639 *               must be allocated by the consumer.\r
2640 * RETURN VALUE\r
2641 *       IB_SUCCESS\r
2642 *               Command processed successfully.\r
2643 *       IB_INVALID_CA_HANDLE\r
2644 *               The HCA handle supplied is not valid.\r
2645 *       IB_INVALID_PORT\r
2646 *               The port number supplied is invalid.\r
2647 * PORTABILITY\r
2648 *       Kernel Mode only\r
2649 * NOTES\r
2650 *       This call is provided to aid adapters that don't have a agent functionality\r
2651 *       built in the channel interface. Some adapters do have a local processor\r
2652 *       to process these packets, hence even for local port management, we can\r
2653 *       use the same mechanism we use to configure external nodes by using a\r
2654 *       hop counter = 1 in the MAD packets. If the SMA indicates it has a local\r
2655 *       sma in the ib_ca_attr_t, then the packets are posted to the adapter\r
2656 *       instead of making a private call to the adapter.\r
2657 * SEE ALSO\r
2658 *       ci_query_ca, ci_ca_attr_t\r
2659 ******\r
2660 */\r
2661 \r
2662 \r
2663 /****f* Verbs/ci_vendor_call\r
2664 * NAME\r
2665 *       ci_vendor_call\r
2666 *\r
2667 * DESCRIPTION\r
2668 *       Performs a vendor specific CA interface function call.\r
2669 *\r
2670 * SYNOPSIS\r
2671 */\r
2672 typedef ib_api_status_t\r
2673 (*ci_vendor_call)(\r
2674         IN              const   ib_ca_handle_t                          h_ca,\r
2675         IN              const   void** const                            handle_array    OPTIONAL,\r
2676         IN                              uint32_t                                        num_handles,\r
2677         IN                              ib_ci_op_t* const                       p_ci_op,\r
2678         IN      OUT                     ci_umv_buf_t                            *p_umv_buf OPTIONAL );\r
2679 /*\r
2680 * PARAMETERS\r
2681 *       h_ca\r
2682 *               [in] A handle to an opened CA.\r
2683 *\r
2684 *       handle_array\r
2685 *               [in] This parameter references an array containing handles of\r
2686 *               existing CA resources.  This array should contain all of the\r
2687 *               handles specified in the vendor specific data provided with this\r
2688 *               call.  All handles specified through this array are validated by\r
2689 *               the verbs provider driver to ensure that the number and type of\r
2690 *               handles are correct for the requested operation.\r
2691 *\r
2692 *       num_handles\r
2693 *               [in] The number of the handles in handle array.  This count is\r
2694 *               verified by the access layer.\r
2695 *\r
2696 *       p_ci_op\r
2697 *               [in] A reference to the vendor specific CA interface data\r
2698 *               structure containing the operation parameters.\r
2699 *\r
2700 *       p_umv_buf\r
2701 *               [in out] Vendor specific parameter to support user mode IO.\r
2702 *\r
2703 * RETURN VALUES\r
2704 *       IB_SUCCESS\r
2705 *               The operation was successful.\r
2706 *\r
2707 *       IB_INVALID_CA_HANDLE\r
2708 *               The CA handle was invalid.\r
2709 *\r
2710 *       IB_INVALID_PARAMETER\r
2711 *               A reference to the vendor specific data was not provided.\r
2712 *\r
2713 *       IB_INVALID_HANDLE\r
2714 *               A handle specified in the handle array was invalid.\r
2715 *\r
2716 *       IB_INSUFFICIENT_MEMORY\r
2717 *               There was insufficient memory to perform the operation.\r
2718 *\r
2719 *       IB_ERROR\r
2720 *               An error occurred while processing the command.  Additional\r
2721 *               error information is provided in the p_ci_op status field.\r
2722 *\r
2723 * NOTES\r
2724 *       This routine performs a vendor specific CA interface function call.\r
2725 *       The p_ci_op structure provides a means to pass vendor specific data to\r
2726 *       the verbs provider driver.  If the vendor specific data contains handles,\r
2727 *       the client should provide the optional handle array that lists all of\r
2728 *        all of the handles specified in the vendor specific data.  The handles\r
2729 *       in the handle array are restricted to the following types:  ib_ca_handle_t,\r
2730 *       ib_pd_handle_t, ib_cq_handle_t, ib_av_handle_t, ib_qp_handle_t,\r
2731 *       ib_mr_handle_t, or ib_mw_handle_t\r
2732 *       The contents of the handle array are verified by the\r
2733 *       access layer and the verbs provider driver.\r
2734 *\r
2735 * SEE ALSO\r
2736 *       ci_open_ca, ci_allocate_pd, ci_create_av, ci_create_cq,\r
2737 *       ci_create_qp, ci_register_mr, ci_register_pmr,\r
2738 *       ci_register_smr, ci_create_mw, ib_ci_op_t\r
2739 *****/\r
2740 \r
2741 \r
2742 #define MAX_LIB_NAME            32\r
2743 \r
2744 #ifdef CL_KERNEL\r
2745 \r
2746 /****s* Verbs/ci_interface_t\r
2747 * NAME\r
2748 *       ci_interface_t -- Interface holding Channel Interface API's\r
2749 * PURPOSE\r
2750 *       The following structure is supplied by a Channel Interface\r
2751 *       providing verbs functionality.\r
2752 * SOURCE\r
2753 */\r
2754 \r
2755 typedef struct _ci_interface\r
2756 {\r
2757         net64_t                         guid;\r
2758 \r
2759         /*\r
2760          * Device object of the HCA.  In Windows, this is a pointer to the PDO\r
2761          * for the HCA device.\r
2762          */\r
2763         void                            *p_hca_dev;\r
2764 \r
2765         /*\r
2766          * Vendor ID, Device ID, Device Revision of the HCA\r
2767          * libname refers to the user mode library to load\r
2768          * to support direct user mode IO. If vendor does not support one\r
2769          * then the fields must be initialized to all zero's.\r
2770          */\r
2771         uint32_t                        vend_id;\r
2772         uint16_t                        dev_id;\r
2773         uint16_t                        dev_revision;\r
2774         char                            libname[MAX_LIB_NAME];\r
2775         /*\r
2776          * Version of the header file this interface export can handle\r
2777          */\r
2778         uint32_t                        version;\r
2779 \r
2780         /*\r
2781          * HCA Access Verbs\r
2782          */\r
2783         ci_open_ca                      open_ca;\r
2784         ci_um_open_ca_t         um_open_ca;\r
2785         ci_query_ca                     query_ca;\r
2786         ci_modify_ca            modify_ca;\r
2787         ci_close_ca                     close_ca;\r
2788         ci_um_close_ca_t        um_close_ca;\r
2789 \r
2790         ci_vendor_call          vendor_call;\r
2791 \r
2792         /*\r
2793          * Protection Domain\r
2794          */\r
2795         ci_allocate_pd          allocate_pd;\r
2796         ci_deallocate_pd        deallocate_pd;\r
2797 \r
2798         /*\r
2799          * Address Vector Management Verbs\r
2800          */\r
2801 \r
2802         ci_create_av            create_av;\r
2803         ci_query_av                     query_av;\r
2804         ci_modify_av            modify_av;\r
2805         ci_destroy_av           destroy_av;\r
2806 \r
2807         /*\r
2808          * SRQ Management Verbs\r
2809          */\r
2810         ci_create_srq           create_srq;\r
2811         ci_modify_srq           modify_srq;\r
2812         ci_query_srq            query_srq;\r
2813         ci_destroy_srq  destroy_srq;\r
2814 \r
2815         /*\r
2816          * QP Management Verbs\r
2817          */\r
2818         ci_create_qp            create_qp;\r
2819         ci_create_spl_qp        create_spl_qp;\r
2820         ci_modify_qp            modify_qp;\r
2821         ci_query_qp                     query_qp;\r
2822         ci_destroy_qp           destroy_qp;\r
2823         ci_ndi_modify_qp        ndi_modify_qp;\r
2824 \r
2825         /*\r
2826          * Completion Queue Management Verbs\r
2827          */\r
2828         ci_create_cq            create_cq;\r
2829         ci_resize_cq            resize_cq;\r
2830         ci_query_cq                     query_cq;\r
2831         ci_destroy_cq           destroy_cq;\r
2832 \r
2833         /*\r
2834          * Memory Management Verbs\r
2835          */\r
2836         ci_register_mr          register_mr;\r
2837         ci_register_pmr         register_pmr;\r
2838         ci_query_mr                     query_mr;\r
2839         ci_modify_mr            modify_mr;\r
2840         ci_modify_pmr           modify_pmr;\r
2841         ci_register_smr         register_smr;\r
2842         ci_deregister_mr        deregister_mr;\r
2843 \r
2844         /*\r
2845          * Mellanox Fast Memory Management Verbs\r
2846          */\r
2847         ci_alloc_mlnx_fmr               alloc_mlnx_fmr;\r
2848         ci_map_phys_mlnx_fmr    map_phys_mlnx_fmr;\r
2849         ci_unmap_mlnx_fmr               unmap_mlnx_fmr;\r
2850         ci_dealloc_mlnx_fmr             dealloc_mlnx_fmr;\r
2851 \r
2852 \r
2853         /*\r
2854          * Memory Window Verbs\r
2855          */\r
2856         ci_create_mw            create_mw;\r
2857         ci_query_mw                     query_mw;\r
2858         ci_bind_mw                      bind_mw;\r
2859         ci_destroy_mw           destroy_mw;\r
2860 \r
2861         /*\r
2862          * Work Request Processing Verbs\r
2863          */\r
2864         ci_post_send            post_send;\r
2865         ci_post_recv            post_recv;\r
2866         ci_post_srq_recv        post_srq_recv;\r
2867 \r
2868         /*\r
2869          * Completion Processing and\r
2870          * Completion Notification Request Verbs.\r
2871          */\r
2872         ci_peek_cq                                      peek_cq;                                /* Optional */\r
2873         ci_poll_cq                                      poll_cq;\r
2874         ci_enable_cq_notify                     enable_cq_notify;\r
2875         ci_enable_ncomp_cq_notify       enable_ncomp_cq_notify; /* Optional */\r
2876 \r
2877         /*\r
2878          * Multicast Support Verbs\r
2879          */\r
2880         ci_attach_mcast         attach_mcast;\r
2881         ci_detach_mcast         detach_mcast;\r
2882 \r
2883         /*\r
2884          * Local MAD support, for HCA's that do not support\r
2885          * Agents in the HW.\r
2886          */\r
2887         ci_local_mad            local_mad;\r
2888 \r
2889 } ci_interface_t;\r
2890 /********/\r
2891 \r
2892 \r
2893 /****f* Verbs/ib_register_ca\r
2894 * NAME\r
2895 *       ib_register_ca -- Inform the IB Access Layer about a new HCA\r
2896 * SYNOPSIS\r
2897 */\r
2898 AL_EXPORT ib_api_status_t\r
2899 ib_register_ca (\r
2900         IN              const   ci_interface_t                          *p_ci );\r
2901 /*\r
2902 * DESCRIPTION\r
2903 *       This routine is called by a HCA kernel mode driver to inform the\r
2904 *       IB Access Layer about a new HCA that is ready for use. It is expected\r
2905 *       that the Access Layer could immediatly turn around and call for services\r
2906 *       even before the call returns back the HCA driver code. The HCA driver\r
2907 *       must initialize all resources and be ready to service any calls before adding\r
2908 *       its services to the IB Access Layer.\r
2909 *\r
2910 * PARAMETERS\r
2911 *       p_ci\r
2912 *               [in] Pointer to the ci_interface_t structure that has the function\r
2913 *               vector to support verbs functionality.\r
2914 *\r
2915 * RETURN VALUE\r
2916 *       IB_SUCCESS\r
2917 *               The registration is successful.\r
2918 *\r
2919 *       IB_INVALID_PARAMETER\r
2920 *               A reference to the CI interface structure was not provided.\r
2921 *\r
2922 *       IB_INSUFFICIENT_RESOURCES\r
2923 *               Insufficient memory to satisfy resource requirements.\r
2924 *\r
2925 *       IB_DUPLICATE_CA\r
2926 *               HCA GUID is already registered with the IB Access Layer\r
2927 *\r
2928 * PORTABILITY\r
2929 *       Kernel Mode only\r
2930 *\r
2931 * SEE ALSO\r
2932 *       ib_deregister_ca, ci_interface_t\r
2933 *******/\r
2934 \r
2935 /****f* Verbs/ib_deregister_ca\r
2936 * NAME\r
2937 *       ib_deregister_ca -- Inform the IB Access Layer that this HCA is no longer available\r
2938 * SYNOPSIS\r
2939 */\r
2940 AL_EXPORT ib_api_status_t\r
2941 ib_deregister_ca (\r
2942         IN              const   net64_t                                         ca_guid );\r
2943 /*\r
2944 * DESCRIPTION\r
2945 *       This routine is called by the HCA driver when this HCA would no longer be\r
2946 *       available for services. The access layer is expected to return all resources\r
2947 *       back to the HCA driver, and perform a ci_close_ca on this interface.\r
2948 *\r
2949 * PARAMETERS\r
2950 *       ca_guid\r
2951 *               [in] GUID of the HCA that is being removed.\r
2952 *\r
2953 * RETURN VALUE\r
2954 *       IB_SUCCESS\r
2955 *               The deregistration is successful.\r
2956 *\r
2957 *       IB_NOT_FOUND\r
2958 *               No HCA with the specified GUID is registered.\r
2959 *\r
2960 *       IB_BUSY\r
2961 *               The HCA is still in use and cannot be released.\r
2962 *\r
2963 * PORTABILITY\r
2964 *       Kernel Mode only\r
2965 *\r
2966 * SEE ALSO\r
2967 *       ib_register_ca, ci_interface_t\r
2968 *******/\r
2969 \r
2970 #endif /* CL_KERNEL */\r
2971 \r
2972 \r
2973 #ifdef __cplusplus\r
2974 }       /* extern "C" */\r
2975 #endif  /* __cplusplus */\r
2976 \r
2977 #endif // __IB_CI_H__\r