ib_mad.h 22 KB

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