1 /* 2 * Copyright (c) 2016 Chelsio Communications, 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 __LIBCXGB_CM_H__ 34 #define __LIBCXGB_CM_H__ 35 36 37 #include <net/tcp.h> 38 39 #include <cxgb4.h> 40 #include <t4_msg.h> 41 #include <l2t.h> 42 43 void 44 cxgb_get_4tuple(struct cpl_pass_accept_req *, enum chip_type, 45 int *, __u8 *, __u8 *, __be16 *, __be16 *); 46 struct dst_entry * 47 cxgb_find_route(struct cxgb4_lld_info *, 48 struct net_device *(*)(struct net_device *), 49 __be32, __be32, __be16, __be16, u8); 50 struct dst_entry * 51 cxgb_find_route6(struct cxgb4_lld_info *, 52 struct net_device *(*)(struct net_device *), 53 __u8 *, __u8 *, __be16, __be16, u8, __u32); 54 55 /* Returns whether a CPL status conveys negative advice. 56 */ 57 static inline bool cxgb_is_neg_adv(unsigned int status) 58 { 59 return status == CPL_ERR_RTX_NEG_ADVICE || 60 status == CPL_ERR_PERSIST_NEG_ADVICE || 61 status == CPL_ERR_KEEPALV_NEG_ADVICE; 62 } 63 64 static inline void 65 cxgb_best_mtu(const unsigned short *mtus, unsigned short mtu, 66 unsigned int *idx, int use_ts, int ipv6) 67 { 68 unsigned short hdr_size = (ipv6 ? 69 sizeof(struct ipv6hdr) : 70 sizeof(struct iphdr)) + 71 sizeof(struct tcphdr) + 72 (use_ts ? 73 round_up(TCPOLEN_TIMESTAMP, 4) : 0); 74 unsigned short data_size = mtu - hdr_size; 75 76 cxgb4_best_aligned_mtu(mtus, hdr_size, data_size, 8, idx); 77 } 78 79 static inline u32 cxgb_compute_wscale(u32 win) 80 { 81 u32 wscale = 0; 82 83 while (wscale < 14 && (65535 << wscale) < win) 84 wscale++; 85 return wscale; 86 } 87 88 static inline void 89 cxgb_mk_tid_release(struct sk_buff *skb, u32 len, u32 tid, u16 chan) 90 { 91 struct cpl_tid_release *req; 92 93 req = __skb_put_zero(skb, len); 94 95 INIT_TP_WR(req, tid); 96 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_TID_RELEASE, tid)); 97 set_wr_txq(skb, CPL_PRIORITY_SETUP, chan); 98 } 99 100 static inline void 101 cxgb_mk_close_con_req(struct sk_buff *skb, u32 len, u32 tid, u16 chan, 102 void *handle, arp_err_handler_t handler) 103 { 104 struct cpl_close_con_req *req; 105 106 req = __skb_put_zero(skb, len); 107 108 INIT_TP_WR(req, tid); 109 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_CLOSE_CON_REQ, tid)); 110 set_wr_txq(skb, CPL_PRIORITY_DATA, chan); 111 t4_set_arp_err_handler(skb, handle, handler); 112 } 113 114 static inline void 115 cxgb_mk_abort_req(struct sk_buff *skb, u32 len, u32 tid, u16 chan, 116 void *handle, arp_err_handler_t handler) 117 { 118 struct cpl_abort_req *req; 119 120 req = __skb_put_zero(skb, len); 121 122 INIT_TP_WR(req, tid); 123 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_REQ, tid)); 124 req->cmd = CPL_ABORT_SEND_RST; 125 set_wr_txq(skb, CPL_PRIORITY_DATA, chan); 126 t4_set_arp_err_handler(skb, handle, handler); 127 } 128 129 static inline void 130 cxgb_mk_abort_rpl(struct sk_buff *skb, u32 len, u32 tid, u16 chan) 131 { 132 struct cpl_abort_rpl *rpl; 133 134 rpl = __skb_put_zero(skb, len); 135 136 INIT_TP_WR(rpl, tid); 137 OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_RPL, tid)); 138 rpl->cmd = CPL_ABORT_NO_RST; 139 set_wr_txq(skb, CPL_PRIORITY_DATA, chan); 140 } 141 142 static inline void 143 cxgb_mk_rx_data_ack(struct sk_buff *skb, u32 len, u32 tid, u16 chan, 144 u32 credit_dack) 145 { 146 struct cpl_rx_data_ack *req; 147 148 req = __skb_put_zero(skb, len); 149 150 INIT_TP_WR(req, tid); 151 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_RX_DATA_ACK, tid)); 152 req->credit_dack = cpu_to_be32(credit_dack); 153 set_wr_txq(skb, CPL_PRIORITY_ACK, chan); 154 } 155 #endif 156