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