home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / mlx4 / qp.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  7.2 KB  |  321 lines
  1. /*
  2.  * Copyright (c) 2007 Cisco Systems, Inc.  All rights reserved.
  3.  *
  4.  * This software is available to you under a choice of one of two
  5.  * licenses.  You may choose to be licensed under the terms of the GNU
  6.  * General Public License (GPL) Version 2, available from the file
  7.  * COPYING in the main directory of this source tree, or the
  8.  * OpenIB.org BSD license below:
  9.  *
  10.  *     Redistribution and use in source and binary forms, with or
  11.  *     without modification, are permitted provided that the following
  12.  *     conditions are met:
  13.  *
  14.  *    - Redistributions of source code must retain the above
  15.  *      copyright notice, this list of conditions and the following
  16.  *      disclaimer.
  17.  *
  18.  *    - Redistributions in binary form must reproduce the above
  19.  *      copyright notice, this list of conditions and the following
  20.  *      disclaimer in the documentation and/or other materials
  21.  *      provided with the distribution.
  22.  *
  23.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30.  * SOFTWARE.
  31.  */
  32.  
  33. #ifndef MLX4_QP_H
  34. #define MLX4_QP_H
  35.  
  36. #include <linux/types.h>
  37.  
  38. #include <linux/mlx4/device.h>
  39.  
  40. #define MLX4_INVALID_LKEY    0x100
  41.  
  42. enum mlx4_qp_optpar {
  43.     MLX4_QP_OPTPAR_ALT_ADDR_PATH        = 1 << 0,
  44.     MLX4_QP_OPTPAR_RRE            = 1 << 1,
  45.     MLX4_QP_OPTPAR_RAE            = 1 << 2,
  46.     MLX4_QP_OPTPAR_RWE            = 1 << 3,
  47.     MLX4_QP_OPTPAR_PKEY_INDEX        = 1 << 4,
  48.     MLX4_QP_OPTPAR_Q_KEY            = 1 << 5,
  49.     MLX4_QP_OPTPAR_RNR_TIMEOUT        = 1 << 6,
  50.     MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH    = 1 << 7,
  51.     MLX4_QP_OPTPAR_SRA_MAX            = 1 << 8,
  52.     MLX4_QP_OPTPAR_RRA_MAX            = 1 << 9,
  53.     MLX4_QP_OPTPAR_PM_STATE            = 1 << 10,
  54.     MLX4_QP_OPTPAR_RETRY_COUNT        = 1 << 12,
  55.     MLX4_QP_OPTPAR_RNR_RETRY        = 1 << 13,
  56.     MLX4_QP_OPTPAR_ACK_TIMEOUT        = 1 << 14,
  57.     MLX4_QP_OPTPAR_SCHED_QUEUE        = 1 << 16
  58. };
  59.  
  60. enum mlx4_qp_state {
  61.     MLX4_QP_STATE_RST            = 0,
  62.     MLX4_QP_STATE_INIT            = 1,
  63.     MLX4_QP_STATE_RTR            = 2,
  64.     MLX4_QP_STATE_RTS            = 3,
  65.     MLX4_QP_STATE_SQER            = 4,
  66.     MLX4_QP_STATE_SQD            = 5,
  67.     MLX4_QP_STATE_ERR            = 6,
  68.     MLX4_QP_STATE_SQ_DRAINING        = 7,
  69.     MLX4_QP_NUM_STATE
  70. };
  71.  
  72. enum {
  73.     MLX4_QP_ST_RC                = 0x0,
  74.     MLX4_QP_ST_UC                = 0x1,
  75.     MLX4_QP_ST_RD                = 0x2,
  76.     MLX4_QP_ST_UD                = 0x3,
  77.     MLX4_QP_ST_MLX                = 0x7
  78. };
  79.  
  80. enum {
  81.     MLX4_QP_PM_MIGRATED            = 0x3,
  82.     MLX4_QP_PM_ARMED            = 0x0,
  83.     MLX4_QP_PM_REARM            = 0x1
  84. };
  85.  
  86. enum {
  87.     /* params1 */
  88.     MLX4_QP_BIT_SRE                = 1 << 15,
  89.     MLX4_QP_BIT_SWE                = 1 << 14,
  90.     MLX4_QP_BIT_SAE                = 1 << 13,
  91.     /* params2 */
  92.     MLX4_QP_BIT_RRE                = 1 << 15,
  93.     MLX4_QP_BIT_RWE                = 1 << 14,
  94.     MLX4_QP_BIT_RAE                = 1 << 13,
  95.     MLX4_QP_BIT_RIC                = 1 <<    4,
  96. };
  97.  
  98. struct mlx4_qp_path {
  99.     u8            fl;
  100.     u8            reserved1[2];
  101.     u8            pkey_index;
  102.     u8            reserved2;
  103.     u8            grh_mylmc;
  104.     __be16            rlid;
  105.     u8            ackto;
  106.     u8            mgid_index;
  107.     u8            static_rate;
  108.     u8            hop_limit;
  109.     __be32            tclass_flowlabel;
  110.     u8            rgid[16];
  111.     u8            sched_queue;
  112.     u8            snooper_flags;
  113.     u8            reserved3[2];
  114.     u8            counter_index;
  115.     u8            reserved4[7];
  116. };
  117.  
  118. struct mlx4_qp_context {
  119.     __be32            flags;
  120.     __be32            pd;
  121.     u8            mtu_msgmax;
  122.     u8            rq_size_stride;
  123.     u8            sq_size_stride;
  124.     u8            rlkey;
  125.     __be32            usr_page;
  126.     __be32            local_qpn;
  127.     __be32            remote_qpn;
  128.     struct            mlx4_qp_path pri_path;
  129.     struct            mlx4_qp_path alt_path;
  130.     __be32            params1;
  131.     u32            reserved1;
  132.     __be32            next_send_psn;
  133.     __be32            cqn_send;
  134.     u32            reserved2[2];
  135.     __be32            last_acked_psn;
  136.     __be32            ssn;
  137.     __be32            params2;
  138.     __be32            rnr_nextrecvpsn;
  139.     __be32            srcd;
  140.     __be32            cqn_recv;
  141.     __be64            db_rec_addr;
  142.     __be32            qkey;
  143.     __be32            srqn;
  144.     __be32            msn;
  145.     __be16            rq_wqe_counter;
  146.     __be16            sq_wqe_counter;
  147.     u32            reserved3[2];
  148.     __be32            param3;
  149.     __be32            nummmcpeers_basemkey;
  150.     u8            log_page_size;
  151.     u8            reserved4[2];
  152.     u8            mtt_base_addr_h;
  153.     __be32            mtt_base_addr_l;
  154.     u32            reserved5[10];
  155. };
  156.  
  157. /* Which firmware version adds support for NEC (NoErrorCompletion) bit */
  158. #define MLX4_FW_VER_WQE_CTRL_NEC mlx4_fw_ver(2, 2, 232)
  159.  
  160. enum {
  161.     MLX4_WQE_CTRL_NEC        = 1 << 29,
  162.     MLX4_WQE_CTRL_FENCE        = 1 << 6,
  163.     MLX4_WQE_CTRL_CQ_UPDATE        = 3 << 2,
  164.     MLX4_WQE_CTRL_SOLICITED        = 1 << 1,
  165.     MLX4_WQE_CTRL_IP_CSUM        = 1 << 4,
  166.     MLX4_WQE_CTRL_TCP_UDP_CSUM    = 1 << 5,
  167.     MLX4_WQE_CTRL_INS_VLAN        = 1 << 6,
  168. };
  169.  
  170. struct mlx4_wqe_ctrl_seg {
  171.     __be32            owner_opcode;
  172.     __be16            vlan_tag;
  173.     u8            ins_vlan;
  174.     u8            fence_size;
  175.     /*
  176.      * High 24 bits are SRC remote buffer; low 8 bits are flags:
  177.      * [7]   SO (strong ordering)
  178.      * [5]   TCP/UDP checksum
  179.      * [4]   IP checksum
  180.      * [3:2] C (generate completion queue entry)
  181.      * [1]   SE (solicited event)
  182.      */
  183.     __be32            srcrb_flags;
  184.     /*
  185.      * imm is immediate data for send/RDMA write w/ immediate;
  186.      * also invalidation key for send with invalidate; input
  187.      * modifier for WQEs on CCQs.
  188.      */
  189.     __be32            imm;
  190. };
  191.  
  192. enum {
  193.     MLX4_WQE_MLX_VL15    = 1 << 17,
  194.     MLX4_WQE_MLX_SLR    = 1 << 16
  195. };
  196.  
  197. struct mlx4_wqe_mlx_seg {
  198.     u8            owner;
  199.     u8            reserved1[2];
  200.     u8            opcode;
  201.     u8            reserved2[3];
  202.     u8            size;
  203.     /*
  204.      * [17]    VL15
  205.      * [16]    SLR
  206.      * [15:12] static rate
  207.      * [11:8]  SL
  208.      * [4]     ICRC
  209.      * [3:2]   C
  210.      * [0]     FL (force loopback)
  211.      */
  212.     __be32            flags;
  213.     __be16            rlid;
  214.     u16            reserved3;
  215. };
  216.  
  217. struct mlx4_wqe_datagram_seg {
  218.     __be32            av[8];
  219.     __be32            dqpn;
  220.     __be32            qkey;
  221.     __be32            reservd[2];
  222. };
  223.  
  224. struct mlx4_wqe_lso_seg {
  225.     __be32            mss_hdr_size;
  226.     __be32            header[0];
  227. };
  228.  
  229. struct mlx4_wqe_bind_seg {
  230.     __be32            flags1;
  231.     __be32            flags2;
  232.     __be32            new_rkey;
  233.     __be32            lkey;
  234.     __be64            addr;
  235.     __be64            length;
  236. };
  237.  
  238. enum {
  239.     MLX4_WQE_FMR_PERM_LOCAL_READ    = 1 << 27,
  240.     MLX4_WQE_FMR_PERM_LOCAL_WRITE    = 1 << 28,
  241.     MLX4_WQE_FMR_PERM_REMOTE_READ    = 1 << 29,
  242.     MLX4_WQE_FMR_PERM_REMOTE_WRITE    = 1 << 30,
  243.     MLX4_WQE_FMR_PERM_ATOMIC    = 1 << 31
  244. };
  245.  
  246. struct mlx4_wqe_fmr_seg {
  247.     __be32            flags;
  248.     __be32            mem_key;
  249.     __be64            buf_list;
  250.     __be64            start_addr;
  251.     __be64            reg_len;
  252.     __be32            offset;
  253.     __be32            page_size;
  254.     u32            reserved[2];
  255. };
  256.  
  257. struct mlx4_wqe_fmr_ext_seg {
  258.     u8            flags;
  259.     u8            reserved;
  260.     __be16            app_mask;
  261.     __be16            wire_app_tag;
  262.     __be16            mem_app_tag;
  263.     __be32            wire_ref_tag_base;
  264.     __be32            mem_ref_tag_base;
  265. };
  266.  
  267. struct mlx4_wqe_local_inval_seg {
  268.     __be32            flags;
  269.     u32            reserved1;
  270.     __be32            mem_key;
  271.     u32            reserved2[2];
  272.     __be32            guest_id;
  273.     __be64            pa;
  274. };
  275.  
  276. struct mlx4_wqe_raddr_seg {
  277.     __be64            raddr;
  278.     __be32            rkey;
  279.     u32            reserved;
  280. };
  281.  
  282. struct mlx4_wqe_atomic_seg {
  283.     __be64            swap_add;
  284.     __be64            compare;
  285. };
  286.  
  287. struct mlx4_wqe_data_seg {
  288.     __be32            byte_count;
  289.     __be32            lkey;
  290.     __be64            addr;
  291. };
  292.  
  293. enum {
  294.     MLX4_INLINE_ALIGN    = 64,
  295. };
  296.  
  297. struct mlx4_wqe_inline_seg {
  298.     __be32            byte_count;
  299. };
  300.  
  301. int mlx4_qp_modify(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
  302.            enum mlx4_qp_state cur_state, enum mlx4_qp_state new_state,
  303.            struct mlx4_qp_context *context, enum mlx4_qp_optpar optpar,
  304.            int sqd_event, struct mlx4_qp *qp);
  305.  
  306. int mlx4_qp_query(struct mlx4_dev *dev, struct mlx4_qp *qp,
  307.           struct mlx4_qp_context *context);
  308.  
  309. int mlx4_qp_to_ready(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
  310.              struct mlx4_qp_context *context,
  311.              struct mlx4_qp *qp, enum mlx4_qp_state *qp_state);
  312.  
  313. static inline struct mlx4_qp *__mlx4_qp_lookup(struct mlx4_dev *dev, u32 qpn)
  314. {
  315.     return radix_tree_lookup(&dev->qp_table_tree, qpn & (dev->caps.num_qps - 1));
  316. }
  317.  
  318. void mlx4_qp_remove(struct mlx4_dev *dev, struct mlx4_qp *qp);
  319.  
  320. #endif /* MLX4_QP_H */
  321.