tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Copyright (c) 2016 Chelsio Communications, Inc.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 */
8
9#ifndef __CXGBIT_H__
10#define __CXGBIT_H__
11
12#include <linux/mutex.h>
13#include <linux/list.h>
14#include <linux/spinlock.h>
15#include <linux/idr.h>
16#include <linux/completion.h>
17#include <linux/netdevice.h>
18#include <linux/sched.h>
19#include <linux/pci.h>
20#include <linux/dma-mapping.h>
21#include <linux/inet.h>
22#include <linux/wait.h>
23#include <linux/kref.h>
24#include <linux/timer.h>
25#include <linux/io.h>
26
27#include <asm/byteorder.h>
28
29#include <net/net_namespace.h>
30
31#include <target/iscsi/iscsi_transport.h>
32#include <iscsi_target_parameters.h>
33#include <iscsi_target_login.h>
34
35#include "t4_regs.h"
36#include "t4_msg.h"
37#include "cxgb4.h"
38#include "cxgb4_uld.h"
39#include "l2t.h"
40#include "libcxgb_ppm.h"
41#include "cxgbit_lro.h"
42
43extern struct mutex cdev_list_lock;
44extern struct list_head cdev_list_head;
45struct cxgbit_np;
46
47struct cxgbit_sock;
48
49struct cxgbit_cmd {
50 struct scatterlist sg;
51 struct cxgbi_task_tag_info ttinfo;
52 bool setup_ddp;
53 bool release;
54};
55
56#define CXGBIT_MAX_ISO_PAYLOAD \
57 min_t(u32, MAX_SKB_FRAGS * PAGE_SIZE, 65535)
58
59struct cxgbit_iso_info {
60 u8 flags;
61 u32 mpdu;
62 u32 len;
63 u32 burst_len;
64};
65
66enum cxgbit_skcb_flags {
67 SKCBF_TX_NEED_HDR = (1 << 0), /* packet needs a header */
68 SKCBF_TX_FLAG_COMPL = (1 << 1), /* wr completion flag */
69 SKCBF_TX_ISO = (1 << 2), /* iso cpl in tx skb */
70 SKCBF_RX_LRO = (1 << 3), /* lro skb */
71};
72
73struct cxgbit_skb_rx_cb {
74 u8 opcode;
75 void *pdu_cb;
76 void (*backlog_fn)(struct cxgbit_sock *, struct sk_buff *);
77};
78
79struct cxgbit_skb_tx_cb {
80 u8 submode;
81 u32 extra_len;
82};
83
84union cxgbit_skb_cb {
85 struct {
86 u8 flags;
87 union {
88 struct cxgbit_skb_tx_cb tx;
89 struct cxgbit_skb_rx_cb rx;
90 };
91 };
92
93 struct {
94 /* This member must be first. */
95 struct l2t_skb_cb l2t;
96 struct sk_buff *wr_next;
97 };
98};
99
100#define CXGBIT_SKB_CB(skb) ((union cxgbit_skb_cb *)&((skb)->cb[0]))
101#define cxgbit_skcb_flags(skb) (CXGBIT_SKB_CB(skb)->flags)
102#define cxgbit_skcb_submode(skb) (CXGBIT_SKB_CB(skb)->tx.submode)
103#define cxgbit_skcb_tx_wr_next(skb) (CXGBIT_SKB_CB(skb)->wr_next)
104#define cxgbit_skcb_tx_extralen(skb) (CXGBIT_SKB_CB(skb)->tx.extra_len)
105#define cxgbit_skcb_rx_opcode(skb) (CXGBIT_SKB_CB(skb)->rx.opcode)
106#define cxgbit_skcb_rx_backlog_fn(skb) (CXGBIT_SKB_CB(skb)->rx.backlog_fn)
107#define cxgbit_rx_pdu_cb(skb) (CXGBIT_SKB_CB(skb)->rx.pdu_cb)
108
109static inline void *cplhdr(struct sk_buff *skb)
110{
111 return skb->data;
112}
113
114enum cxgbit_cdev_flags {
115 CDEV_STATE_UP = 0,
116 CDEV_ISO_ENABLE,
117 CDEV_DDP_ENABLE,
118};
119
120#define NP_INFO_HASH_SIZE 32
121
122struct np_info {
123 struct np_info *next;
124 struct cxgbit_np *cnp;
125 unsigned int stid;
126};
127
128struct cxgbit_list_head {
129 struct list_head list;
130 /* device lock */
131 spinlock_t lock;
132};
133
134struct cxgbit_device {
135 struct list_head list;
136 struct cxgb4_lld_info lldi;
137 struct np_info *np_hash_tab[NP_INFO_HASH_SIZE];
138 /* np lock */
139 spinlock_t np_lock;
140 u8 selectq[MAX_NPORTS][2];
141 struct cxgbit_list_head cskq;
142 u32 mdsl;
143 struct kref kref;
144 unsigned long flags;
145};
146
147struct cxgbit_wr_wait {
148 struct completion completion;
149 int ret;
150};
151
152enum cxgbit_csk_state {
153 CSK_STATE_IDLE = 0,
154 CSK_STATE_LISTEN,
155 CSK_STATE_CONNECTING,
156 CSK_STATE_ESTABLISHED,
157 CSK_STATE_ABORTING,
158 CSK_STATE_CLOSING,
159 CSK_STATE_MORIBUND,
160 CSK_STATE_DEAD,
161};
162
163enum cxgbit_csk_flags {
164 CSK_TX_DATA_SENT = 0,
165 CSK_LOGIN_PDU_DONE,
166 CSK_LOGIN_DONE,
167 CSK_DDP_ENABLE,
168};
169
170struct cxgbit_sock_common {
171 struct cxgbit_device *cdev;
172 struct sockaddr_storage local_addr;
173 struct sockaddr_storage remote_addr;
174 struct cxgbit_wr_wait wr_wait;
175 enum cxgbit_csk_state state;
176 unsigned long flags;
177};
178
179struct cxgbit_np {
180 struct cxgbit_sock_common com;
181 wait_queue_head_t accept_wait;
182 struct iscsi_np *np;
183 struct completion accept_comp;
184 struct list_head np_accept_list;
185 /* np accept lock */
186 spinlock_t np_accept_lock;
187 struct kref kref;
188 unsigned int stid;
189};
190
191struct cxgbit_sock {
192 struct cxgbit_sock_common com;
193 struct cxgbit_np *cnp;
194 struct iscsi_conn *conn;
195 struct l2t_entry *l2t;
196 struct dst_entry *dst;
197 struct list_head list;
198 struct sk_buff_head rxq;
199 struct sk_buff_head txq;
200 struct sk_buff_head ppodq;
201 struct sk_buff_head backlogq;
202 struct sk_buff_head skbq;
203 struct sk_buff *wr_pending_head;
204 struct sk_buff *wr_pending_tail;
205 struct sk_buff *skb;
206 struct sk_buff *lro_skb;
207 struct sk_buff *lro_hskb;
208 struct list_head accept_node;
209 /* socket lock */
210 spinlock_t lock;
211 wait_queue_head_t waitq;
212 wait_queue_head_t ack_waitq;
213 bool lock_owner;
214 struct kref kref;
215 u32 max_iso_npdu;
216 u32 wr_cred;
217 u32 wr_una_cred;
218 u32 wr_max_cred;
219 u32 snd_una;
220 u32 tid;
221 u32 snd_nxt;
222 u32 rcv_nxt;
223 u32 smac_idx;
224 u32 tx_chan;
225 u32 mtu;
226 u32 write_seq;
227 u32 rx_credits;
228 u32 snd_win;
229 u32 rcv_win;
230 u16 mss;
231 u16 emss;
232 u16 plen;
233 u16 rss_qid;
234 u16 txq_idx;
235 u16 ctrlq_idx;
236 u8 tos;
237 u8 port_id;
238#define CXGBIT_SUBMODE_HCRC 0x1
239#define CXGBIT_SUBMODE_DCRC 0x2
240 u8 submode;
241#ifdef CONFIG_CHELSIO_T4_DCB
242 u8 dcb_priority;
243#endif
244 u8 snd_wscale;
245};
246
247void _cxgbit_free_cdev(struct kref *kref);
248void _cxgbit_free_csk(struct kref *kref);
249void _cxgbit_free_cnp(struct kref *kref);
250
251static inline void cxgbit_get_cdev(struct cxgbit_device *cdev)
252{
253 kref_get(&cdev->kref);
254}
255
256static inline void cxgbit_put_cdev(struct cxgbit_device *cdev)
257{
258 kref_put(&cdev->kref, _cxgbit_free_cdev);
259}
260
261static inline void cxgbit_get_csk(struct cxgbit_sock *csk)
262{
263 kref_get(&csk->kref);
264}
265
266static inline void cxgbit_put_csk(struct cxgbit_sock *csk)
267{
268 kref_put(&csk->kref, _cxgbit_free_csk);
269}
270
271static inline void cxgbit_get_cnp(struct cxgbit_np *cnp)
272{
273 kref_get(&cnp->kref);
274}
275
276static inline void cxgbit_put_cnp(struct cxgbit_np *cnp)
277{
278 kref_put(&cnp->kref, _cxgbit_free_cnp);
279}
280
281static inline void cxgbit_sock_reset_wr_list(struct cxgbit_sock *csk)
282{
283 csk->wr_pending_tail = NULL;
284 csk->wr_pending_head = NULL;
285}
286
287static inline struct sk_buff *cxgbit_sock_peek_wr(const struct cxgbit_sock *csk)
288{
289 return csk->wr_pending_head;
290}
291
292static inline void
293cxgbit_sock_enqueue_wr(struct cxgbit_sock *csk, struct sk_buff *skb)
294{
295 cxgbit_skcb_tx_wr_next(skb) = NULL;
296
297 skb_get(skb);
298
299 if (!csk->wr_pending_head)
300 csk->wr_pending_head = skb;
301 else
302 cxgbit_skcb_tx_wr_next(csk->wr_pending_tail) = skb;
303 csk->wr_pending_tail = skb;
304}
305
306static inline struct sk_buff *cxgbit_sock_dequeue_wr(struct cxgbit_sock *csk)
307{
308 struct sk_buff *skb = csk->wr_pending_head;
309
310 if (likely(skb)) {
311 csk->wr_pending_head = cxgbit_skcb_tx_wr_next(skb);
312 cxgbit_skcb_tx_wr_next(skb) = NULL;
313 }
314 return skb;
315}
316
317typedef void (*cxgbit_cplhandler_func)(struct cxgbit_device *,
318 struct sk_buff *);
319
320int cxgbit_setup_np(struct iscsi_np *, struct sockaddr_storage *);
321int cxgbit_setup_conn_digest(struct cxgbit_sock *);
322int cxgbit_accept_np(struct iscsi_np *, struct iscsi_conn *);
323void cxgbit_free_np(struct iscsi_np *);
324void cxgbit_free_conn(struct iscsi_conn *);
325extern cxgbit_cplhandler_func cxgbit_cplhandlers[NUM_CPL_CMDS];
326int cxgbit_get_login_rx(struct iscsi_conn *, struct iscsi_login *);
327int cxgbit_rx_data_ack(struct cxgbit_sock *);
328int cxgbit_l2t_send(struct cxgbit_device *, struct sk_buff *,
329 struct l2t_entry *);
330void cxgbit_push_tx_frames(struct cxgbit_sock *);
331int cxgbit_put_login_tx(struct iscsi_conn *, struct iscsi_login *, u32);
332int cxgbit_xmit_pdu(struct iscsi_conn *, struct iscsi_cmd *,
333 struct iscsi_datain_req *, const void *, u32);
334void cxgbit_get_r2t_ttt(struct iscsi_conn *, struct iscsi_cmd *,
335 struct iscsi_r2t *);
336u32 cxgbit_send_tx_flowc_wr(struct cxgbit_sock *);
337int cxgbit_ofld_send(struct cxgbit_device *, struct sk_buff *);
338void cxgbit_get_rx_pdu(struct iscsi_conn *);
339int cxgbit_validate_params(struct iscsi_conn *);
340struct cxgbit_device *cxgbit_find_device(struct net_device *, u8 *);
341
342/* DDP */
343int cxgbit_ddp_init(struct cxgbit_device *);
344int cxgbit_setup_conn_pgidx(struct cxgbit_sock *, u32);
345int cxgbit_reserve_ttt(struct cxgbit_sock *, struct iscsi_cmd *);
346void cxgbit_release_cmd(struct iscsi_conn *, struct iscsi_cmd *);
347
348static inline
349struct cxgbi_ppm *cdev2ppm(struct cxgbit_device *cdev)
350{
351 return (struct cxgbi_ppm *)(*cdev->lldi.iscsi_ppm);
352}
353#endif /* __CXGBIT_H__ */