diff options
Diffstat (limited to 'drivers/infiniband/include/ib_cm.h')
-rw-r--r-- | drivers/infiniband/include/ib_cm.h | 568 |
1 files changed, 0 insertions, 568 deletions
diff --git a/drivers/infiniband/include/ib_cm.h b/drivers/infiniband/include/ib_cm.h deleted file mode 100644 index 8202ad2e6435..000000000000 --- a/drivers/infiniband/include/ib_cm.h +++ /dev/null | |||
@@ -1,568 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2004 Intel Corporation. All rights reserved. | ||
3 | * Copyright (c) 2004 Topspin Corporation. All rights reserved. | ||
4 | * Copyright (c) 2004 Voltaire Corporation. All rights reserved. | ||
5 | * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved. | ||
6 | * | ||
7 | * This software is available to you under a choice of one of two | ||
8 | * licenses. You may choose to be licensed under the terms of the GNU | ||
9 | * General Public License (GPL) Version 2, available from the file | ||
10 | * COPYING in the main directory of this source tree, or the | ||
11 | * OpenIB.org BSD license below: | ||
12 | * | ||
13 | * Redistribution and use in source and binary forms, with or | ||
14 | * without modification, are permitted provided that the following | ||
15 | * conditions are met: | ||
16 | * | ||
17 | * - Redistributions of source code must retain the above | ||
18 | * copyright notice, this list of conditions and the following | ||
19 | * disclaimer. | ||
20 | * | ||
21 | * - Redistributions in binary form must reproduce the above | ||
22 | * copyright notice, this list of conditions and the following | ||
23 | * disclaimer in the documentation and/or other materials | ||
24 | * provided with the distribution. | ||
25 | * | ||
26 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
27 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
28 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
29 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | ||
30 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | ||
31 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | ||
32 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
33 | * SOFTWARE. | ||
34 | * | ||
35 | * $Id: ib_cm.h 2730 2005-06-28 16:43:03Z sean.hefty $ | ||
36 | */ | ||
37 | #if !defined(IB_CM_H) | ||
38 | #define IB_CM_H | ||
39 | |||
40 | #include <ib_mad.h> | ||
41 | #include <ib_sa.h> | ||
42 | |||
43 | enum ib_cm_state { | ||
44 | IB_CM_IDLE, | ||
45 | IB_CM_LISTEN, | ||
46 | IB_CM_REQ_SENT, | ||
47 | IB_CM_REQ_RCVD, | ||
48 | IB_CM_MRA_REQ_SENT, | ||
49 | IB_CM_MRA_REQ_RCVD, | ||
50 | IB_CM_REP_SENT, | ||
51 | IB_CM_REP_RCVD, | ||
52 | IB_CM_MRA_REP_SENT, | ||
53 | IB_CM_MRA_REP_RCVD, | ||
54 | IB_CM_ESTABLISHED, | ||
55 | IB_CM_DREQ_SENT, | ||
56 | IB_CM_DREQ_RCVD, | ||
57 | IB_CM_TIMEWAIT, | ||
58 | IB_CM_SIDR_REQ_SENT, | ||
59 | IB_CM_SIDR_REQ_RCVD | ||
60 | }; | ||
61 | |||
62 | enum ib_cm_lap_state { | ||
63 | IB_CM_LAP_IDLE, | ||
64 | IB_CM_LAP_SENT, | ||
65 | IB_CM_LAP_RCVD, | ||
66 | IB_CM_MRA_LAP_SENT, | ||
67 | IB_CM_MRA_LAP_RCVD, | ||
68 | }; | ||
69 | |||
70 | enum ib_cm_event_type { | ||
71 | IB_CM_REQ_ERROR, | ||
72 | IB_CM_REQ_RECEIVED, | ||
73 | IB_CM_REP_ERROR, | ||
74 | IB_CM_REP_RECEIVED, | ||
75 | IB_CM_RTU_RECEIVED, | ||
76 | IB_CM_USER_ESTABLISHED, | ||
77 | IB_CM_DREQ_ERROR, | ||
78 | IB_CM_DREQ_RECEIVED, | ||
79 | IB_CM_DREP_RECEIVED, | ||
80 | IB_CM_TIMEWAIT_EXIT, | ||
81 | IB_CM_MRA_RECEIVED, | ||
82 | IB_CM_REJ_RECEIVED, | ||
83 | IB_CM_LAP_ERROR, | ||
84 | IB_CM_LAP_RECEIVED, | ||
85 | IB_CM_APR_RECEIVED, | ||
86 | IB_CM_SIDR_REQ_ERROR, | ||
87 | IB_CM_SIDR_REQ_RECEIVED, | ||
88 | IB_CM_SIDR_REP_RECEIVED | ||
89 | }; | ||
90 | |||
91 | enum ib_cm_data_size { | ||
92 | IB_CM_REQ_PRIVATE_DATA_SIZE = 92, | ||
93 | IB_CM_MRA_PRIVATE_DATA_SIZE = 222, | ||
94 | IB_CM_REJ_PRIVATE_DATA_SIZE = 148, | ||
95 | IB_CM_REP_PRIVATE_DATA_SIZE = 196, | ||
96 | IB_CM_RTU_PRIVATE_DATA_SIZE = 224, | ||
97 | IB_CM_DREQ_PRIVATE_DATA_SIZE = 220, | ||
98 | IB_CM_DREP_PRIVATE_DATA_SIZE = 224, | ||
99 | IB_CM_REJ_ARI_LENGTH = 72, | ||
100 | IB_CM_LAP_PRIVATE_DATA_SIZE = 168, | ||
101 | IB_CM_APR_PRIVATE_DATA_SIZE = 148, | ||
102 | IB_CM_APR_INFO_LENGTH = 72, | ||
103 | IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE = 216, | ||
104 | IB_CM_SIDR_REP_PRIVATE_DATA_SIZE = 136, | ||
105 | IB_CM_SIDR_REP_INFO_LENGTH = 72 | ||
106 | }; | ||
107 | |||
108 | struct ib_cm_id; | ||
109 | |||
110 | struct ib_cm_req_event_param { | ||
111 | struct ib_cm_id *listen_id; | ||
112 | struct ib_device *device; | ||
113 | u8 port; | ||
114 | |||
115 | struct ib_sa_path_rec *primary_path; | ||
116 | struct ib_sa_path_rec *alternate_path; | ||
117 | |||
118 | __be64 remote_ca_guid; | ||
119 | u32 remote_qkey; | ||
120 | u32 remote_qpn; | ||
121 | enum ib_qp_type qp_type; | ||
122 | |||
123 | u32 starting_psn; | ||
124 | u8 responder_resources; | ||
125 | u8 initiator_depth; | ||
126 | unsigned int local_cm_response_timeout:5; | ||
127 | unsigned int flow_control:1; | ||
128 | unsigned int remote_cm_response_timeout:5; | ||
129 | unsigned int retry_count:3; | ||
130 | unsigned int rnr_retry_count:3; | ||
131 | unsigned int srq:1; | ||
132 | }; | ||
133 | |||
134 | struct ib_cm_rep_event_param { | ||
135 | __be64 remote_ca_guid; | ||
136 | u32 remote_qkey; | ||
137 | u32 remote_qpn; | ||
138 | u32 starting_psn; | ||
139 | u8 responder_resources; | ||
140 | u8 initiator_depth; | ||
141 | unsigned int target_ack_delay:5; | ||
142 | unsigned int failover_accepted:2; | ||
143 | unsigned int flow_control:1; | ||
144 | unsigned int rnr_retry_count:3; | ||
145 | unsigned int srq:1; | ||
146 | }; | ||
147 | |||
148 | enum ib_cm_rej_reason { | ||
149 | IB_CM_REJ_NO_QP = 1, | ||
150 | IB_CM_REJ_NO_EEC = 2, | ||
151 | IB_CM_REJ_NO_RESOURCES = 3, | ||
152 | IB_CM_REJ_TIMEOUT = 4, | ||
153 | IB_CM_REJ_UNSUPPORTED = 5, | ||
154 | IB_CM_REJ_INVALID_COMM_ID = 6, | ||
155 | IB_CM_REJ_INVALID_COMM_INSTANCE = 7, | ||
156 | IB_CM_REJ_INVALID_SERVICE_ID = 8, | ||
157 | IB_CM_REJ_INVALID_TRANSPORT_TYPE = 9, | ||
158 | IB_CM_REJ_STALE_CONN = 10, | ||
159 | IB_CM_REJ_RDC_NOT_EXIST = 11, | ||
160 | IB_CM_REJ_INVALID_GID = 12, | ||
161 | IB_CM_REJ_INVALID_LID = 13, | ||
162 | IB_CM_REJ_INVALID_SL = 14, | ||
163 | IB_CM_REJ_INVALID_TRAFFIC_CLASS = 15, | ||
164 | IB_CM_REJ_INVALID_HOP_LIMIT = 16, | ||
165 | IB_CM_REJ_INVALID_PACKET_RATE = 17, | ||
166 | IB_CM_REJ_INVALID_ALT_GID = 18, | ||
167 | IB_CM_REJ_INVALID_ALT_LID = 19, | ||
168 | IB_CM_REJ_INVALID_ALT_SL = 20, | ||
169 | IB_CM_REJ_INVALID_ALT_TRAFFIC_CLASS = 21, | ||
170 | IB_CM_REJ_INVALID_ALT_HOP_LIMIT = 22, | ||
171 | IB_CM_REJ_INVALID_ALT_PACKET_RATE = 23, | ||
172 | IB_CM_REJ_PORT_CM_REDIRECT = 24, | ||
173 | IB_CM_REJ_PORT_REDIRECT = 25, | ||
174 | IB_CM_REJ_INVALID_MTU = 26, | ||
175 | IB_CM_REJ_INSUFFICIENT_RESP_RESOURCES = 27, | ||
176 | IB_CM_REJ_CONSUMER_DEFINED = 28, | ||
177 | IB_CM_REJ_INVALID_RNR_RETRY = 29, | ||
178 | IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID = 30, | ||
179 | IB_CM_REJ_INVALID_CLASS_VERSION = 31, | ||
180 | IB_CM_REJ_INVALID_FLOW_LABEL = 32, | ||
181 | IB_CM_REJ_INVALID_ALT_FLOW_LABEL = 33 | ||
182 | }; | ||
183 | |||
184 | struct ib_cm_rej_event_param { | ||
185 | enum ib_cm_rej_reason reason; | ||
186 | void *ari; | ||
187 | u8 ari_length; | ||
188 | }; | ||
189 | |||
190 | struct ib_cm_mra_event_param { | ||
191 | u8 service_timeout; | ||
192 | }; | ||
193 | |||
194 | struct ib_cm_lap_event_param { | ||
195 | struct ib_sa_path_rec *alternate_path; | ||
196 | }; | ||
197 | |||
198 | enum ib_cm_apr_status { | ||
199 | IB_CM_APR_SUCCESS, | ||
200 | IB_CM_APR_INVALID_COMM_ID, | ||
201 | IB_CM_APR_UNSUPPORTED, | ||
202 | IB_CM_APR_REJECT, | ||
203 | IB_CM_APR_REDIRECT, | ||
204 | IB_CM_APR_IS_CURRENT, | ||
205 | IB_CM_APR_INVALID_QPN_EECN, | ||
206 | IB_CM_APR_INVALID_LID, | ||
207 | IB_CM_APR_INVALID_GID, | ||
208 | IB_CM_APR_INVALID_FLOW_LABEL, | ||
209 | IB_CM_APR_INVALID_TCLASS, | ||
210 | IB_CM_APR_INVALID_HOP_LIMIT, | ||
211 | IB_CM_APR_INVALID_PACKET_RATE, | ||
212 | IB_CM_APR_INVALID_SL | ||
213 | }; | ||
214 | |||
215 | struct ib_cm_apr_event_param { | ||
216 | enum ib_cm_apr_status ap_status; | ||
217 | void *apr_info; | ||
218 | u8 info_len; | ||
219 | }; | ||
220 | |||
221 | struct ib_cm_sidr_req_event_param { | ||
222 | struct ib_cm_id *listen_id; | ||
223 | struct ib_device *device; | ||
224 | u8 port; | ||
225 | u16 pkey; | ||
226 | }; | ||
227 | |||
228 | enum ib_cm_sidr_status { | ||
229 | IB_SIDR_SUCCESS, | ||
230 | IB_SIDR_UNSUPPORTED, | ||
231 | IB_SIDR_REJECT, | ||
232 | IB_SIDR_NO_QP, | ||
233 | IB_SIDR_REDIRECT, | ||
234 | IB_SIDR_UNSUPPORTED_VERSION | ||
235 | }; | ||
236 | |||
237 | struct ib_cm_sidr_rep_event_param { | ||
238 | enum ib_cm_sidr_status status; | ||
239 | u32 qkey; | ||
240 | u32 qpn; | ||
241 | void *info; | ||
242 | u8 info_len; | ||
243 | |||
244 | }; | ||
245 | |||
246 | struct ib_cm_event { | ||
247 | enum ib_cm_event_type event; | ||
248 | union { | ||
249 | struct ib_cm_req_event_param req_rcvd; | ||
250 | struct ib_cm_rep_event_param rep_rcvd; | ||
251 | /* No data for RTU received events. */ | ||
252 | struct ib_cm_rej_event_param rej_rcvd; | ||
253 | struct ib_cm_mra_event_param mra_rcvd; | ||
254 | struct ib_cm_lap_event_param lap_rcvd; | ||
255 | struct ib_cm_apr_event_param apr_rcvd; | ||
256 | /* No data for DREQ/DREP received events. */ | ||
257 | struct ib_cm_sidr_req_event_param sidr_req_rcvd; | ||
258 | struct ib_cm_sidr_rep_event_param sidr_rep_rcvd; | ||
259 | enum ib_wc_status send_status; | ||
260 | } param; | ||
261 | |||
262 | void *private_data; | ||
263 | }; | ||
264 | |||
265 | /** | ||
266 | * ib_cm_handler - User-defined callback to process communication events. | ||
267 | * @cm_id: Communication identifier associated with the reported event. | ||
268 | * @event: Information about the communication event. | ||
269 | * | ||
270 | * IB_CM_REQ_RECEIVED and IB_CM_SIDR_REQ_RECEIVED communication events | ||
271 | * generated as a result of listen requests result in the allocation of a | ||
272 | * new @cm_id. The new @cm_id is returned to the user through this callback. | ||
273 | * Clients are responsible for destroying the new @cm_id. For peer-to-peer | ||
274 | * IB_CM_REQ_RECEIVED and all other events, the returned @cm_id corresponds | ||
275 | * to a user's existing communication identifier. | ||
276 | * | ||
277 | * Users may not call ib_destroy_cm_id while in the context of this callback; | ||
278 | * however, returning a non-zero value instructs the communication manager to | ||
279 | * destroy the @cm_id after the callback completes. | ||
280 | */ | ||
281 | typedef int (*ib_cm_handler)(struct ib_cm_id *cm_id, | ||
282 | struct ib_cm_event *event); | ||
283 | |||
284 | struct ib_cm_id { | ||
285 | ib_cm_handler cm_handler; | ||
286 | void *context; | ||
287 | __be64 service_id; | ||
288 | __be64 service_mask; | ||
289 | enum ib_cm_state state; /* internal CM/debug use */ | ||
290 | enum ib_cm_lap_state lap_state; /* internal CM/debug use */ | ||
291 | __be32 local_id; | ||
292 | __be32 remote_id; | ||
293 | }; | ||
294 | |||
295 | /** | ||
296 | * ib_create_cm_id - Allocate a communication identifier. | ||
297 | * @cm_handler: Callback invoked to notify the user of CM events. | ||
298 | * @context: User specified context associated with the communication | ||
299 | * identifier. | ||
300 | * | ||
301 | * Communication identifiers are used to track connection states, service | ||
302 | * ID resolution requests, and listen requests. | ||
303 | */ | ||
304 | struct ib_cm_id *ib_create_cm_id(ib_cm_handler cm_handler, | ||
305 | void *context); | ||
306 | |||
307 | /** | ||
308 | * ib_destroy_cm_id - Destroy a connection identifier. | ||
309 | * @cm_id: Connection identifier to destroy. | ||
310 | * | ||
311 | * This call blocks until the connection identifier is destroyed. | ||
312 | */ | ||
313 | void ib_destroy_cm_id(struct ib_cm_id *cm_id); | ||
314 | |||
315 | #define IB_SERVICE_ID_AGN_MASK __constant_cpu_to_be64(0xFF00000000000000ULL) | ||
316 | #define IB_CM_ASSIGN_SERVICE_ID __constant_cpu_to_be64(0x0200000000000000ULL) | ||
317 | |||
318 | /** | ||
319 | * ib_cm_listen - Initiates listening on the specified service ID for | ||
320 | * connection and service ID resolution requests. | ||
321 | * @cm_id: Connection identifier associated with the listen request. | ||
322 | * @service_id: Service identifier matched against incoming connection | ||
323 | * and service ID resolution requests. The service ID should be specified | ||
324 | * network-byte order. If set to IB_CM_ASSIGN_SERVICE_ID, the CM will | ||
325 | * assign a service ID to the caller. | ||
326 | * @service_mask: Mask applied to service ID used to listen across a | ||
327 | * range of service IDs. If set to 0, the service ID is matched | ||
328 | * exactly. This parameter is ignored if %service_id is set to | ||
329 | * IB_CM_ASSIGN_SERVICE_ID. | ||
330 | */ | ||
331 | int ib_cm_listen(struct ib_cm_id *cm_id, | ||
332 | __be64 service_id, | ||
333 | __be64 service_mask); | ||
334 | |||
335 | struct ib_cm_req_param { | ||
336 | struct ib_sa_path_rec *primary_path; | ||
337 | struct ib_sa_path_rec *alternate_path; | ||
338 | __be64 service_id; | ||
339 | u32 qp_num; | ||
340 | enum ib_qp_type qp_type; | ||
341 | u32 starting_psn; | ||
342 | const void *private_data; | ||
343 | u8 private_data_len; | ||
344 | u8 peer_to_peer; | ||
345 | u8 responder_resources; | ||
346 | u8 initiator_depth; | ||
347 | u8 remote_cm_response_timeout; | ||
348 | u8 flow_control; | ||
349 | u8 local_cm_response_timeout; | ||
350 | u8 retry_count; | ||
351 | u8 rnr_retry_count; | ||
352 | u8 max_cm_retries; | ||
353 | u8 srq; | ||
354 | }; | ||
355 | |||
356 | /** | ||
357 | * ib_send_cm_req - Sends a connection request to the remote node. | ||
358 | * @cm_id: Connection identifier that will be associated with the | ||
359 | * connection request. | ||
360 | * @param: Connection request information needed to establish the | ||
361 | * connection. | ||
362 | */ | ||
363 | int ib_send_cm_req(struct ib_cm_id *cm_id, | ||
364 | struct ib_cm_req_param *param); | ||
365 | |||
366 | struct ib_cm_rep_param { | ||
367 | u32 qp_num; | ||
368 | u32 starting_psn; | ||
369 | const void *private_data; | ||
370 | u8 private_data_len; | ||
371 | u8 responder_resources; | ||
372 | u8 initiator_depth; | ||
373 | u8 target_ack_delay; | ||
374 | u8 failover_accepted; | ||
375 | u8 flow_control; | ||
376 | u8 rnr_retry_count; | ||
377 | u8 srq; | ||
378 | }; | ||
379 | |||
380 | /** | ||
381 | * ib_send_cm_rep - Sends a connection reply in response to a connection | ||
382 | * request. | ||
383 | * @cm_id: Connection identifier that will be associated with the | ||
384 | * connection request. | ||
385 | * @param: Connection reply information needed to establish the | ||
386 | * connection. | ||
387 | */ | ||
388 | int ib_send_cm_rep(struct ib_cm_id *cm_id, | ||
389 | struct ib_cm_rep_param *param); | ||
390 | |||
391 | /** | ||
392 | * ib_send_cm_rtu - Sends a connection ready to use message in response | ||
393 | * to a connection reply message. | ||
394 | * @cm_id: Connection identifier associated with the connection request. | ||
395 | * @private_data: Optional user-defined private data sent with the | ||
396 | * ready to use message. | ||
397 | * @private_data_len: Size of the private data buffer, in bytes. | ||
398 | */ | ||
399 | int ib_send_cm_rtu(struct ib_cm_id *cm_id, | ||
400 | const void *private_data, | ||
401 | u8 private_data_len); | ||
402 | |||
403 | /** | ||
404 | * ib_send_cm_dreq - Sends a disconnection request for an existing | ||
405 | * connection. | ||
406 | * @cm_id: Connection identifier associated with the connection being | ||
407 | * released. | ||
408 | * @private_data: Optional user-defined private data sent with the | ||
409 | * disconnection request message. | ||
410 | * @private_data_len: Size of the private data buffer, in bytes. | ||
411 | */ | ||
412 | int ib_send_cm_dreq(struct ib_cm_id *cm_id, | ||
413 | const void *private_data, | ||
414 | u8 private_data_len); | ||
415 | |||
416 | /** | ||
417 | * ib_send_cm_drep - Sends a disconnection reply to a disconnection request. | ||
418 | * @cm_id: Connection identifier associated with the connection being | ||
419 | * released. | ||
420 | * @private_data: Optional user-defined private data sent with the | ||
421 | * disconnection reply message. | ||
422 | * @private_data_len: Size of the private data buffer, in bytes. | ||
423 | * | ||
424 | * If the cm_id is in the correct state, the CM will transition the connection | ||
425 | * to the timewait state, even if an error occurs sending the DREP message. | ||
426 | */ | ||
427 | int ib_send_cm_drep(struct ib_cm_id *cm_id, | ||
428 | const void *private_data, | ||
429 | u8 private_data_len); | ||
430 | |||
431 | /** | ||
432 | * ib_cm_establish - Forces a connection state to established. | ||
433 | * @cm_id: Connection identifier to transition to established. | ||
434 | * | ||
435 | * This routine should be invoked by users who receive messages on a | ||
436 | * connected QP before an RTU has been received. | ||
437 | */ | ||
438 | int ib_cm_establish(struct ib_cm_id *cm_id); | ||
439 | |||
440 | /** | ||
441 | * ib_send_cm_rej - Sends a connection rejection message to the | ||
442 | * remote node. | ||
443 | * @cm_id: Connection identifier associated with the connection being | ||
444 | * rejected. | ||
445 | * @reason: Reason for the connection request rejection. | ||
446 | * @ari: Optional additional rejection information. | ||
447 | * @ari_length: Size of the additional rejection information, in bytes. | ||
448 | * @private_data: Optional user-defined private data sent with the | ||
449 | * rejection message. | ||
450 | * @private_data_len: Size of the private data buffer, in bytes. | ||
451 | */ | ||
452 | int ib_send_cm_rej(struct ib_cm_id *cm_id, | ||
453 | enum ib_cm_rej_reason reason, | ||
454 | void *ari, | ||
455 | u8 ari_length, | ||
456 | const void *private_data, | ||
457 | u8 private_data_len); | ||
458 | |||
459 | /** | ||
460 | * ib_send_cm_mra - Sends a message receipt acknowledgement to a connection | ||
461 | * message. | ||
462 | * @cm_id: Connection identifier associated with the connection message. | ||
463 | * @service_timeout: The maximum time required for the sender to reply to | ||
464 | * to the connection message. | ||
465 | * @private_data: Optional user-defined private data sent with the | ||
466 | * message receipt acknowledgement. | ||
467 | * @private_data_len: Size of the private data buffer, in bytes. | ||
468 | */ | ||
469 | int ib_send_cm_mra(struct ib_cm_id *cm_id, | ||
470 | u8 service_timeout, | ||
471 | const void *private_data, | ||
472 | u8 private_data_len); | ||
473 | |||
474 | /** | ||
475 | * ib_send_cm_lap - Sends a load alternate path request. | ||
476 | * @cm_id: Connection identifier associated with the load alternate path | ||
477 | * message. | ||
478 | * @alternate_path: A path record that identifies the alternate path to | ||
479 | * load. | ||
480 | * @private_data: Optional user-defined private data sent with the | ||
481 | * load alternate path message. | ||
482 | * @private_data_len: Size of the private data buffer, in bytes. | ||
483 | */ | ||
484 | int ib_send_cm_lap(struct ib_cm_id *cm_id, | ||
485 | struct ib_sa_path_rec *alternate_path, | ||
486 | const void *private_data, | ||
487 | u8 private_data_len); | ||
488 | |||
489 | /** | ||
490 | * ib_cm_init_qp_attr - Initializes the QP attributes for use in transitioning | ||
491 | * to a specified QP state. | ||
492 | * @cm_id: Communication identifier associated with the QP attributes to | ||
493 | * initialize. | ||
494 | * @qp_attr: On input, specifies the desired QP state. On output, the | ||
495 | * mandatory and desired optional attributes will be set in order to | ||
496 | * modify the QP to the specified state. | ||
497 | * @qp_attr_mask: The QP attribute mask that may be used to transition the | ||
498 | * QP to the specified state. | ||
499 | * | ||
500 | * Users must set the @qp_attr->qp_state to the desired QP state. This call | ||
501 | * will set all required attributes for the given transition, along with | ||
502 | * known optional attributes. Users may override the attributes returned from | ||
503 | * this call before calling ib_modify_qp. | ||
504 | */ | ||
505 | int ib_cm_init_qp_attr(struct ib_cm_id *cm_id, | ||
506 | struct ib_qp_attr *qp_attr, | ||
507 | int *qp_attr_mask); | ||
508 | |||
509 | /** | ||
510 | * ib_send_cm_apr - Sends an alternate path response message in response to | ||
511 | * a load alternate path request. | ||
512 | * @cm_id: Connection identifier associated with the alternate path response. | ||
513 | * @status: Reply status sent with the alternate path response. | ||
514 | * @info: Optional additional information sent with the alternate path | ||
515 | * response. | ||
516 | * @info_length: Size of the additional information, in bytes. | ||
517 | * @private_data: Optional user-defined private data sent with the | ||
518 | * alternate path response message. | ||
519 | * @private_data_len: Size of the private data buffer, in bytes. | ||
520 | */ | ||
521 | int ib_send_cm_apr(struct ib_cm_id *cm_id, | ||
522 | enum ib_cm_apr_status status, | ||
523 | void *info, | ||
524 | u8 info_length, | ||
525 | const void *private_data, | ||
526 | u8 private_data_len); | ||
527 | |||
528 | struct ib_cm_sidr_req_param { | ||
529 | struct ib_sa_path_rec *path; | ||
530 | __be64 service_id; | ||
531 | int timeout_ms; | ||
532 | const void *private_data; | ||
533 | u8 private_data_len; | ||
534 | u8 max_cm_retries; | ||
535 | u16 pkey; | ||
536 | }; | ||
537 | |||
538 | /** | ||
539 | * ib_send_cm_sidr_req - Sends a service ID resolution request to the | ||
540 | * remote node. | ||
541 | * @cm_id: Communication identifier that will be associated with the | ||
542 | * service ID resolution request. | ||
543 | * @param: Service ID resolution request information. | ||
544 | */ | ||
545 | int ib_send_cm_sidr_req(struct ib_cm_id *cm_id, | ||
546 | struct ib_cm_sidr_req_param *param); | ||
547 | |||
548 | struct ib_cm_sidr_rep_param { | ||
549 | u32 qp_num; | ||
550 | u32 qkey; | ||
551 | enum ib_cm_sidr_status status; | ||
552 | const void *info; | ||
553 | u8 info_length; | ||
554 | const void *private_data; | ||
555 | u8 private_data_len; | ||
556 | }; | ||
557 | |||
558 | /** | ||
559 | * ib_send_cm_sidr_rep - Sends a service ID resolution request to the | ||
560 | * remote node. | ||
561 | * @cm_id: Communication identifier associated with the received service ID | ||
562 | * resolution request. | ||
563 | * @param: Service ID resolution reply information. | ||
564 | */ | ||
565 | int ib_send_cm_sidr_rep(struct ib_cm_id *cm_id, | ||
566 | struct ib_cm_sidr_rep_param *param); | ||
567 | |||
568 | #endif /* IB_CM_H */ | ||