home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / rdma / ib_mad.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  21.9 KB  |  647 lines
  1. /*
  2.  * Copyright (c) 2004 Mellanox Technologies Ltd.  All rights reserved.
  3.  * Copyright (c) 2004 Infinicon Corporation.  All rights reserved.
  4.  * Copyright (c) 2004 Intel Corporation.  All rights reserved.
  5.  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
  6.  * Copyright (c) 2004-2006 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 in the main directory of this source tree, or the
  12.  * OpenIB.org BSD license below:
  13.  *
  14.  *     Redistribution and use in source and binary forms, with or
  15.  *     without modification, are permitted provided that the following
  16.  *     conditions are met:
  17.  *
  18.  *      - Redistributions of source code must retain the above
  19.  *        copyright notice, this list of conditions and the following
  20.  *        disclaimer.
  21.  *
  22.  *      - Redistributions in binary form must reproduce the above
  23.  *        copyright notice, this list of conditions and the following
  24.  *        disclaimer in the documentation and/or other materials
  25.  *        provided with the distribution.
  26.  *
  27.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY 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. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  31.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  32.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  33.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  34.  * SOFTWARE.
  35.  *
  36.  * $Id: ib_mad.h 5596 2006-03-03 01:00:07Z sean.hefty $
  37.  */
  38.  
  39. #if !defined( IB_MAD_H )
  40. #define IB_MAD_H
  41.  
  42. #include <linux/pci.h>
  43.  
  44. #include <rdma/ib_verbs.h>
  45.  
  46. /* Management base version */
  47. #define IB_MGMT_BASE_VERSION            1
  48.  
  49. /* Management classes */
  50. #define IB_MGMT_CLASS_SUBN_LID_ROUTED        0x01
  51. #define IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE    0x81
  52. #define IB_MGMT_CLASS_SUBN_ADM            0x03
  53. #define IB_MGMT_CLASS_PERF_MGMT            0x04
  54. #define IB_MGMT_CLASS_BM            0x05
  55. #define IB_MGMT_CLASS_DEVICE_MGMT        0x06
  56. #define IB_MGMT_CLASS_CM            0x07
  57. #define IB_MGMT_CLASS_SNMP            0x08
  58. #define IB_MGMT_CLASS_DEVICE_ADM        0x10
  59. #define IB_MGMT_CLASS_BOOT_MGMT            0x11
  60. #define IB_MGMT_CLASS_BIS            0x12
  61. #define IB_MGMT_CLASS_CONG_MGMT            0x21
  62. #define IB_MGMT_CLASS_VENDOR_RANGE2_START    0x30
  63. #define IB_MGMT_CLASS_VENDOR_RANGE2_END        0x4F
  64.  
  65. #define    IB_OPENIB_OUI                (0x001405)
  66.  
  67. /* Management methods */
  68. #define IB_MGMT_METHOD_GET            0x01
  69. #define IB_MGMT_METHOD_SET            0x02
  70. #define IB_MGMT_METHOD_GET_RESP            0x81
  71. #define IB_MGMT_METHOD_SEND            0x03
  72. #define IB_MGMT_METHOD_TRAP            0x05
  73. #define IB_MGMT_METHOD_REPORT            0x06
  74. #define IB_MGMT_METHOD_REPORT_RESP        0x86
  75. #define IB_MGMT_METHOD_TRAP_REPRESS        0x07
  76.  
  77. #define IB_MGMT_METHOD_RESP            0x80
  78.  
  79. #define IB_MGMT_MAX_METHODS            128
  80.  
  81. /* RMPP information */
  82. #define IB_MGMT_RMPP_VERSION            1
  83.  
  84. #define IB_MGMT_RMPP_TYPE_DATA            1
  85. #define IB_MGMT_RMPP_TYPE_ACK            2
  86. #define IB_MGMT_RMPP_TYPE_STOP            3
  87. #define IB_MGMT_RMPP_TYPE_ABORT            4
  88.  
  89. #define IB_MGMT_RMPP_FLAG_ACTIVE        1
  90. #define IB_MGMT_RMPP_FLAG_FIRST            (1<<1)
  91. #define IB_MGMT_RMPP_FLAG_LAST            (1<<2)
  92.  
  93. #define IB_MGMT_RMPP_NO_RESPTIME        0x1F
  94.  
  95. #define    IB_MGMT_RMPP_STATUS_SUCCESS        0
  96. #define    IB_MGMT_RMPP_STATUS_RESX        1
  97. #define    IB_MGMT_RMPP_STATUS_ABORT_MIN        118
  98. #define    IB_MGMT_RMPP_STATUS_T2L            118
  99. #define    IB_MGMT_RMPP_STATUS_BAD_LEN        119
  100. #define    IB_MGMT_RMPP_STATUS_BAD_SEG        120
  101. #define    IB_MGMT_RMPP_STATUS_BADT        121
  102. #define    IB_MGMT_RMPP_STATUS_W2S            122
  103. #define    IB_MGMT_RMPP_STATUS_S2B            123
  104. #define    IB_MGMT_RMPP_STATUS_BAD_STATUS        124
  105. #define    IB_MGMT_RMPP_STATUS_UNV            125
  106. #define    IB_MGMT_RMPP_STATUS_TMR            126
  107. #define    IB_MGMT_RMPP_STATUS_UNSPEC        127
  108. #define    IB_MGMT_RMPP_STATUS_ABORT_MAX        127
  109.  
  110. #define IB_QP0        0
  111. #define IB_QP1        __constant_htonl(1)
  112. #define IB_QP1_QKEY    0x80010000
  113. #define IB_QP_SET_QKEY    0x80000000
  114.  
  115. enum {
  116.     IB_MGMT_MAD_HDR = 24,
  117.     IB_MGMT_MAD_DATA = 232,
  118.     IB_MGMT_RMPP_HDR = 36,
  119.     IB_MGMT_RMPP_DATA = 220,
  120.     IB_MGMT_VENDOR_HDR = 40,
  121.     IB_MGMT_VENDOR_DATA = 216,
  122.     IB_MGMT_SA_HDR = 56,
  123.     IB_MGMT_SA_DATA = 200,
  124.     IB_MGMT_DEVICE_HDR = 64,
  125.     IB_MGMT_DEVICE_DATA = 192,
  126. };
  127.  
  128. struct ib_mad_hdr {
  129.     u8    base_version;
  130.     u8    mgmt_class;
  131.     u8    class_version;
  132.     u8    method;
  133.     __be16    status;
  134.     __be16    class_specific;
  135.     __be64    tid;
  136.     __be16    attr_id;
  137.     __be16    resv;
  138.     __be32    attr_mod;
  139. };
  140.  
  141. struct ib_rmpp_hdr {
  142.     u8    rmpp_version;
  143.     u8    rmpp_type;
  144.     u8    rmpp_rtime_flags;
  145.     u8    rmpp_status;
  146.     __be32    seg_num;
  147.     __be32    paylen_newwin;
  148. };
  149.  
  150. typedef u64 __bitwise ib_sa_comp_mask;
  151.  
  152. #define IB_SA_COMP_MASK(n) ((__force ib_sa_comp_mask) cpu_to_be64(1ull << n))
  153.  
  154. /*
  155.  * ib_sa_hdr and ib_sa_mad structures must be packed because they have
  156.  * 64-bit fields that are only 32-bit aligned. 64-bit architectures will
  157.  * lay them out wrong otherwise.  (And unfortunately they are sent on
  158.  * the wire so we can't change the layout)
  159.  */
  160. struct ib_sa_hdr {
  161.     __be64            sm_key;
  162.     __be16            attr_offset;
  163.     __be16            reserved;
  164.     ib_sa_comp_mask        comp_mask;
  165. } __attribute__ ((packed));
  166.  
  167. struct ib_mad {
  168.     struct ib_mad_hdr    mad_hdr;
  169.     u8            data[IB_MGMT_MAD_DATA];
  170. };
  171.  
  172. struct ib_rmpp_mad {
  173.     struct ib_mad_hdr    mad_hdr;
  174.     struct ib_rmpp_hdr    rmpp_hdr;
  175.     u8            data[IB_MGMT_RMPP_DATA];
  176. };
  177.  
  178. struct ib_sa_mad {
  179.     struct ib_mad_hdr    mad_hdr;
  180.     struct ib_rmpp_hdr    rmpp_hdr;
  181.     struct ib_sa_hdr    sa_hdr;
  182.     u8            data[IB_MGMT_SA_DATA];
  183. } __attribute__ ((packed));
  184.  
  185. struct ib_vendor_mad {
  186.     struct ib_mad_hdr    mad_hdr;
  187.     struct ib_rmpp_hdr    rmpp_hdr;
  188.     u8            reserved;
  189.     u8            oui[3];
  190.     u8            data[IB_MGMT_VENDOR_DATA];
  191. };
  192.  
  193. struct ib_class_port_info
  194. {
  195.     u8            base_version;
  196.     u8            class_version;
  197.     __be16            capability_mask;
  198.     u8            reserved[3];
  199.     u8            resp_time_value;
  200.     u8            redirect_gid[16];
  201.     __be32            redirect_tcslfl;
  202.     __be16            redirect_lid;
  203.     __be16            redirect_pkey;
  204.     __be32            redirect_qp;
  205.     __be32            redirect_qkey;
  206.     u8            trap_gid[16];
  207.     __be32            trap_tcslfl;
  208.     __be16            trap_lid;
  209.     __be16            trap_pkey;
  210.     __be32            trap_hlqp;
  211.     __be32            trap_qkey;
  212. };
  213.  
  214. /**
  215.  * ib_mad_send_buf - MAD data buffer and work request for sends.
  216.  * @next: A pointer used to chain together MADs for posting.
  217.  * @mad: References an allocated MAD data buffer for MADs that do not have
  218.  *   RMPP active.  For MADs using RMPP, references the common and management
  219.  *   class specific headers.
  220.  * @mad_agent: MAD agent that allocated the buffer.
  221.  * @ah: The address handle to use when sending the MAD.
  222.  * @context: User-controlled context fields.
  223.  * @hdr_len: Indicates the size of the data header of the MAD.  This length
  224.  *   includes the common MAD, RMPP, and class specific headers.
  225.  * @data_len: Indicates the total size of user-transferred data.
  226.  * @seg_count: The number of RMPP segments allocated for this send.
  227.  * @seg_size: Size of each RMPP segment.
  228.  * @timeout_ms: Time to wait for a response.
  229.  * @retries: Number of times to retry a request for a response.
  230.  *
  231.  * Users are responsible for initializing the MAD buffer itself, with the
  232.  * exception of any RMPP header.  Additional segment buffer space allocated
  233.  * beyond data_len is padding.
  234.  */
  235. struct ib_mad_send_buf {
  236.     struct ib_mad_send_buf    *next;
  237.     void            *mad;
  238.     struct ib_mad_agent    *mad_agent;
  239.     struct ib_ah        *ah;
  240.     void            *context[2];
  241.     int            hdr_len;
  242.     int            data_len;
  243.     int            seg_count;
  244.     int            seg_size;
  245.     int            timeout_ms;
  246.     int            retries;
  247. };
  248.  
  249. /**
  250.  * ib_get_rmpp_resptime - Returns the RMPP response time.
  251.  * @rmpp_hdr: An RMPP header.
  252.  */
  253. static inline u8 ib_get_rmpp_resptime(struct ib_rmpp_hdr *rmpp_hdr)
  254. {
  255.     return rmpp_hdr->rmpp_rtime_flags >> 3;
  256. }
  257.  
  258. /**
  259.  * ib_get_rmpp_flags - Returns the RMPP flags.
  260.  * @rmpp_hdr: An RMPP header.
  261.  */
  262. static inline u8 ib_get_rmpp_flags(struct ib_rmpp_hdr *rmpp_hdr)
  263. {
  264.     return rmpp_hdr->rmpp_rtime_flags & 0x7;
  265. }
  266.  
  267. /**
  268.  * ib_set_rmpp_resptime - Sets the response time in an RMPP header.
  269.  * @rmpp_hdr: An RMPP header.
  270.  * @rtime: The response time to set.
  271.  */
  272. static inline void ib_set_rmpp_resptime(struct ib_rmpp_hdr *rmpp_hdr, u8 rtime)
  273. {
  274.     rmpp_hdr->rmpp_rtime_flags = ib_get_rmpp_flags(rmpp_hdr) | (rtime << 3);
  275. }
  276.  
  277. /**
  278.  * ib_set_rmpp_flags - Sets the flags in an RMPP header.
  279.  * @rmpp_hdr: An RMPP header.
  280.  * @flags: The flags to set.
  281.  */
  282. static inline void ib_set_rmpp_flags(struct ib_rmpp_hdr *rmpp_hdr, u8 flags)
  283. {
  284.     rmpp_hdr->rmpp_rtime_flags = (rmpp_hdr->rmpp_rtime_flags & 0xF1) |
  285.                      (flags & 0x7);
  286. }
  287.  
  288. struct ib_mad_agent;
  289. struct ib_mad_send_wc;
  290. struct ib_mad_recv_wc;
  291.  
  292. /**
  293.  * ib_mad_send_handler - callback handler for a sent MAD.
  294.  * @mad_agent: MAD agent that sent the MAD.
  295.  * @mad_send_wc: Send work completion information on the sent MAD.
  296.  */
  297. typedef void (*ib_mad_send_handler)(struct ib_mad_agent *mad_agent,
  298.                     struct ib_mad_send_wc *mad_send_wc);
  299.  
  300. /**
  301.  * ib_mad_snoop_handler - Callback handler for snooping sent MADs.
  302.  * @mad_agent: MAD agent that snooped the MAD.
  303.  * @send_wr: Work request information on the sent MAD.
  304.  * @mad_send_wc: Work completion information on the sent MAD.  Valid
  305.  *   only for snooping that occurs on a send completion.
  306.  *
  307.  * Clients snooping MADs should not modify data referenced by the @send_wr
  308.  * or @mad_send_wc.
  309.  */
  310. typedef void (*ib_mad_snoop_handler)(struct ib_mad_agent *mad_agent,
  311.                      struct ib_mad_send_buf *send_buf,
  312.                      struct ib_mad_send_wc *mad_send_wc);
  313.  
  314. /**
  315.  * ib_mad_recv_handler - callback handler for a received MAD.
  316.  * @mad_agent: MAD agent requesting the received MAD.
  317.  * @mad_recv_wc: Received work completion information on the received MAD.
  318.  *
  319.  * MADs received in response to a send request operation will be handed to
  320.  * the user before the send operation completes.  All data buffers given
  321.  * to registered agents through this routine are owned by the receiving
  322.  * client, except for snooping agents.  Clients snooping MADs should not
  323.  * modify the data referenced by @mad_recv_wc.
  324.  */
  325. typedef void (*ib_mad_recv_handler)(struct ib_mad_agent *mad_agent,
  326.                     struct ib_mad_recv_wc *mad_recv_wc);
  327.  
  328. /**
  329.  * ib_mad_agent - Used to track MAD registration with the access layer.
  330.  * @device: Reference to device registration is on.
  331.  * @qp: Reference to QP used for sending and receiving MADs.
  332.  * @mr: Memory region for system memory usable for DMA.
  333.  * @recv_handler: Callback handler for a received MAD.
  334.  * @send_handler: Callback handler for a sent MAD.
  335.  * @snoop_handler: Callback handler for snooped sent MADs.
  336.  * @context: User-specified context associated with this registration.
  337.  * @hi_tid: Access layer assigned transaction ID for this client.
  338.  *   Unsolicited MADs sent by this client will have the upper 32-bits
  339.  *   of their TID set to this value.
  340.  * @port_num: Port number on which QP is registered
  341.  * @rmpp_version: If set, indicates the RMPP version used by this agent.
  342.  */
  343. struct ib_mad_agent {
  344.     struct ib_device    *device;
  345.     struct ib_qp        *qp;
  346.     struct ib_mr        *mr;
  347.     ib_mad_recv_handler    recv_handler;
  348.     ib_mad_send_handler    send_handler;
  349.     ib_mad_snoop_handler    snoop_handler;
  350.     void            *context;
  351.     u32            hi_tid;
  352.     u8            port_num;
  353.     u8            rmpp_version;
  354. };
  355.  
  356. /**
  357.  * ib_mad_send_wc - MAD send completion information.
  358.  * @send_buf: Send MAD data buffer associated with the send MAD request.
  359.  * @status: Completion status.
  360.  * @vendor_err: Optional vendor error information returned with a failed
  361.  *   request.
  362.  */
  363. struct ib_mad_send_wc {
  364.     struct ib_mad_send_buf    *send_buf;
  365.     enum ib_wc_status    status;
  366.     u32            vendor_err;
  367. };
  368.  
  369. /**
  370.  * ib_mad_recv_buf - received MAD buffer information.
  371.  * @list: Reference to next data buffer for a received RMPP MAD.
  372.  * @grh: References a data buffer containing the global route header.
  373.  *   The data refereced by this buffer is only valid if the GRH is
  374.  *   valid.
  375.  * @mad: References the start of the received MAD.
  376.  */
  377. struct ib_mad_recv_buf {
  378.     struct list_head    list;
  379.     struct ib_grh        *grh;
  380.     struct ib_mad        *mad;
  381. };
  382.  
  383. /**
  384.  * ib_mad_recv_wc - received MAD information.
  385.  * @wc: Completion information for the received data.
  386.  * @recv_buf: Specifies the location of the received data buffer(s).
  387.  * @rmpp_list: Specifies a list of RMPP reassembled received MAD buffers.
  388.  * @mad_len: The length of the received MAD, without duplicated headers.
  389.  *
  390.  * For received response, the wr_id contains a pointer to the ib_mad_send_buf
  391.  *   for the corresponding send request.
  392.  */
  393. struct ib_mad_recv_wc {
  394.     struct ib_wc        *wc;
  395.     struct ib_mad_recv_buf    recv_buf;
  396.     struct list_head    rmpp_list;
  397.     int            mad_len;
  398. };
  399.  
  400. /**
  401.  * ib_mad_reg_req - MAD registration request
  402.  * @mgmt_class: Indicates which management class of MADs should be receive
  403.  *   by the caller.  This field is only required if the user wishes to
  404.  *   receive unsolicited MADs, otherwise it should be 0.
  405.  * @mgmt_class_version: Indicates which version of MADs for the given
  406.  *   management class to receive.
  407.  * @oui: Indicates IEEE OUI when mgmt_class is a vendor class
  408.  *   in the range from 0x30 to 0x4f. Otherwise not used.
  409.  * @method_mask: The caller will receive unsolicited MADs for any method
  410.  *   where @method_mask = 1.
  411.  */
  412. struct ib_mad_reg_req {
  413.     u8    mgmt_class;
  414.     u8    mgmt_class_version;
  415.     u8    oui[3];
  416.     DECLARE_BITMAP(method_mask, IB_MGMT_MAX_METHODS);
  417. };
  418.  
  419. /**
  420.  * ib_register_mad_agent - Register to send/receive MADs.
  421.  * @device: The device to register with.
  422.  * @port_num: The port on the specified device to use.
  423.  * @qp_type: Specifies which QP to access.  Must be either
  424.  *   IB_QPT_SMI or IB_QPT_GSI.
  425.  * @mad_reg_req: Specifies which unsolicited MADs should be received
  426.  *   by the caller.  This parameter may be NULL if the caller only
  427.  *   wishes to receive solicited responses.
  428.  * @rmpp_version: If set, indicates that the client will send
  429.  *   and receive MADs that contain the RMPP header for the given version.
  430.  *   If set to 0, indicates that RMPP is not used by this client.
  431.  * @send_handler: The completion callback routine invoked after a send
  432.  *   request has completed.
  433.  * @recv_handler: The completion callback routine invoked for a received
  434.  *   MAD.
  435.  * @context: User specified context associated with the registration.
  436.  */
  437. struct ib_mad_agent *ib_register_mad_agent(struct ib_device *device,
  438.                        u8 port_num,
  439.                        enum ib_qp_type qp_type,
  440.                        struct ib_mad_reg_req *mad_reg_req,
  441.                        u8 rmpp_version,
  442.                        ib_mad_send_handler send_handler,
  443.                        ib_mad_recv_handler recv_handler,
  444.                        void *context);
  445.  
  446. enum ib_mad_snoop_flags {
  447.     /*IB_MAD_SNOOP_POSTED_SENDS       = 1,*/
  448.     /*IB_MAD_SNOOP_RMPP_SENDS       = (1<<1),*/
  449.     IB_MAD_SNOOP_SEND_COMPLETIONS       = (1<<2),
  450.     /*IB_MAD_SNOOP_RMPP_SEND_COMPLETIONS = (1<<3),*/
  451.     IB_MAD_SNOOP_RECVS           = (1<<4)
  452.     /*IB_MAD_SNOOP_RMPP_RECVS       = (1<<5),*/
  453.     /*IB_MAD_SNOOP_REDIRECTED_QPS       = (1<<6)*/
  454. };
  455.  
  456. /**
  457.  * ib_register_mad_snoop - Register to snoop sent and received MADs.
  458.  * @device: The device to register with.
  459.  * @port_num: The port on the specified device to use.
  460.  * @qp_type: Specifies which QP traffic to snoop.  Must be either
  461.  *   IB_QPT_SMI or IB_QPT_GSI.
  462.  * @mad_snoop_flags: Specifies information where snooping occurs.
  463.  * @send_handler: The callback routine invoked for a snooped send.
  464.  * @recv_handler: The callback routine invoked for a snooped receive.
  465.  * @context: User specified context associated with the registration.
  466.  */
  467. struct ib_mad_agent *ib_register_mad_snoop(struct ib_device *device,
  468.                        u8 port_num,
  469.                        enum ib_qp_type qp_type,
  470.                        int mad_snoop_flags,
  471.                        ib_mad_snoop_handler snoop_handler,
  472.                        ib_mad_recv_handler recv_handler,
  473.                        void *context);
  474.  
  475. /**
  476.  * ib_unregister_mad_agent - Unregisters a client from using MAD services.
  477.  * @mad_agent: Corresponding MAD registration request to deregister.
  478.  *
  479.  * After invoking this routine, MAD services are no longer usable by the
  480.  * client on the associated QP.
  481.  */
  482. int ib_unregister_mad_agent(struct ib_mad_agent *mad_agent);
  483.  
  484. /**
  485.  * ib_post_send_mad - Posts MAD(s) to the send queue of the QP associated
  486.  *   with the registered client.
  487.  * @send_buf: Specifies the information needed to send the MAD(s).
  488.  * @bad_send_buf: Specifies the MAD on which an error was encountered.  This
  489.  *   parameter is optional if only a single MAD is posted.
  490.  *
  491.  * Sent MADs are not guaranteed to complete in the order that they were posted.
  492.  *
  493.  * If the MAD requires RMPP, the data buffer should contain a single copy
  494.  * of the common MAD, RMPP, and class specific headers, followed by the class
  495.  * defined data.  If the class defined data would not divide evenly into
  496.  * RMPP segments, then space must be allocated at the end of the referenced
  497.  * buffer for any required padding.  To indicate the amount of class defined
  498.  * data being transferred, the paylen_newwin field in the RMPP header should
  499.  * be set to the size of the class specific header plus the amount of class
  500.  * defined data being transferred.  The paylen_newwin field should be
  501.  * specified in network-byte order.
  502.  */
  503. int ib_post_send_mad(struct ib_mad_send_buf *send_buf,
  504.              struct ib_mad_send_buf **bad_send_buf);
  505.  
  506.  
  507. /**
  508.  * ib_free_recv_mad - Returns data buffers used to receive a MAD.
  509.  * @mad_recv_wc: Work completion information for a received MAD.
  510.  *
  511.  * Clients receiving MADs through their ib_mad_recv_handler must call this
  512.  * routine to return the work completion buffers to the access layer.
  513.  */
  514. void ib_free_recv_mad(struct ib_mad_recv_wc *mad_recv_wc);
  515.  
  516. /**
  517.  * ib_cancel_mad - Cancels an outstanding send MAD operation.
  518.  * @mad_agent: Specifies the registration associated with sent MAD.
  519.  * @send_buf: Indicates the MAD to cancel.
  520.  *
  521.  * MADs will be returned to the user through the corresponding
  522.  * ib_mad_send_handler.
  523.  */
  524. void ib_cancel_mad(struct ib_mad_agent *mad_agent,
  525.            struct ib_mad_send_buf *send_buf);
  526.  
  527. /**
  528.  * ib_modify_mad - Modifies an outstanding send MAD operation.
  529.  * @mad_agent: Specifies the registration associated with sent MAD.
  530.  * @send_buf: Indicates the MAD to modify.
  531.  * @timeout_ms: New timeout value for sent MAD.
  532.  *
  533.  * This call will reset the timeout value for a sent MAD to the specified
  534.  * value.
  535.  */
  536. int ib_modify_mad(struct ib_mad_agent *mad_agent,
  537.           struct ib_mad_send_buf *send_buf, u32 timeout_ms);
  538.  
  539. /**
  540.  * ib_redirect_mad_qp - Registers a QP for MAD services.
  541.  * @qp: Reference to a QP that requires MAD services.
  542.  * @rmpp_version: If set, indicates that the client will send
  543.  *   and receive MADs that contain the RMPP header for the given version.
  544.  *   If set to 0, indicates that RMPP is not used by this client.
  545.  * @send_handler: The completion callback routine invoked after a send
  546.  *   request has completed.
  547.  * @recv_handler: The completion callback routine invoked for a received
  548.  *   MAD.
  549.  * @context: User specified context associated with the registration.
  550.  *
  551.  * Use of this call allows clients to use MAD services, such as RMPP,
  552.  * on user-owned QPs.  After calling this routine, users may send
  553.  * MADs on the specified QP by calling ib_mad_post_send.
  554.  */
  555. struct ib_mad_agent *ib_redirect_mad_qp(struct ib_qp *qp,
  556.                     u8 rmpp_version,
  557.                     ib_mad_send_handler send_handler,
  558.                     ib_mad_recv_handler recv_handler,
  559.                     void *context);
  560.  
  561. /**
  562.  * ib_process_mad_wc - Processes a work completion associated with a
  563.  *   MAD sent or received on a redirected QP.
  564.  * @mad_agent: Specifies the registered MAD service using the redirected QP.
  565.  * @wc: References a work completion associated with a sent or received
  566.  *   MAD segment.
  567.  *
  568.  * This routine is used to complete or continue processing on a MAD request.
  569.  * If the work completion is associated with a send operation, calling
  570.  * this routine is required to continue an RMPP transfer or to wait for a
  571.  * corresponding response, if it is a request.  If the work completion is
  572.  * associated with a receive operation, calling this routine is required to
  573.  * process an inbound or outbound RMPP transfer, or to match a response MAD
  574.  * with its corresponding request.
  575.  */
  576. int ib_process_mad_wc(struct ib_mad_agent *mad_agent,
  577.               struct ib_wc *wc);
  578.  
  579. /**
  580.  * ib_create_send_mad - Allocate and initialize a data buffer and work request
  581.  *   for sending a MAD.
  582.  * @mad_agent: Specifies the registered MAD service to associate with the MAD.
  583.  * @remote_qpn: Specifies the QPN of the receiving node.
  584.  * @pkey_index: Specifies which PKey the MAD will be sent using.  This field
  585.  *   is valid only if the remote_qpn is QP 1.
  586.  * @rmpp_active: Indicates if the send will enable RMPP.
  587.  * @hdr_len: Indicates the size of the data header of the MAD.  This length
  588.  *   should include the common MAD header, RMPP header, plus any class
  589.  *   specific header.
  590.  * @data_len: Indicates the size of any user-transferred data.  The call will
  591.  *   automatically adjust the allocated buffer size to account for any
  592.  *   additional padding that may be necessary.
  593.  * @gfp_mask: GFP mask used for the memory allocation.
  594.  *
  595.  * This routine allocates a MAD for sending.  The returned MAD send buffer
  596.  * will reference a data buffer usable for sending a MAD, along
  597.  * with an initialized work request structure.  Users may modify the returned
  598.  * MAD data buffer before posting the send.
  599.  *
  600.  * The returned MAD header, class specific headers, and any padding will be
  601.  * cleared.  Users are responsible for initializing the common MAD header,
  602.  * any class specific header, and MAD data area.
  603.  * If @rmpp_active is set, the RMPP header will be initialized for sending.
  604.  */
  605. struct ib_mad_send_buf * ib_create_send_mad(struct ib_mad_agent *mad_agent,
  606.                         u32 remote_qpn, u16 pkey_index,
  607.                         int rmpp_active,
  608.                         int hdr_len, int data_len,
  609.                         gfp_t gfp_mask);
  610.  
  611. /**
  612.  * ib_is_mad_class_rmpp - returns whether given management class
  613.  * supports RMPP.
  614.  * @mgmt_class: management class
  615.  *
  616.  * This routine returns whether the management class supports RMPP.
  617.  */
  618. int ib_is_mad_class_rmpp(u8 mgmt_class);
  619.  
  620. /**
  621.  * ib_get_mad_data_offset - returns the data offset for a given
  622.  * management class.
  623.  * @mgmt_class: management class
  624.  *
  625.  * This routine returns the data offset in the MAD for the management
  626.  * class requested.
  627.  */
  628. int ib_get_mad_data_offset(u8 mgmt_class);
  629.  
  630. /**
  631.  * ib_get_rmpp_segment - returns the data buffer for a given RMPP segment.
  632.  * @send_buf: Previously allocated send data buffer.
  633.  * @seg_num: number of segment to return
  634.  *
  635.  * This routine returns a pointer to the data buffer of an RMPP MAD.
  636.  * Users must provide synchronization to @send_buf around this call.
  637.  */
  638. void *ib_get_rmpp_segment(struct ib_mad_send_buf *send_buf, int seg_num);
  639.  
  640. /**
  641.  * ib_free_send_mad - Returns data buffers used to send a MAD.
  642.  * @send_buf: Previously allocated send data buffer.
  643.  */
  644. void ib_free_send_mad(struct ib_mad_send_buf *send_buf);
  645.  
  646. #endif /* IB_MAD_H */
  647.