cm_msgs.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
    3  *
    4  * Copyright (c) 2004, 2011 Intel Corporation.  All rights reserved.
    5  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
    6  * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.
    7  *
    8  * This software is available to you under a choice of one of two
    9  * licenses.  You may choose to be licensed under the terms of the GNU
   10  * General Public License (GPL) Version 2, available from the file
   11  * COPYING the madirectory of this source tree, or the
   12  * OpenIB.org BSD license below:
   13  *
   14  *     Redistribution and use source and binary forms, with or
   15  *     withmodification, are permitted provided that the following
   16  *     conditions are met:
   17  *
   18  *      - Redistributions of source code must retathe above
   19  *        copyright notice, this list of conditions and the following
   20  *        disclaimer.
   21  *
   22  *      - Redistributions binary form must reproduce the above
   23  *        copyright notice, this list of conditions and the following
   24  *        disclaimer the documentation and/or other materials
   25  *        provided with the distribution.
   26  *
   27  * THE SOFTWARE IS PROVIDED "AS IS", WITHWARRANTY OF ANY KIND,
   28  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   29  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   30  * NONINFRINGEMENT. NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
   31  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER AN
   32  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OF OR IN
   33  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS THE
   34  * SOFTWARE.
   35  *
   36  * $FreeBSD$
   37  */
   38 
   39 #if !defined(CM_MSGS_H)
   40 #define CM_MSGS_H
   41 
   42 #include <rdma/ib_mad.h>
   43 #include <rdma/ib_cm.h>
   44 
   45 /*
   46  * Parameters to routines below should be in network-byte order, and values
   47  * are returned in network-byte order.
   48  */
   49 
   50 #define IB_CM_CLASS_VERSION     2 /* IB specification 1.2 */
   51 
   52 struct cm_req_msg {
   53         struct ib_mad_hdr hdr;
   54 
   55         __be32 local_comm_id;
   56         __be32 rsvd4;
   57         __be64 service_id;
   58         __be64 local_ca_guid;
   59         __be32 rsvd24;
   60         __be32 local_qkey;
   61         /* local QPN:24, responder resources:8 */
   62         __be32 offset32;
   63         /* local EECN:24, initiator depth:8 */
   64         __be32 offset36;
   65         /*
   66          * remote EECN:24, remote CM response timeout:5,
   67          * transport service type:2, end-to-end flow control:1
   68          */
   69         __be32 offset40;
   70         /* starting PSN:24, local CM response timeout:5, retry count:3 */
   71         __be32 offset44;
   72         __be16 pkey;
   73         /* path MTU:4, RDC exists:1, RNR retry count:3. */
   74         u8 offset50;
   75         /* max CM Retries:4, SRQ:1, extended transport type:3 */
   76         u8 offset51;
   77 
   78         __be16 primary_local_lid;
   79         __be16 primary_remote_lid;
   80         union ib_gid primary_local_gid;
   81         union ib_gid primary_remote_gid;
   82         /* flow label:20, rsvd:6, packet rate:6 */
   83         __be32 primary_offset88;
   84         u8 primary_traffic_class;
   85         u8 primary_hop_limit;
   86         /* SL:4, subnet local:1, rsvd:3 */
   87         u8 primary_offset94;
   88         /* local ACK timeout:5, rsvd:3 */
   89         u8 primary_offset95;
   90 
   91         __be16 alt_local_lid;
   92         __be16 alt_remote_lid;
   93         union ib_gid alt_local_gid;
   94         union ib_gid alt_remote_gid;
   95         /* flow label:20, rsvd:6, packet rate:6 */
   96         __be32 alt_offset132;
   97         u8 alt_traffic_class;
   98         u8 alt_hop_limit;
   99         /* SL:4, subnet local:1, rsvd:3 */
  100         u8 alt_offset138;
  101         /* local ACK timeout:5, rsvd:3 */
  102         u8 alt_offset139;
  103 
  104         u32 private_data[IB_CM_REQ_PRIVATE_DATA_SIZE / sizeof(u32)];
  105 
  106 } __attribute__ ((packed));
  107 
  108 static inline __be32 cm_req_get_local_qpn(struct cm_req_msg *req_msg)
  109 {
  110         return cpu_to_be32(be32_to_cpu(req_msg->offset32) >> 8);
  111 }
  112 
  113 static inline void cm_req_set_local_qpn(struct cm_req_msg *req_msg, __be32 qpn)
  114 {
  115         req_msg->offset32 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
  116                                          (be32_to_cpu(req_msg->offset32) &
  117                                           0x000000FF));
  118 }
  119 
  120 static inline u8 cm_req_get_resp_res(struct cm_req_msg *req_msg)
  121 {
  122         return (u8) be32_to_cpu(req_msg->offset32);
  123 }
  124 
  125 static inline void cm_req_set_resp_res(struct cm_req_msg *req_msg, u8 resp_res)
  126 {
  127         req_msg->offset32 = cpu_to_be32(resp_res |
  128                                         (be32_to_cpu(req_msg->offset32) &
  129                                          0xFFFFFF00));
  130 }
  131 
  132 static inline u8 cm_req_get_init_depth(struct cm_req_msg *req_msg)
  133 {
  134         return (u8) be32_to_cpu(req_msg->offset36);
  135 }
  136 
  137 static inline void cm_req_set_init_depth(struct cm_req_msg *req_msg,
  138                                          u8 init_depth)
  139 {
  140         req_msg->offset36 = cpu_to_be32(init_depth |
  141                                         (be32_to_cpu(req_msg->offset36) &
  142                                          0xFFFFFF00));
  143 }
  144 
  145 static inline u8 cm_req_get_remote_resp_timeout(struct cm_req_msg *req_msg)
  146 {
  147         return (u8) ((be32_to_cpu(req_msg->offset40) & 0xF8) >> 3);
  148 }
  149 
  150 static inline void cm_req_set_remote_resp_timeout(struct cm_req_msg *req_msg,
  151                                                   u8 resp_timeout)
  152 {
  153         req_msg->offset40 = cpu_to_be32((resp_timeout << 3) |
  154                                          (be32_to_cpu(req_msg->offset40) &
  155                                           0xFFFFFF07));
  156 }
  157 
  158 static inline enum ib_qp_type cm_req_get_qp_type(struct cm_req_msg *req_msg)
  159 {
  160         u8 transport_type = (u8) (be32_to_cpu(req_msg->offset40) & 0x06) >> 1;
  161         switch(transport_type) {
  162         case 0: return IB_QPT_RC;
  163         case 1: return IB_QPT_UC;
  164         case 3:
  165                 switch (req_msg->offset51 & 0x7) {
  166                 case 1: return IB_QPT_XRC_TGT;
  167                 default: return 0;
  168                 }
  169         default: return 0;
  170         }
  171 }
  172 
  173 static inline void cm_req_set_qp_type(struct cm_req_msg *req_msg,
  174                                       enum ib_qp_type qp_type)
  175 {
  176         switch(qp_type) {
  177         case IB_QPT_UC:
  178                 req_msg->offset40 = cpu_to_be32((be32_to_cpu(
  179                                                   req_msg->offset40) &
  180                                                    0xFFFFFFF9) | 0x2);
  181                 break;
  182         case IB_QPT_XRC_INI:
  183                 req_msg->offset40 = cpu_to_be32((be32_to_cpu(
  184                                                  req_msg->offset40) &
  185                                                    0xFFFFFFF9) | 0x6);
  186                 req_msg->offset51 = (req_msg->offset51 & 0xF8) | 1;
  187                 break;
  188         default:
  189                 req_msg->offset40 = cpu_to_be32(be32_to_cpu(
  190                                                  req_msg->offset40) &
  191                                                   0xFFFFFFF9);
  192         }
  193 }
  194 
  195 static inline u8 cm_req_get_flow_ctrl(struct cm_req_msg *req_msg)
  196 {
  197         return be32_to_cpu(req_msg->offset40) & 0x1;
  198 }
  199 
  200 static inline void cm_req_set_flow_ctrl(struct cm_req_msg *req_msg,
  201                                         u8 flow_ctrl)
  202 {
  203         req_msg->offset40 = cpu_to_be32((flow_ctrl & 0x1) |
  204                                          (be32_to_cpu(req_msg->offset40) &
  205                                           0xFFFFFFFE));
  206 }
  207 
  208 static inline __be32 cm_req_get_starting_psn(struct cm_req_msg *req_msg)
  209 {
  210         return cpu_to_be32(be32_to_cpu(req_msg->offset44) >> 8);
  211 }
  212 
  213 static inline void cm_req_set_starting_psn(struct cm_req_msg *req_msg,
  214                                            __be32 starting_psn)
  215 {
  216         req_msg->offset44 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) |
  217                             (be32_to_cpu(req_msg->offset44) & 0x000000FF));
  218 }
  219 
  220 static inline u8 cm_req_get_local_resp_timeout(struct cm_req_msg *req_msg)
  221 {
  222         return (u8) ((be32_to_cpu(req_msg->offset44) & 0xF8) >> 3);
  223 }
  224 
  225 static inline void cm_req_set_local_resp_timeout(struct cm_req_msg *req_msg,
  226                                                  u8 resp_timeout)
  227 {
  228         req_msg->offset44 = cpu_to_be32((resp_timeout << 3) |
  229                             (be32_to_cpu(req_msg->offset44) & 0xFFFFFF07));
  230 }
  231 
  232 static inline u8 cm_req_get_retry_count(struct cm_req_msg *req_msg)
  233 {
  234         return (u8) (be32_to_cpu(req_msg->offset44) & 0x7);
  235 }
  236 
  237 static inline void cm_req_set_retry_count(struct cm_req_msg *req_msg,
  238                                           u8 retry_count)
  239 {
  240         req_msg->offset44 = cpu_to_be32((retry_count & 0x7) |
  241                             (be32_to_cpu(req_msg->offset44) & 0xFFFFFFF8));
  242 }
  243 
  244 static inline u8 cm_req_get_path_mtu(struct cm_req_msg *req_msg)
  245 {
  246         return req_msg->offset50 >> 4;
  247 }
  248 
  249 static inline void cm_req_set_path_mtu(struct cm_req_msg *req_msg, u8 path_mtu)
  250 {
  251         req_msg->offset50 = (u8) ((req_msg->offset50 & 0xF) | (path_mtu << 4));
  252 }
  253 
  254 static inline u8 cm_req_get_rnr_retry_count(struct cm_req_msg *req_msg)
  255 {
  256         return req_msg->offset50 & 0x7;
  257 }
  258 
  259 static inline void cm_req_set_rnr_retry_count(struct cm_req_msg *req_msg,
  260                                               u8 rnr_retry_count)
  261 {
  262         req_msg->offset50 = (u8) ((req_msg->offset50 & 0xF8) |
  263                                   (rnr_retry_count & 0x7));
  264 }
  265 
  266 static inline u8 cm_req_get_max_cm_retries(struct cm_req_msg *req_msg)
  267 {
  268         return req_msg->offset51 >> 4;
  269 }
  270 
  271 static inline void cm_req_set_max_cm_retries(struct cm_req_msg *req_msg,
  272                                              u8 retries)
  273 {
  274         req_msg->offset51 = (u8) ((req_msg->offset51 & 0xF) | (retries << 4));
  275 }
  276 
  277 static inline u8 cm_req_get_srq(struct cm_req_msg *req_msg)
  278 {
  279         return (req_msg->offset51 & 0x8) >> 3;
  280 }
  281 
  282 static inline void cm_req_set_srq(struct cm_req_msg *req_msg, u8 srq)
  283 {
  284         req_msg->offset51 = (u8) ((req_msg->offset51 & 0xF7) |
  285                                   ((srq & 0x1) << 3));
  286 }
  287 
  288 static inline __be32 cm_req_get_primary_flow_label(struct cm_req_msg *req_msg)
  289 {
  290         return cpu_to_be32(be32_to_cpu(req_msg->primary_offset88) >> 12);
  291 }
  292 
  293 static inline void cm_req_set_primary_flow_label(struct cm_req_msg *req_msg,
  294                                                  __be32 flow_label)
  295 {
  296         req_msg->primary_offset88 = cpu_to_be32(
  297                                     (be32_to_cpu(req_msg->primary_offset88) &
  298                                      0x00000FFF) |
  299                                      (be32_to_cpu(flow_label) << 12));
  300 }
  301 
  302 static inline u8 cm_req_get_primary_packet_rate(struct cm_req_msg *req_msg)
  303 {
  304         return (u8) (be32_to_cpu(req_msg->primary_offset88) & 0x3F);
  305 }
  306 
  307 static inline void cm_req_set_primary_packet_rate(struct cm_req_msg *req_msg,
  308                                                   u8 rate)
  309 {
  310         req_msg->primary_offset88 = cpu_to_be32(
  311                                     (be32_to_cpu(req_msg->primary_offset88) &
  312                                      0xFFFFFFC0) | (rate & 0x3F));
  313 }
  314 
  315 static inline u8 cm_req_get_primary_sl(struct cm_req_msg *req_msg)
  316 {
  317         return (u8) (req_msg->primary_offset94 >> 4);
  318 }
  319 
  320 static inline void cm_req_set_primary_sl(struct cm_req_msg *req_msg, u8 sl)
  321 {
  322         req_msg->primary_offset94 = (u8) ((req_msg->primary_offset94 & 0x0F) |
  323                                           (sl << 4));
  324 }
  325 
  326 static inline u8 cm_req_get_primary_subnet_local(struct cm_req_msg *req_msg)
  327 {
  328         return (u8) ((req_msg->primary_offset94 & 0x08) >> 3);
  329 }
  330 
  331 static inline void cm_req_set_primary_subnet_local(struct cm_req_msg *req_msg,
  332                                                    u8 subnet_local)
  333 {
  334         req_msg->primary_offset94 = (u8) ((req_msg->primary_offset94 & 0xF7) |
  335                                           ((subnet_local & 0x1) << 3));
  336 }
  337 
  338 static inline u8 cm_req_get_primary_local_ack_timeout(struct cm_req_msg *req_msg)
  339 {
  340         return (u8) (req_msg->primary_offset95 >> 3);
  341 }
  342 
  343 static inline void cm_req_set_primary_local_ack_timeout(struct cm_req_msg *req_msg,
  344                                                         u8 local_ack_timeout)
  345 {
  346         req_msg->primary_offset95 = (u8) ((req_msg->primary_offset95 & 0x07) |
  347                                           (local_ack_timeout << 3));
  348 }
  349 
  350 static inline __be32 cm_req_get_alt_flow_label(struct cm_req_msg *req_msg)
  351 {
  352         return cpu_to_be32(be32_to_cpu(req_msg->alt_offset132) >> 12);
  353 }
  354 
  355 static inline void cm_req_set_alt_flow_label(struct cm_req_msg *req_msg,
  356                                              __be32 flow_label)
  357 {
  358         req_msg->alt_offset132 = cpu_to_be32(
  359                                  (be32_to_cpu(req_msg->alt_offset132) &
  360                                   0x00000FFF) |
  361                                   (be32_to_cpu(flow_label) << 12));
  362 }
  363 
  364 static inline u8 cm_req_get_alt_packet_rate(struct cm_req_msg *req_msg)
  365 {
  366         return (u8) (be32_to_cpu(req_msg->alt_offset132) & 0x3F);
  367 }
  368 
  369 static inline void cm_req_set_alt_packet_rate(struct cm_req_msg *req_msg,
  370                                               u8 rate)
  371 {
  372         req_msg->alt_offset132 = cpu_to_be32(
  373                                  (be32_to_cpu(req_msg->alt_offset132) &
  374                                   0xFFFFFFC0) | (rate & 0x3F));
  375 }
  376 
  377 static inline u8 cm_req_get_alt_sl(struct cm_req_msg *req_msg)
  378 {
  379         return (u8) (req_msg->alt_offset138 >> 4);
  380 }
  381 
  382 static inline void cm_req_set_alt_sl(struct cm_req_msg *req_msg, u8 sl)
  383 {
  384         req_msg->alt_offset138 = (u8) ((req_msg->alt_offset138 & 0x0F) |
  385                                        (sl << 4));
  386 }
  387 
  388 static inline u8 cm_req_get_alt_subnet_local(struct cm_req_msg *req_msg)
  389 {
  390         return (u8) ((req_msg->alt_offset138 & 0x08) >> 3);
  391 }
  392 
  393 static inline void cm_req_set_alt_subnet_local(struct cm_req_msg *req_msg,
  394                                                u8 subnet_local)
  395 {
  396         req_msg->alt_offset138 = (u8) ((req_msg->alt_offset138 & 0xF7) |
  397                                        ((subnet_local & 0x1) << 3));
  398 }
  399 
  400 static inline u8 cm_req_get_alt_local_ack_timeout(struct cm_req_msg *req_msg)
  401 {
  402         return (u8) (req_msg->alt_offset139 >> 3);
  403 }
  404 
  405 static inline void cm_req_set_alt_local_ack_timeout(struct cm_req_msg *req_msg,
  406                                                     u8 local_ack_timeout)
  407 {
  408         req_msg->alt_offset139 = (u8) ((req_msg->alt_offset139 & 0x07) |
  409                                        (local_ack_timeout << 3));
  410 }
  411 
  412 /* Message REJected or MRAed */
  413 enum cm_msg_response {
  414         CM_MSG_RESPONSE_REQ = 0x0,
  415         CM_MSG_RESPONSE_REP = 0x1,
  416         CM_MSG_RESPONSE_OTHER = 0x2
  417 };
  418 
  419  struct cm_mra_msg {
  420         struct ib_mad_hdr hdr;
  421 
  422         __be32 local_comm_id;
  423         __be32 remote_comm_id;
  424         /* message MRAed:2, rsvd:6 */
  425         u8 offset8;
  426         /* service timeout:5, rsvd:3 */
  427         u8 offset9;
  428 
  429         u8 private_data[IB_CM_MRA_PRIVATE_DATA_SIZE];
  430 
  431 } __attribute__ ((packed));
  432 
  433 static inline u8 cm_mra_get_msg_mraed(struct cm_mra_msg *mra_msg)
  434 {
  435         return (u8) (mra_msg->offset8 >> 6);
  436 }
  437 
  438 static inline void cm_mra_set_msg_mraed(struct cm_mra_msg *mra_msg, u8 msg)
  439 {
  440         mra_msg->offset8 = (u8) ((mra_msg->offset8 & 0x3F) | (msg << 6));
  441 }
  442 
  443 static inline u8 cm_mra_get_service_timeout(struct cm_mra_msg *mra_msg)
  444 {
  445         return (u8) (mra_msg->offset9 >> 3);
  446 }
  447 
  448 static inline void cm_mra_set_service_timeout(struct cm_mra_msg *mra_msg,
  449                                               u8 service_timeout)
  450 {
  451         mra_msg->offset9 = (u8) ((mra_msg->offset9 & 0x07) |
  452                                  (service_timeout << 3));
  453 }
  454 
  455 struct cm_rej_msg {
  456         struct ib_mad_hdr hdr;
  457 
  458         __be32 local_comm_id;
  459         __be32 remote_comm_id;
  460         /* message REJected:2, rsvd:6 */
  461         u8 offset8;
  462         /* reject info length:7, rsvd:1. */
  463         u8 offset9;
  464         __be16 reason;
  465         u8 ari[IB_CM_REJ_ARI_LENGTH];
  466 
  467         u8 private_data[IB_CM_REJ_PRIVATE_DATA_SIZE];
  468 
  469 } __attribute__ ((packed));
  470 
  471 static inline u8 cm_rej_get_msg_rejected(struct cm_rej_msg *rej_msg)
  472 {
  473         return (u8) (rej_msg->offset8 >> 6);
  474 }
  475 
  476 static inline void cm_rej_set_msg_rejected(struct cm_rej_msg *rej_msg, u8 msg)
  477 {
  478         rej_msg->offset8 = (u8) ((rej_msg->offset8 & 0x3F) | (msg << 6));
  479 }
  480 
  481 static inline u8 cm_rej_get_reject_info_len(struct cm_rej_msg *rej_msg)
  482 {
  483         return (u8) (rej_msg->offset9 >> 1);
  484 }
  485 
  486 static inline void cm_rej_set_reject_info_len(struct cm_rej_msg *rej_msg,
  487                                               u8 len)
  488 {
  489         rej_msg->offset9 = (u8) ((rej_msg->offset9 & 0x1) | (len << 1));
  490 }
  491 
  492 struct cm_rep_msg {
  493         struct ib_mad_hdr hdr;
  494 
  495         __be32 local_comm_id;
  496         __be32 remote_comm_id;
  497         __be32 local_qkey;
  498         /* local QPN:24, rsvd:8 */
  499         __be32 offset12;
  500         /* local EECN:24, rsvd:8 */
  501         __be32 offset16;
  502         /* starting PSN:24 rsvd:8 */
  503         __be32 offset20;
  504         u8 resp_resources;
  505         u8 initiator_depth;
  506         /* target ACK delay:5, failover accepted:2, end-to-end flow control:1 */
  507         u8 offset26;
  508         /* RNR retry count:3, SRQ:1, rsvd:5 */
  509         u8 offset27;
  510         __be64 local_ca_guid;
  511 
  512         u8 private_data[IB_CM_REP_PRIVATE_DATA_SIZE];
  513 
  514 } __attribute__ ((packed));
  515 
  516 static inline __be32 cm_rep_get_local_qpn(struct cm_rep_msg *rep_msg)
  517 {
  518         return cpu_to_be32(be32_to_cpu(rep_msg->offset12) >> 8);
  519 }
  520 
  521 static inline void cm_rep_set_local_qpn(struct cm_rep_msg *rep_msg, __be32 qpn)
  522 {
  523         rep_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
  524                             (be32_to_cpu(rep_msg->offset12) & 0x000000FF));
  525 }
  526 
  527 static inline __be32 cm_rep_get_local_eecn(struct cm_rep_msg *rep_msg)
  528 {
  529         return cpu_to_be32(be32_to_cpu(rep_msg->offset16) >> 8);
  530 }
  531 
  532 static inline void cm_rep_set_local_eecn(struct cm_rep_msg *rep_msg, __be32 eecn)
  533 {
  534         rep_msg->offset16 = cpu_to_be32((be32_to_cpu(eecn) << 8) |
  535                             (be32_to_cpu(rep_msg->offset16) & 0x000000FF));
  536 }
  537 
  538 static inline __be32 cm_rep_get_qpn(struct cm_rep_msg *rep_msg, enum ib_qp_type qp_type)
  539 {
  540         return (qp_type == IB_QPT_XRC_INI) ?
  541                 cm_rep_get_local_eecn(rep_msg) : cm_rep_get_local_qpn(rep_msg);
  542 }
  543 
  544 static inline __be32 cm_rep_get_starting_psn(struct cm_rep_msg *rep_msg)
  545 {
  546         return cpu_to_be32(be32_to_cpu(rep_msg->offset20) >> 8);
  547 }
  548 
  549 static inline void cm_rep_set_starting_psn(struct cm_rep_msg *rep_msg,
  550                                            __be32 starting_psn)
  551 {
  552         rep_msg->offset20 = cpu_to_be32((be32_to_cpu(starting_psn) << 8) |
  553                             (be32_to_cpu(rep_msg->offset20) & 0x000000FF));
  554 }
  555 
  556 static inline u8 cm_rep_get_target_ack_delay(struct cm_rep_msg *rep_msg)
  557 {
  558         return (u8) (rep_msg->offset26 >> 3);
  559 }
  560 
  561 static inline void cm_rep_set_target_ack_delay(struct cm_rep_msg *rep_msg,
  562                                                u8 target_ack_delay)
  563 {
  564         rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0x07) |
  565                                   (target_ack_delay << 3));
  566 }
  567 
  568 static inline u8 cm_rep_get_failover(struct cm_rep_msg *rep_msg)
  569 {
  570         return (u8) ((rep_msg->offset26 & 0x06) >> 1);
  571 }
  572 
  573 static inline void cm_rep_set_failover(struct cm_rep_msg *rep_msg, u8 failover)
  574 {
  575         rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xF9) |
  576                                   ((failover & 0x3) << 1));
  577 }
  578 
  579 static inline u8 cm_rep_get_flow_ctrl(struct cm_rep_msg *rep_msg)
  580 {
  581         return (u8) (rep_msg->offset26 & 0x01);
  582 }
  583 
  584 static inline void cm_rep_set_flow_ctrl(struct cm_rep_msg *rep_msg,
  585                                             u8 flow_ctrl)
  586 {
  587         rep_msg->offset26 = (u8) ((rep_msg->offset26 & 0xFE) |
  588                                   (flow_ctrl & 0x1));
  589 }
  590 
  591 static inline u8 cm_rep_get_rnr_retry_count(struct cm_rep_msg *rep_msg)
  592 {
  593         return (u8) (rep_msg->offset27 >> 5);
  594 }
  595 
  596 static inline void cm_rep_set_rnr_retry_count(struct cm_rep_msg *rep_msg,
  597                                               u8 rnr_retry_count)
  598 {
  599         rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0x1F) |
  600                                   (rnr_retry_count << 5));
  601 }
  602 
  603 static inline u8 cm_rep_get_srq(struct cm_rep_msg *rep_msg)
  604 {
  605         return (u8) ((rep_msg->offset27 >> 4) & 0x1);
  606 }
  607 
  608 static inline void cm_rep_set_srq(struct cm_rep_msg *rep_msg, u8 srq)
  609 {
  610         rep_msg->offset27 = (u8) ((rep_msg->offset27 & 0xEF) |
  611                                   ((srq & 0x1) << 4));
  612 }
  613 
  614 struct cm_rtu_msg {
  615         struct ib_mad_hdr hdr;
  616 
  617         __be32 local_comm_id;
  618         __be32 remote_comm_id;
  619 
  620         u8 private_data[IB_CM_RTU_PRIVATE_DATA_SIZE];
  621 
  622 } __attribute__ ((packed));
  623 
  624 struct cm_dreq_msg {
  625         struct ib_mad_hdr hdr;
  626 
  627         __be32 local_comm_id;
  628         __be32 remote_comm_id;
  629         /* remote QPN/EECN:24, rsvd:8 */
  630         __be32 offset8;
  631 
  632         u8 private_data[IB_CM_DREQ_PRIVATE_DATA_SIZE];
  633 
  634 } __attribute__ ((packed));
  635 
  636 static inline __be32 cm_dreq_get_remote_qpn(struct cm_dreq_msg *dreq_msg)
  637 {
  638         return cpu_to_be32(be32_to_cpu(dreq_msg->offset8) >> 8);
  639 }
  640 
  641 static inline void cm_dreq_set_remote_qpn(struct cm_dreq_msg *dreq_msg, __be32 qpn)
  642 {
  643         dreq_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
  644                             (be32_to_cpu(dreq_msg->offset8) & 0x000000FF));
  645 }
  646 
  647 struct cm_drep_msg {
  648         struct ib_mad_hdr hdr;
  649 
  650         __be32 local_comm_id;
  651         __be32 remote_comm_id;
  652 
  653         u8 private_data[IB_CM_DREP_PRIVATE_DATA_SIZE];
  654 
  655 } __attribute__ ((packed));
  656 
  657 struct cm_lap_msg {
  658         struct ib_mad_hdr hdr;
  659 
  660         __be32 local_comm_id;
  661         __be32 remote_comm_id;
  662 
  663         __be32 rsvd8;
  664         /* remote QPN/EECN:24, remote CM response timeout:5, rsvd:3 */
  665         __be32 offset12;
  666         __be32 rsvd16;
  667 
  668         __be16 alt_local_lid;
  669         __be16 alt_remote_lid;
  670         union ib_gid alt_local_gid;
  671         union ib_gid alt_remote_gid;
  672         /* flow label:20, rsvd:4, traffic class:8 */
  673         __be32 offset56;
  674         u8 alt_hop_limit;
  675         /* rsvd:2, packet rate:6 */
  676         u8 offset61;
  677         /* SL:4, subnet local:1, rsvd:3 */
  678         u8 offset62;
  679         /* local ACK timeout:5, rsvd:3 */
  680         u8 offset63;
  681 
  682         u8 private_data[IB_CM_LAP_PRIVATE_DATA_SIZE];
  683 } __attribute__  ((packed));
  684 
  685 static inline __be32 cm_lap_get_remote_qpn(struct cm_lap_msg *lap_msg)
  686 {
  687         return cpu_to_be32(be32_to_cpu(lap_msg->offset12) >> 8);
  688 }
  689 
  690 static inline void cm_lap_set_remote_qpn(struct cm_lap_msg *lap_msg, __be32 qpn)
  691 {
  692         lap_msg->offset12 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
  693                                          (be32_to_cpu(lap_msg->offset12) &
  694                                           0x000000FF));
  695 }
  696 
  697 static inline u8 cm_lap_get_remote_resp_timeout(struct cm_lap_msg *lap_msg)
  698 {
  699         return (u8) ((be32_to_cpu(lap_msg->offset12) & 0xF8) >> 3);
  700 }
  701 
  702 static inline void cm_lap_set_remote_resp_timeout(struct cm_lap_msg *lap_msg,
  703                                                   u8 resp_timeout)
  704 {
  705         lap_msg->offset12 = cpu_to_be32((resp_timeout << 3) |
  706                                          (be32_to_cpu(lap_msg->offset12) &
  707                                           0xFFFFFF07));
  708 }
  709 
  710 static inline __be32 cm_lap_get_flow_label(struct cm_lap_msg *lap_msg)
  711 {
  712         return cpu_to_be32(be32_to_cpu(lap_msg->offset56) >> 12);
  713 }
  714 
  715 static inline void cm_lap_set_flow_label(struct cm_lap_msg *lap_msg,
  716                                          __be32 flow_label)
  717 {
  718         lap_msg->offset56 = cpu_to_be32(
  719                                  (be32_to_cpu(lap_msg->offset56) & 0x00000FFF) |
  720                                  (be32_to_cpu(flow_label) << 12));
  721 }
  722 
  723 static inline u8 cm_lap_get_traffic_class(struct cm_lap_msg *lap_msg)
  724 {
  725         return (u8) be32_to_cpu(lap_msg->offset56);
  726 }
  727 
  728 static inline void cm_lap_set_traffic_class(struct cm_lap_msg *lap_msg,
  729                                             u8 traffic_class)
  730 {
  731         lap_msg->offset56 = cpu_to_be32(traffic_class |
  732                                          (be32_to_cpu(lap_msg->offset56) &
  733                                           0xFFFFFF00));
  734 }
  735 
  736 static inline u8 cm_lap_get_packet_rate(struct cm_lap_msg *lap_msg)
  737 {
  738         return lap_msg->offset61 & 0x3F;
  739 }
  740 
  741 static inline void cm_lap_set_packet_rate(struct cm_lap_msg *lap_msg,
  742                                           u8 packet_rate)
  743 {
  744         lap_msg->offset61 = (packet_rate & 0x3F) | (lap_msg->offset61 & 0xC0);
  745 }
  746 
  747 static inline u8 cm_lap_get_sl(struct cm_lap_msg *lap_msg)
  748 {
  749         return lap_msg->offset62 >> 4;
  750 }
  751 
  752 static inline void cm_lap_set_sl(struct cm_lap_msg *lap_msg, u8 sl)
  753 {
  754         lap_msg->offset62 = (sl << 4) | (lap_msg->offset62 & 0x0F);
  755 }
  756 
  757 static inline u8 cm_lap_get_subnet_local(struct cm_lap_msg *lap_msg)
  758 {
  759         return (lap_msg->offset62 >> 3) & 0x1;
  760 }
  761 
  762 static inline void cm_lap_set_subnet_local(struct cm_lap_msg *lap_msg,
  763                                            u8 subnet_local)
  764 {
  765         lap_msg->offset62 = ((subnet_local & 0x1) << 3) |
  766                              (lap_msg->offset61 & 0xF7);
  767 }
  768 static inline u8 cm_lap_get_local_ack_timeout(struct cm_lap_msg *lap_msg)
  769 {
  770         return lap_msg->offset63 >> 3;
  771 }
  772 
  773 static inline void cm_lap_set_local_ack_timeout(struct cm_lap_msg *lap_msg,
  774                                                 u8 local_ack_timeout)
  775 {
  776         lap_msg->offset63 = (local_ack_timeout << 3) |
  777                             (lap_msg->offset63 & 0x07);
  778 }
  779 
  780 struct cm_apr_msg {
  781         struct ib_mad_hdr hdr;
  782 
  783         __be32 local_comm_id;
  784         __be32 remote_comm_id;
  785 
  786         u8 info_length;
  787         u8 ap_status;
  788         __be16 rsvd;
  789         u8 info[IB_CM_APR_INFO_LENGTH];
  790 
  791         u8 private_data[IB_CM_APR_PRIVATE_DATA_SIZE];
  792 } __attribute__ ((packed));
  793 
  794 struct cm_sidr_req_msg {
  795         struct ib_mad_hdr hdr;
  796 
  797         __be32 request_id;
  798         __be16 pkey;
  799         __be16 rsvd;
  800         __be64 service_id;
  801 
  802         u32 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE / sizeof(u32)];
  803 } __attribute__ ((packed));
  804 
  805 struct cm_sidr_rep_msg {
  806         struct ib_mad_hdr hdr;
  807 
  808         __be32 request_id;
  809         u8 status;
  810         u8 info_length;
  811         __be16 rsvd;
  812         /* QPN:24, rsvd:8 */
  813         __be32 offset8;
  814         __be64 service_id;
  815         __be32 qkey;
  816         u8 info[IB_CM_SIDR_REP_INFO_LENGTH];
  817 
  818         u8 private_data[IB_CM_SIDR_REP_PRIVATE_DATA_SIZE];
  819 } __attribute__ ((packed));
  820 
  821 static inline __be32 cm_sidr_rep_get_qpn(struct cm_sidr_rep_msg *sidr_rep_msg)
  822 {
  823         return cpu_to_be32(be32_to_cpu(sidr_rep_msg->offset8) >> 8);
  824 }
  825 
  826 static inline void cm_sidr_rep_set_qpn(struct cm_sidr_rep_msg *sidr_rep_msg,
  827                                        __be32 qpn)
  828 {
  829         sidr_rep_msg->offset8 = cpu_to_be32((be32_to_cpu(qpn) << 8) |
  830                                         (be32_to_cpu(sidr_rep_msg->offset8) &
  831                                          0x000000FF));
  832 }
  833 
  834 #endif /* CM_MSGS_H */
Cache object: c214f8edefb243a37f549d626b4e4a2c
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/ofed/drivers/infiniband/core/cm_msgs.h

FreeBSD/Linux Kernel Cross Reference
sys/ofed/drivers/infiniband/core/cm_msgs.h
