]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/infiniband/hw/cxgb4/cm.c
IPoIB: Call skb_dst_drop() once skb is enqueued for sending
[~shefty/rdma-dev.git] / drivers / infiniband / hw / cxgb4 / cm.c
1 /*
2  * Copyright (c) 2009-2010 Chelsio, 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 #include <linux/module.h>
33 #include <linux/list.h>
34 #include <linux/workqueue.h>
35 #include <linux/skbuff.h>
36 #include <linux/timer.h>
37 #include <linux/notifier.h>
38 #include <linux/inetdevice.h>
39 #include <linux/ip.h>
40 #include <linux/tcp.h>
41
42 #include <net/neighbour.h>
43 #include <net/netevent.h>
44 #include <net/route.h>
45
46 #include "iw_cxgb4.h"
47
48 static char *states[] = {
49         "idle",
50         "listen",
51         "connecting",
52         "mpa_wait_req",
53         "mpa_req_sent",
54         "mpa_req_rcvd",
55         "mpa_rep_sent",
56         "fpdu_mode",
57         "aborting",
58         "closing",
59         "moribund",
60         "dead",
61         NULL,
62 };
63
64 static int dack_mode = 1;
65 module_param(dack_mode, int, 0644);
66 MODULE_PARM_DESC(dack_mode, "Delayed ack mode (default=1)");
67
68 int c4iw_max_read_depth = 8;
69 module_param(c4iw_max_read_depth, int, 0644);
70 MODULE_PARM_DESC(c4iw_max_read_depth, "Per-connection max ORD/IRD (default=8)");
71
72 static int enable_tcp_timestamps;
73 module_param(enable_tcp_timestamps, int, 0644);
74 MODULE_PARM_DESC(enable_tcp_timestamps, "Enable tcp timestamps (default=0)");
75
76 static int enable_tcp_sack;
77 module_param(enable_tcp_sack, int, 0644);
78 MODULE_PARM_DESC(enable_tcp_sack, "Enable tcp SACK (default=0)");
79
80 static int enable_tcp_window_scaling = 1;
81 module_param(enable_tcp_window_scaling, int, 0644);
82 MODULE_PARM_DESC(enable_tcp_window_scaling,
83                  "Enable tcp window scaling (default=1)");
84
85 int c4iw_debug;
86 module_param(c4iw_debug, int, 0644);
87 MODULE_PARM_DESC(c4iw_debug, "Enable debug logging (default=0)");
88
89 static int peer2peer;
90 module_param(peer2peer, int, 0644);
91 MODULE_PARM_DESC(peer2peer, "Support peer2peer ULPs (default=0)");
92
93 static int p2p_type = FW_RI_INIT_P2PTYPE_READ_REQ;
94 module_param(p2p_type, int, 0644);
95 MODULE_PARM_DESC(p2p_type, "RDMAP opcode to use for the RTR message: "
96                            "1=RDMA_READ 0=RDMA_WRITE (default 1)");
97
98 static int ep_timeout_secs = 60;
99 module_param(ep_timeout_secs, int, 0644);
100 MODULE_PARM_DESC(ep_timeout_secs, "CM Endpoint operation timeout "
101                                    "in seconds (default=60)");
102
103 static int mpa_rev = 1;
104 module_param(mpa_rev, int, 0644);
105 MODULE_PARM_DESC(mpa_rev, "MPA Revision, 0 supports amso1100, "
106                 "1 is RFC0544 spec compliant, 2 is IETF MPA Peer Connect Draft"
107                 " compliant (default=1)");
108
109 static int markers_enabled;
110 module_param(markers_enabled, int, 0644);
111 MODULE_PARM_DESC(markers_enabled, "Enable MPA MARKERS (default(0)=disabled)");
112
113 static int crc_enabled = 1;
114 module_param(crc_enabled, int, 0644);
115 MODULE_PARM_DESC(crc_enabled, "Enable MPA CRC (default(1)=enabled)");
116
117 static int rcv_win = 256 * 1024;
118 module_param(rcv_win, int, 0644);
119 MODULE_PARM_DESC(rcv_win, "TCP receive window in bytes (default=256KB)");
120
121 static int snd_win = 128 * 1024;
122 module_param(snd_win, int, 0644);
123 MODULE_PARM_DESC(snd_win, "TCP send window in bytes (default=128KB)");
124
125 static struct workqueue_struct *workq;
126
127 static struct sk_buff_head rxq;
128
129 static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp);
130 static void ep_timeout(unsigned long arg);
131 static void connect_reply_upcall(struct c4iw_ep *ep, int status);
132
133 static LIST_HEAD(timeout_list);
134 static spinlock_t timeout_lock;
135
136 static void start_ep_timer(struct c4iw_ep *ep)
137 {
138         PDBG("%s ep %p\n", __func__, ep);
139         if (timer_pending(&ep->timer)) {
140                 PDBG("%s stopped / restarted timer ep %p\n", __func__, ep);
141                 del_timer_sync(&ep->timer);
142         } else
143                 c4iw_get_ep(&ep->com);
144         ep->timer.expires = jiffies + ep_timeout_secs * HZ;
145         ep->timer.data = (unsigned long)ep;
146         ep->timer.function = ep_timeout;
147         add_timer(&ep->timer);
148 }
149
150 static void stop_ep_timer(struct c4iw_ep *ep)
151 {
152         PDBG("%s ep %p\n", __func__, ep);
153         if (!timer_pending(&ep->timer)) {
154                 WARN(1, "%s timer stopped when its not running! "
155                        "ep %p state %u\n", __func__, ep, ep->com.state);
156                 return;
157         }
158         del_timer_sync(&ep->timer);
159         c4iw_put_ep(&ep->com);
160 }
161
162 static int c4iw_l2t_send(struct c4iw_rdev *rdev, struct sk_buff *skb,
163                   struct l2t_entry *l2e)
164 {
165         int     error = 0;
166
167         if (c4iw_fatal_error(rdev)) {
168                 kfree_skb(skb);
169                 PDBG("%s - device in error state - dropping\n", __func__);
170                 return -EIO;
171         }
172         error = cxgb4_l2t_send(rdev->lldi.ports[0], skb, l2e);
173         if (error < 0)
174                 kfree_skb(skb);
175         return error < 0 ? error : 0;
176 }
177
178 int c4iw_ofld_send(struct c4iw_rdev *rdev, struct sk_buff *skb)
179 {
180         int     error = 0;
181
182         if (c4iw_fatal_error(rdev)) {
183                 kfree_skb(skb);
184                 PDBG("%s - device in error state - dropping\n", __func__);
185                 return -EIO;
186         }
187         error = cxgb4_ofld_send(rdev->lldi.ports[0], skb);
188         if (error < 0)
189                 kfree_skb(skb);
190         return error < 0 ? error : 0;
191 }
192
193 static void release_tid(struct c4iw_rdev *rdev, u32 hwtid, struct sk_buff *skb)
194 {
195         struct cpl_tid_release *req;
196
197         skb = get_skb(skb, sizeof *req, GFP_KERNEL);
198         if (!skb)
199                 return;
200         req = (struct cpl_tid_release *) skb_put(skb, sizeof(*req));
201         INIT_TP_WR(req, hwtid);
202         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_TID_RELEASE, hwtid));
203         set_wr_txq(skb, CPL_PRIORITY_SETUP, 0);
204         c4iw_ofld_send(rdev, skb);
205         return;
206 }
207
208 static void set_emss(struct c4iw_ep *ep, u16 opt)
209 {
210         ep->emss = ep->com.dev->rdev.lldi.mtus[GET_TCPOPT_MSS(opt)] - 40;
211         ep->mss = ep->emss;
212         if (GET_TCPOPT_TSTAMP(opt))
213                 ep->emss -= 12;
214         if (ep->emss < 128)
215                 ep->emss = 128;
216         PDBG("%s mss_idx %u mss %u emss=%u\n", __func__, GET_TCPOPT_MSS(opt),
217              ep->mss, ep->emss);
218 }
219
220 static enum c4iw_ep_state state_read(struct c4iw_ep_common *epc)
221 {
222         enum c4iw_ep_state state;
223
224         mutex_lock(&epc->mutex);
225         state = epc->state;
226         mutex_unlock(&epc->mutex);
227         return state;
228 }
229
230 static void __state_set(struct c4iw_ep_common *epc, enum c4iw_ep_state new)
231 {
232         epc->state = new;
233 }
234
235 static void state_set(struct c4iw_ep_common *epc, enum c4iw_ep_state new)
236 {
237         mutex_lock(&epc->mutex);
238         PDBG("%s - %s -> %s\n", __func__, states[epc->state], states[new]);
239         __state_set(epc, new);
240         mutex_unlock(&epc->mutex);
241         return;
242 }
243
244 static void *alloc_ep(int size, gfp_t gfp)
245 {
246         struct c4iw_ep_common *epc;
247
248         epc = kzalloc(size, gfp);
249         if (epc) {
250                 kref_init(&epc->kref);
251                 mutex_init(&epc->mutex);
252                 c4iw_init_wr_wait(&epc->wr_wait);
253         }
254         PDBG("%s alloc ep %p\n", __func__, epc);
255         return epc;
256 }
257
258 void _c4iw_free_ep(struct kref *kref)
259 {
260         struct c4iw_ep *ep;
261
262         ep = container_of(kref, struct c4iw_ep, com.kref);
263         PDBG("%s ep %p state %s\n", __func__, ep, states[state_read(&ep->com)]);
264         if (test_bit(RELEASE_RESOURCES, &ep->com.flags)) {
265                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, ep->hwtid);
266                 dst_release(ep->dst);
267                 cxgb4_l2t_release(ep->l2t);
268         }
269         kfree(ep);
270 }
271
272 static void release_ep_resources(struct c4iw_ep *ep)
273 {
274         set_bit(RELEASE_RESOURCES, &ep->com.flags);
275         c4iw_put_ep(&ep->com);
276 }
277
278 static int status2errno(int status)
279 {
280         switch (status) {
281         case CPL_ERR_NONE:
282                 return 0;
283         case CPL_ERR_CONN_RESET:
284                 return -ECONNRESET;
285         case CPL_ERR_ARP_MISS:
286                 return -EHOSTUNREACH;
287         case CPL_ERR_CONN_TIMEDOUT:
288                 return -ETIMEDOUT;
289         case CPL_ERR_TCAM_FULL:
290                 return -ENOMEM;
291         case CPL_ERR_CONN_EXIST:
292                 return -EADDRINUSE;
293         default:
294                 return -EIO;
295         }
296 }
297
298 /*
299  * Try and reuse skbs already allocated...
300  */
301 static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp)
302 {
303         if (skb && !skb_is_nonlinear(skb) && !skb_cloned(skb)) {
304                 skb_trim(skb, 0);
305                 skb_get(skb);
306                 skb_reset_transport_header(skb);
307         } else {
308                 skb = alloc_skb(len, gfp);
309         }
310         return skb;
311 }
312
313 static struct rtable *find_route(struct c4iw_dev *dev, __be32 local_ip,
314                                  __be32 peer_ip, __be16 local_port,
315                                  __be16 peer_port, u8 tos)
316 {
317         struct rtable *rt;
318         struct flowi4 fl4;
319
320         rt = ip_route_output_ports(&init_net, &fl4, NULL, peer_ip, local_ip,
321                                    peer_port, local_port, IPPROTO_TCP,
322                                    tos, 0);
323         if (IS_ERR(rt))
324                 return NULL;
325         return rt;
326 }
327
328 static void arp_failure_discard(void *handle, struct sk_buff *skb)
329 {
330         PDBG("%s c4iw_dev %p\n", __func__, handle);
331         kfree_skb(skb);
332 }
333
334 /*
335  * Handle an ARP failure for an active open.
336  */
337 static void act_open_req_arp_failure(void *handle, struct sk_buff *skb)
338 {
339         printk(KERN_ERR MOD "ARP failure duing connect\n");
340         kfree_skb(skb);
341 }
342
343 /*
344  * Handle an ARP failure for a CPL_ABORT_REQ.  Change it into a no RST variant
345  * and send it along.
346  */
347 static void abort_arp_failure(void *handle, struct sk_buff *skb)
348 {
349         struct c4iw_rdev *rdev = handle;
350         struct cpl_abort_req *req = cplhdr(skb);
351
352         PDBG("%s rdev %p\n", __func__, rdev);
353         req->cmd = CPL_ABORT_NO_RST;
354         c4iw_ofld_send(rdev, skb);
355 }
356
357 static void send_flowc(struct c4iw_ep *ep, struct sk_buff *skb)
358 {
359         unsigned int flowclen = 80;
360         struct fw_flowc_wr *flowc;
361         int i;
362
363         skb = get_skb(skb, flowclen, GFP_KERNEL);
364         flowc = (struct fw_flowc_wr *)__skb_put(skb, flowclen);
365
366         flowc->op_to_nparams = cpu_to_be32(FW_WR_OP(FW_FLOWC_WR) |
367                                            FW_FLOWC_WR_NPARAMS(8));
368         flowc->flowid_len16 = cpu_to_be32(FW_WR_LEN16(DIV_ROUND_UP(flowclen,
369                                           16)) | FW_WR_FLOWID(ep->hwtid));
370
371         flowc->mnemval[0].mnemonic = FW_FLOWC_MNEM_PFNVFN;
372         flowc->mnemval[0].val = cpu_to_be32(PCI_FUNC(ep->com.dev->rdev.lldi.pdev->devfn) << 8);
373         flowc->mnemval[1].mnemonic = FW_FLOWC_MNEM_CH;
374         flowc->mnemval[1].val = cpu_to_be32(ep->tx_chan);
375         flowc->mnemval[2].mnemonic = FW_FLOWC_MNEM_PORT;
376         flowc->mnemval[2].val = cpu_to_be32(ep->tx_chan);
377         flowc->mnemval[3].mnemonic = FW_FLOWC_MNEM_IQID;
378         flowc->mnemval[3].val = cpu_to_be32(ep->rss_qid);
379         flowc->mnemval[4].mnemonic = FW_FLOWC_MNEM_SNDNXT;
380         flowc->mnemval[4].val = cpu_to_be32(ep->snd_seq);
381         flowc->mnemval[5].mnemonic = FW_FLOWC_MNEM_RCVNXT;
382         flowc->mnemval[5].val = cpu_to_be32(ep->rcv_seq);
383         flowc->mnemval[6].mnemonic = FW_FLOWC_MNEM_SNDBUF;
384         flowc->mnemval[6].val = cpu_to_be32(snd_win);
385         flowc->mnemval[7].mnemonic = FW_FLOWC_MNEM_MSS;
386         flowc->mnemval[7].val = cpu_to_be32(ep->emss);
387         /* Pad WR to 16 byte boundary */
388         flowc->mnemval[8].mnemonic = 0;
389         flowc->mnemval[8].val = 0;
390         for (i = 0; i < 9; i++) {
391                 flowc->mnemval[i].r4[0] = 0;
392                 flowc->mnemval[i].r4[1] = 0;
393                 flowc->mnemval[i].r4[2] = 0;
394         }
395
396         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
397         c4iw_ofld_send(&ep->com.dev->rdev, skb);
398 }
399
400 static int send_halfclose(struct c4iw_ep *ep, gfp_t gfp)
401 {
402         struct cpl_close_con_req *req;
403         struct sk_buff *skb;
404         int wrlen = roundup(sizeof *req, 16);
405
406         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
407         skb = get_skb(NULL, wrlen, gfp);
408         if (!skb) {
409                 printk(KERN_ERR MOD "%s - failed to alloc skb\n", __func__);
410                 return -ENOMEM;
411         }
412         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
413         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
414         req = (struct cpl_close_con_req *) skb_put(skb, wrlen);
415         memset(req, 0, wrlen);
416         INIT_TP_WR(req, ep->hwtid);
417         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_CLOSE_CON_REQ,
418                                                     ep->hwtid));
419         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
420 }
421
422 static int send_abort(struct c4iw_ep *ep, struct sk_buff *skb, gfp_t gfp)
423 {
424         struct cpl_abort_req *req;
425         int wrlen = roundup(sizeof *req, 16);
426
427         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
428         skb = get_skb(skb, wrlen, gfp);
429         if (!skb) {
430                 printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
431                        __func__);
432                 return -ENOMEM;
433         }
434         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
435         t4_set_arp_err_handler(skb, &ep->com.dev->rdev, abort_arp_failure);
436         req = (struct cpl_abort_req *) skb_put(skb, wrlen);
437         memset(req, 0, wrlen);
438         INIT_TP_WR(req, ep->hwtid);
439         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_REQ, ep->hwtid));
440         req->cmd = CPL_ABORT_SEND_RST;
441         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
442 }
443
444 static int send_connect(struct c4iw_ep *ep)
445 {
446         struct cpl_act_open_req *req;
447         struct sk_buff *skb;
448         u64 opt0;
449         u32 opt2;
450         unsigned int mtu_idx;
451         int wscale;
452         int wrlen = roundup(sizeof *req, 16);
453
454         PDBG("%s ep %p atid %u\n", __func__, ep, ep->atid);
455
456         skb = get_skb(NULL, wrlen, GFP_KERNEL);
457         if (!skb) {
458                 printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
459                        __func__);
460                 return -ENOMEM;
461         }
462         set_wr_txq(skb, CPL_PRIORITY_SETUP, ep->ctrlq_idx);
463
464         cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
465         wscale = compute_wscale(rcv_win);
466         opt0 = KEEP_ALIVE(1) |
467                DELACK(1) |
468                WND_SCALE(wscale) |
469                MSS_IDX(mtu_idx) |
470                L2T_IDX(ep->l2t->idx) |
471                TX_CHAN(ep->tx_chan) |
472                SMAC_SEL(ep->smac_idx) |
473                DSCP(ep->tos) |
474                ULP_MODE(ULP_MODE_TCPDDP) |
475                RCV_BUFSIZ(rcv_win>>10);
476         opt2 = RX_CHANNEL(0) |
477                RSS_QUEUE_VALID | RSS_QUEUE(ep->rss_qid);
478         if (enable_tcp_timestamps)
479                 opt2 |= TSTAMPS_EN(1);
480         if (enable_tcp_sack)
481                 opt2 |= SACK_EN(1);
482         if (wscale && enable_tcp_window_scaling)
483                 opt2 |= WND_SCALE_EN(1);
484         t4_set_arp_err_handler(skb, NULL, act_open_req_arp_failure);
485
486         req = (struct cpl_act_open_req *) skb_put(skb, wrlen);
487         INIT_TP_WR(req, 0);
488         OPCODE_TID(req) = cpu_to_be32(
489                 MK_OPCODE_TID(CPL_ACT_OPEN_REQ, ((ep->rss_qid<<14)|ep->atid)));
490         req->local_port = ep->com.local_addr.sin_port;
491         req->peer_port = ep->com.remote_addr.sin_port;
492         req->local_ip = ep->com.local_addr.sin_addr.s_addr;
493         req->peer_ip = ep->com.remote_addr.sin_addr.s_addr;
494         req->opt0 = cpu_to_be64(opt0);
495         req->params = 0;
496         req->opt2 = cpu_to_be32(opt2);
497         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
498 }
499
500 static void send_mpa_req(struct c4iw_ep *ep, struct sk_buff *skb,
501                 u8 mpa_rev_to_use)
502 {
503         int mpalen, wrlen;
504         struct fw_ofld_tx_data_wr *req;
505         struct mpa_message *mpa;
506         struct mpa_v2_conn_params mpa_v2_params;
507
508         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
509
510         BUG_ON(skb_cloned(skb));
511
512         mpalen = sizeof(*mpa) + ep->plen;
513         if (mpa_rev_to_use == 2)
514                 mpalen += sizeof(struct mpa_v2_conn_params);
515         wrlen = roundup(mpalen + sizeof *req, 16);
516         skb = get_skb(skb, wrlen, GFP_KERNEL);
517         if (!skb) {
518                 connect_reply_upcall(ep, -ENOMEM);
519                 return;
520         }
521         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
522
523         req = (struct fw_ofld_tx_data_wr *)skb_put(skb, wrlen);
524         memset(req, 0, wrlen);
525         req->op_to_immdlen = cpu_to_be32(
526                 FW_WR_OP(FW_OFLD_TX_DATA_WR) |
527                 FW_WR_COMPL(1) |
528                 FW_WR_IMMDLEN(mpalen));
529         req->flowid_len16 = cpu_to_be32(
530                 FW_WR_FLOWID(ep->hwtid) |
531                 FW_WR_LEN16(wrlen >> 4));
532         req->plen = cpu_to_be32(mpalen);
533         req->tunnel_to_proxy = cpu_to_be32(
534                 FW_OFLD_TX_DATA_WR_FLUSH(1) |
535                 FW_OFLD_TX_DATA_WR_SHOVE(1));
536
537         mpa = (struct mpa_message *)(req + 1);
538         memcpy(mpa->key, MPA_KEY_REQ, sizeof(mpa->key));
539         mpa->flags = (crc_enabled ? MPA_CRC : 0) |
540                      (markers_enabled ? MPA_MARKERS : 0) |
541                      (mpa_rev_to_use == 2 ? MPA_ENHANCED_RDMA_CONN : 0);
542         mpa->private_data_size = htons(ep->plen);
543         mpa->revision = mpa_rev_to_use;
544         if (mpa_rev_to_use == 1) {
545                 ep->tried_with_mpa_v1 = 1;
546                 ep->retry_with_mpa_v1 = 0;
547         }
548
549         if (mpa_rev_to_use == 2) {
550                 mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
551                                                sizeof (struct mpa_v2_conn_params));
552                 mpa_v2_params.ird = htons((u16)ep->ird);
553                 mpa_v2_params.ord = htons((u16)ep->ord);
554
555                 if (peer2peer) {
556                         mpa_v2_params.ird |= htons(MPA_V2_PEER2PEER_MODEL);
557                         if (p2p_type == FW_RI_INIT_P2PTYPE_RDMA_WRITE)
558                                 mpa_v2_params.ord |=
559                                         htons(MPA_V2_RDMA_WRITE_RTR);
560                         else if (p2p_type == FW_RI_INIT_P2PTYPE_READ_REQ)
561                                 mpa_v2_params.ord |=
562                                         htons(MPA_V2_RDMA_READ_RTR);
563                 }
564                 memcpy(mpa->private_data, &mpa_v2_params,
565                        sizeof(struct mpa_v2_conn_params));
566
567                 if (ep->plen)
568                         memcpy(mpa->private_data +
569                                sizeof(struct mpa_v2_conn_params),
570                                ep->mpa_pkt + sizeof(*mpa), ep->plen);
571         } else
572                 if (ep->plen)
573                         memcpy(mpa->private_data,
574                                         ep->mpa_pkt + sizeof(*mpa), ep->plen);
575
576         /*
577          * Reference the mpa skb.  This ensures the data area
578          * will remain in memory until the hw acks the tx.
579          * Function fw4_ack() will deref it.
580          */
581         skb_get(skb);
582         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
583         BUG_ON(ep->mpa_skb);
584         ep->mpa_skb = skb;
585         c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
586         start_ep_timer(ep);
587         state_set(&ep->com, MPA_REQ_SENT);
588         ep->mpa_attr.initiator = 1;
589         return;
590 }
591
592 static int send_mpa_reject(struct c4iw_ep *ep, const void *pdata, u8 plen)
593 {
594         int mpalen, wrlen;
595         struct fw_ofld_tx_data_wr *req;
596         struct mpa_message *mpa;
597         struct sk_buff *skb;
598         struct mpa_v2_conn_params mpa_v2_params;
599
600         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
601
602         mpalen = sizeof(*mpa) + plen;
603         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn)
604                 mpalen += sizeof(struct mpa_v2_conn_params);
605         wrlen = roundup(mpalen + sizeof *req, 16);
606
607         skb = get_skb(NULL, wrlen, GFP_KERNEL);
608         if (!skb) {
609                 printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
610                 return -ENOMEM;
611         }
612         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
613
614         req = (struct fw_ofld_tx_data_wr *)skb_put(skb, wrlen);
615         memset(req, 0, wrlen);
616         req->op_to_immdlen = cpu_to_be32(
617                 FW_WR_OP(FW_OFLD_TX_DATA_WR) |
618                 FW_WR_COMPL(1) |
619                 FW_WR_IMMDLEN(mpalen));
620         req->flowid_len16 = cpu_to_be32(
621                 FW_WR_FLOWID(ep->hwtid) |
622                 FW_WR_LEN16(wrlen >> 4));
623         req->plen = cpu_to_be32(mpalen);
624         req->tunnel_to_proxy = cpu_to_be32(
625                 FW_OFLD_TX_DATA_WR_FLUSH(1) |
626                 FW_OFLD_TX_DATA_WR_SHOVE(1));
627
628         mpa = (struct mpa_message *)(req + 1);
629         memset(mpa, 0, sizeof(*mpa));
630         memcpy(mpa->key, MPA_KEY_REP, sizeof(mpa->key));
631         mpa->flags = MPA_REJECT;
632         mpa->revision = mpa_rev;
633         mpa->private_data_size = htons(plen);
634
635         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
636                 mpa->flags |= MPA_ENHANCED_RDMA_CONN;
637                 mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
638                                                sizeof (struct mpa_v2_conn_params));
639                 mpa_v2_params.ird = htons(((u16)ep->ird) |
640                                           (peer2peer ? MPA_V2_PEER2PEER_MODEL :
641                                            0));
642                 mpa_v2_params.ord = htons(((u16)ep->ord) | (peer2peer ?
643                                           (p2p_type ==
644                                            FW_RI_INIT_P2PTYPE_RDMA_WRITE ?
645                                            MPA_V2_RDMA_WRITE_RTR : p2p_type ==
646                                            FW_RI_INIT_P2PTYPE_READ_REQ ?
647                                            MPA_V2_RDMA_READ_RTR : 0) : 0));
648                 memcpy(mpa->private_data, &mpa_v2_params,
649                        sizeof(struct mpa_v2_conn_params));
650
651                 if (ep->plen)
652                         memcpy(mpa->private_data +
653                                sizeof(struct mpa_v2_conn_params), pdata, plen);
654         } else
655                 if (plen)
656                         memcpy(mpa->private_data, pdata, plen);
657
658         /*
659          * Reference the mpa skb again.  This ensures the data area
660          * will remain in memory until the hw acks the tx.
661          * Function fw4_ack() will deref it.
662          */
663         skb_get(skb);
664         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
665         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
666         BUG_ON(ep->mpa_skb);
667         ep->mpa_skb = skb;
668         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
669 }
670
671 static int send_mpa_reply(struct c4iw_ep *ep, const void *pdata, u8 plen)
672 {
673         int mpalen, wrlen;
674         struct fw_ofld_tx_data_wr *req;
675         struct mpa_message *mpa;
676         struct sk_buff *skb;
677         struct mpa_v2_conn_params mpa_v2_params;
678
679         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
680
681         mpalen = sizeof(*mpa) + plen;
682         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn)
683                 mpalen += sizeof(struct mpa_v2_conn_params);
684         wrlen = roundup(mpalen + sizeof *req, 16);
685
686         skb = get_skb(NULL, wrlen, GFP_KERNEL);
687         if (!skb) {
688                 printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
689                 return -ENOMEM;
690         }
691         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
692
693         req = (struct fw_ofld_tx_data_wr *) skb_put(skb, wrlen);
694         memset(req, 0, wrlen);
695         req->op_to_immdlen = cpu_to_be32(
696                 FW_WR_OP(FW_OFLD_TX_DATA_WR) |
697                 FW_WR_COMPL(1) |
698                 FW_WR_IMMDLEN(mpalen));
699         req->flowid_len16 = cpu_to_be32(
700                 FW_WR_FLOWID(ep->hwtid) |
701                 FW_WR_LEN16(wrlen >> 4));
702         req->plen = cpu_to_be32(mpalen);
703         req->tunnel_to_proxy = cpu_to_be32(
704                 FW_OFLD_TX_DATA_WR_FLUSH(1) |
705                 FW_OFLD_TX_DATA_WR_SHOVE(1));
706
707         mpa = (struct mpa_message *)(req + 1);
708         memset(mpa, 0, sizeof(*mpa));
709         memcpy(mpa->key, MPA_KEY_REP, sizeof(mpa->key));
710         mpa->flags = (ep->mpa_attr.crc_enabled ? MPA_CRC : 0) |
711                      (markers_enabled ? MPA_MARKERS : 0);
712         mpa->revision = ep->mpa_attr.version;
713         mpa->private_data_size = htons(plen);
714
715         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
716                 mpa->flags |= MPA_ENHANCED_RDMA_CONN;
717                 mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
718                                                sizeof (struct mpa_v2_conn_params));
719                 mpa_v2_params.ird = htons((u16)ep->ird);
720                 mpa_v2_params.ord = htons((u16)ep->ord);
721                 if (peer2peer && (ep->mpa_attr.p2p_type !=
722                                         FW_RI_INIT_P2PTYPE_DISABLED)) {
723                         mpa_v2_params.ird |= htons(MPA_V2_PEER2PEER_MODEL);
724
725                         if (p2p_type == FW_RI_INIT_P2PTYPE_RDMA_WRITE)
726                                 mpa_v2_params.ord |=
727                                         htons(MPA_V2_RDMA_WRITE_RTR);
728                         else if (p2p_type == FW_RI_INIT_P2PTYPE_READ_REQ)
729                                 mpa_v2_params.ord |=
730                                         htons(MPA_V2_RDMA_READ_RTR);
731                 }
732
733                 memcpy(mpa->private_data, &mpa_v2_params,
734                        sizeof(struct mpa_v2_conn_params));
735
736                 if (ep->plen)
737                         memcpy(mpa->private_data +
738                                sizeof(struct mpa_v2_conn_params), pdata, plen);
739         } else
740                 if (plen)
741                         memcpy(mpa->private_data, pdata, plen);
742
743         /*
744          * Reference the mpa skb.  This ensures the data area
745          * will remain in memory until the hw acks the tx.
746          * Function fw4_ack() will deref it.
747          */
748         skb_get(skb);
749         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
750         ep->mpa_skb = skb;
751         state_set(&ep->com, MPA_REP_SENT);
752         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
753 }
754
755 static int act_establish(struct c4iw_dev *dev, struct sk_buff *skb)
756 {
757         struct c4iw_ep *ep;
758         struct cpl_act_establish *req = cplhdr(skb);
759         unsigned int tid = GET_TID(req);
760         unsigned int atid = GET_TID_TID(ntohl(req->tos_atid));
761         struct tid_info *t = dev->rdev.lldi.tids;
762
763         ep = lookup_atid(t, atid);
764
765         PDBG("%s ep %p tid %u snd_isn %u rcv_isn %u\n", __func__, ep, tid,
766              be32_to_cpu(req->snd_isn), be32_to_cpu(req->rcv_isn));
767
768         dst_confirm(ep->dst);
769
770         /* setup the hwtid for this connection */
771         ep->hwtid = tid;
772         cxgb4_insert_tid(t, ep, tid);
773
774         ep->snd_seq = be32_to_cpu(req->snd_isn);
775         ep->rcv_seq = be32_to_cpu(req->rcv_isn);
776
777         set_emss(ep, ntohs(req->tcp_opt));
778
779         /* dealloc the atid */
780         cxgb4_free_atid(t, atid);
781
782         /* start MPA negotiation */
783         send_flowc(ep, NULL);
784         if (ep->retry_with_mpa_v1)
785                 send_mpa_req(ep, skb, 1);
786         else
787                 send_mpa_req(ep, skb, mpa_rev);
788
789         return 0;
790 }
791
792 static void close_complete_upcall(struct c4iw_ep *ep)
793 {
794         struct iw_cm_event event;
795
796         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
797         memset(&event, 0, sizeof(event));
798         event.event = IW_CM_EVENT_CLOSE;
799         if (ep->com.cm_id) {
800                 PDBG("close complete delivered ep %p cm_id %p tid %u\n",
801                      ep, ep->com.cm_id, ep->hwtid);
802                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
803                 ep->com.cm_id->rem_ref(ep->com.cm_id);
804                 ep->com.cm_id = NULL;
805                 ep->com.qp = NULL;
806         }
807 }
808
809 static int abort_connection(struct c4iw_ep *ep, struct sk_buff *skb, gfp_t gfp)
810 {
811         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
812         close_complete_upcall(ep);
813         state_set(&ep->com, ABORTING);
814         return send_abort(ep, skb, gfp);
815 }
816
817 static void peer_close_upcall(struct c4iw_ep *ep)
818 {
819         struct iw_cm_event event;
820
821         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
822         memset(&event, 0, sizeof(event));
823         event.event = IW_CM_EVENT_DISCONNECT;
824         if (ep->com.cm_id) {
825                 PDBG("peer close delivered ep %p cm_id %p tid %u\n",
826                      ep, ep->com.cm_id, ep->hwtid);
827                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
828         }
829 }
830
831 static void peer_abort_upcall(struct c4iw_ep *ep)
832 {
833         struct iw_cm_event event;
834
835         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
836         memset(&event, 0, sizeof(event));
837         event.event = IW_CM_EVENT_CLOSE;
838         event.status = -ECONNRESET;
839         if (ep->com.cm_id) {
840                 PDBG("abort delivered ep %p cm_id %p tid %u\n", ep,
841                      ep->com.cm_id, ep->hwtid);
842                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
843                 ep->com.cm_id->rem_ref(ep->com.cm_id);
844                 ep->com.cm_id = NULL;
845                 ep->com.qp = NULL;
846         }
847 }
848
849 static void connect_reply_upcall(struct c4iw_ep *ep, int status)
850 {
851         struct iw_cm_event event;
852
853         PDBG("%s ep %p tid %u status %d\n", __func__, ep, ep->hwtid, status);
854         memset(&event, 0, sizeof(event));
855         event.event = IW_CM_EVENT_CONNECT_REPLY;
856         event.status = status;
857         event.local_addr = ep->com.local_addr;
858         event.remote_addr = ep->com.remote_addr;
859
860         if ((status == 0) || (status == -ECONNREFUSED)) {
861                 if (!ep->tried_with_mpa_v1) {
862                         /* this means MPA_v2 is used */
863                         event.private_data_len = ep->plen -
864                                 sizeof(struct mpa_v2_conn_params);
865                         event.private_data = ep->mpa_pkt +
866                                 sizeof(struct mpa_message) +
867                                 sizeof(struct mpa_v2_conn_params);
868                 } else {
869                         /* this means MPA_v1 is used */
870                         event.private_data_len = ep->plen;
871                         event.private_data = ep->mpa_pkt +
872                                 sizeof(struct mpa_message);
873                 }
874         }
875
876         PDBG("%s ep %p tid %u status %d\n", __func__, ep,
877              ep->hwtid, status);
878         ep->com.cm_id->event_handler(ep->com.cm_id, &event);
879
880         if (status < 0) {
881                 ep->com.cm_id->rem_ref(ep->com.cm_id);
882                 ep->com.cm_id = NULL;
883                 ep->com.qp = NULL;
884         }
885 }
886
887 static void connect_request_upcall(struct c4iw_ep *ep)
888 {
889         struct iw_cm_event event;
890
891         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
892         memset(&event, 0, sizeof(event));
893         event.event = IW_CM_EVENT_CONNECT_REQUEST;
894         event.local_addr = ep->com.local_addr;
895         event.remote_addr = ep->com.remote_addr;
896         event.provider_data = ep;
897         if (!ep->tried_with_mpa_v1) {
898                 /* this means MPA_v2 is used */
899                 event.ord = ep->ord;
900                 event.ird = ep->ird;
901                 event.private_data_len = ep->plen -
902                         sizeof(struct mpa_v2_conn_params);
903                 event.private_data = ep->mpa_pkt + sizeof(struct mpa_message) +
904                         sizeof(struct mpa_v2_conn_params);
905         } else {
906                 /* this means MPA_v1 is used. Send max supported */
907                 event.ord = c4iw_max_read_depth;
908                 event.ird = c4iw_max_read_depth;
909                 event.private_data_len = ep->plen;
910                 event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
911         }
912         if (state_read(&ep->parent_ep->com) != DEAD) {
913                 c4iw_get_ep(&ep->com);
914                 ep->parent_ep->com.cm_id->event_handler(
915                                                 ep->parent_ep->com.cm_id,
916                                                 &event);
917         }
918         c4iw_put_ep(&ep->parent_ep->com);
919         ep->parent_ep = NULL;
920 }
921
922 static void established_upcall(struct c4iw_ep *ep)
923 {
924         struct iw_cm_event event;
925
926         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
927         memset(&event, 0, sizeof(event));
928         event.event = IW_CM_EVENT_ESTABLISHED;
929         event.ird = ep->ird;
930         event.ord = ep->ord;
931         if (ep->com.cm_id) {
932                 PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
933                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
934         }
935 }
936
937 static int update_rx_credits(struct c4iw_ep *ep, u32 credits)
938 {
939         struct cpl_rx_data_ack *req;
940         struct sk_buff *skb;
941         int wrlen = roundup(sizeof *req, 16);
942
943         PDBG("%s ep %p tid %u credits %u\n", __func__, ep, ep->hwtid, credits);
944         skb = get_skb(NULL, wrlen, GFP_KERNEL);
945         if (!skb) {
946                 printk(KERN_ERR MOD "update_rx_credits - cannot alloc skb!\n");
947                 return 0;
948         }
949
950         req = (struct cpl_rx_data_ack *) skb_put(skb, wrlen);
951         memset(req, 0, wrlen);
952         INIT_TP_WR(req, ep->hwtid);
953         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_RX_DATA_ACK,
954                                                     ep->hwtid));
955         req->credit_dack = cpu_to_be32(credits | RX_FORCE_ACK(1) |
956                                        F_RX_DACK_CHANGE |
957                                        V_RX_DACK_MODE(dack_mode));
958         set_wr_txq(skb, CPL_PRIORITY_ACK, ep->ctrlq_idx);
959         c4iw_ofld_send(&ep->com.dev->rdev, skb);
960         return credits;
961 }
962
963 static void process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
964 {
965         struct mpa_message *mpa;
966         struct mpa_v2_conn_params *mpa_v2_params;
967         u16 plen;
968         u16 resp_ird, resp_ord;
969         u8 rtr_mismatch = 0, insuff_ird = 0;
970         struct c4iw_qp_attributes attrs;
971         enum c4iw_qp_attr_mask mask;
972         int err;
973
974         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
975
976         /*
977          * Stop mpa timer.  If it expired, then the state has
978          * changed and we bail since ep_timeout already aborted
979          * the connection.
980          */
981         stop_ep_timer(ep);
982         if (state_read(&ep->com) != MPA_REQ_SENT)
983                 return;
984
985         /*
986          * If we get more than the supported amount of private data
987          * then we must fail this connection.
988          */
989         if (ep->mpa_pkt_len + skb->len > sizeof(ep->mpa_pkt)) {
990                 err = -EINVAL;
991                 goto err;
992         }
993
994         /*
995          * copy the new data into our accumulation buffer.
996          */
997         skb_copy_from_linear_data(skb, &(ep->mpa_pkt[ep->mpa_pkt_len]),
998                                   skb->len);
999         ep->mpa_pkt_len += skb->len;
1000
1001         /*
1002          * if we don't even have the mpa message, then bail.
1003          */
1004         if (ep->mpa_pkt_len < sizeof(*mpa))
1005                 return;
1006         mpa = (struct mpa_message *) ep->mpa_pkt;
1007
1008         /* Validate MPA header. */
1009         if (mpa->revision > mpa_rev) {
1010                 printk(KERN_ERR MOD "%s MPA version mismatch. Local = %d,"
1011                        " Received = %d\n", __func__, mpa_rev, mpa->revision);
1012                 err = -EPROTO;
1013                 goto err;
1014         }
1015         if (memcmp(mpa->key, MPA_KEY_REP, sizeof(mpa->key))) {
1016                 err = -EPROTO;
1017                 goto err;
1018         }
1019
1020         plen = ntohs(mpa->private_data_size);
1021
1022         /*
1023          * Fail if there's too much private data.
1024          */
1025         if (plen > MPA_MAX_PRIVATE_DATA) {
1026                 err = -EPROTO;
1027                 goto err;
1028         }
1029
1030         /*
1031          * If plen does not account for pkt size
1032          */
1033         if (ep->mpa_pkt_len > (sizeof(*mpa) + plen)) {
1034                 err = -EPROTO;
1035                 goto err;
1036         }
1037
1038         ep->plen = (u8) plen;
1039
1040         /*
1041          * If we don't have all the pdata yet, then bail.
1042          * We'll continue process when more data arrives.
1043          */
1044         if (ep->mpa_pkt_len < (sizeof(*mpa) + plen))
1045                 return;
1046
1047         if (mpa->flags & MPA_REJECT) {
1048                 err = -ECONNREFUSED;
1049                 goto err;
1050         }
1051
1052         /*
1053          * If we get here we have accumulated the entire mpa
1054          * start reply message including private data. And
1055          * the MPA header is valid.
1056          */
1057         state_set(&ep->com, FPDU_MODE);
1058         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
1059         ep->mpa_attr.recv_marker_enabled = markers_enabled;
1060         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
1061         ep->mpa_attr.version = mpa->revision;
1062         ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
1063
1064         if (mpa->revision == 2) {
1065                 ep->mpa_attr.enhanced_rdma_conn =
1066                         mpa->flags & MPA_ENHANCED_RDMA_CONN ? 1 : 0;
1067                 if (ep->mpa_attr.enhanced_rdma_conn) {
1068                         mpa_v2_params = (struct mpa_v2_conn_params *)
1069                                 (ep->mpa_pkt + sizeof(*mpa));
1070                         resp_ird = ntohs(mpa_v2_params->ird) &
1071                                 MPA_V2_IRD_ORD_MASK;
1072                         resp_ord = ntohs(mpa_v2_params->ord) &
1073                                 MPA_V2_IRD_ORD_MASK;
1074
1075                         /*
1076                          * This is a double-check. Ideally, below checks are
1077                          * not required since ird/ord stuff has been taken
1078                          * care of in c4iw_accept_cr
1079                          */
1080                         if ((ep->ird < resp_ord) || (ep->ord > resp_ird)) {
1081                                 err = -ENOMEM;
1082                                 ep->ird = resp_ord;
1083                                 ep->ord = resp_ird;
1084                                 insuff_ird = 1;
1085                         }
1086
1087                         if (ntohs(mpa_v2_params->ird) &
1088                                         MPA_V2_PEER2PEER_MODEL) {
1089                                 if (ntohs(mpa_v2_params->ord) &
1090                                                 MPA_V2_RDMA_WRITE_RTR)
1091                                         ep->mpa_attr.p2p_type =
1092                                                 FW_RI_INIT_P2PTYPE_RDMA_WRITE;
1093                                 else if (ntohs(mpa_v2_params->ord) &
1094                                                 MPA_V2_RDMA_READ_RTR)
1095                                         ep->mpa_attr.p2p_type =
1096                                                 FW_RI_INIT_P2PTYPE_READ_REQ;
1097                         }
1098                 }
1099         } else if (mpa->revision == 1)
1100                 if (peer2peer)
1101                         ep->mpa_attr.p2p_type = p2p_type;
1102
1103         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
1104              "xmit_marker_enabled=%d, version=%d p2p_type=%d local-p2p_type = "
1105              "%d\n", __func__, ep->mpa_attr.crc_enabled,
1106              ep->mpa_attr.recv_marker_enabled,
1107              ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version,
1108              ep->mpa_attr.p2p_type, p2p_type);
1109
1110         /*
1111          * If responder's RTR does not match with that of initiator, assign
1112          * FW_RI_INIT_P2PTYPE_DISABLED in mpa attributes so that RTR is not
1113          * generated when moving QP to RTS state.
1114          * A TERM message will be sent after QP has moved to RTS state
1115          */
1116         if ((ep->mpa_attr.version == 2) && peer2peer &&
1117                         (ep->mpa_attr.p2p_type != p2p_type)) {
1118                 ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
1119                 rtr_mismatch = 1;
1120         }
1121
1122         attrs.mpa_attr = ep->mpa_attr;
1123         attrs.max_ird = ep->ird;
1124         attrs.max_ord = ep->ord;
1125         attrs.llp_stream_handle = ep;
1126         attrs.next_state = C4IW_QP_STATE_RTS;
1127
1128         mask = C4IW_QP_ATTR_NEXT_STATE |
1129             C4IW_QP_ATTR_LLP_STREAM_HANDLE | C4IW_QP_ATTR_MPA_ATTR |
1130             C4IW_QP_ATTR_MAX_IRD | C4IW_QP_ATTR_MAX_ORD;
1131
1132         /* bind QP and TID with INIT_WR */
1133         err = c4iw_modify_qp(ep->com.qp->rhp,
1134                              ep->com.qp, mask, &attrs, 1);
1135         if (err)
1136                 goto err;
1137
1138         /*
1139          * If responder's RTR requirement did not match with what initiator
1140          * supports, generate TERM message
1141          */
1142         if (rtr_mismatch) {
1143                 printk(KERN_ERR "%s: RTR mismatch, sending TERM\n", __func__);
1144                 attrs.layer_etype = LAYER_MPA | DDP_LLP;
1145                 attrs.ecode = MPA_NOMATCH_RTR;
1146                 attrs.next_state = C4IW_QP_STATE_TERMINATE;
1147                 err = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
1148                                 C4IW_QP_ATTR_NEXT_STATE, &attrs, 0);
1149                 err = -ENOMEM;
1150                 goto out;
1151         }
1152
1153         /*
1154          * Generate TERM if initiator IRD is not sufficient for responder
1155          * provided ORD. Currently, we do the same behaviour even when
1156          * responder provided IRD is also not sufficient as regards to
1157          * initiator ORD.
1158          */
1159         if (insuff_ird) {
1160                 printk(KERN_ERR "%s: Insufficient IRD, sending TERM\n",
1161                                 __func__);
1162                 attrs.layer_etype = LAYER_MPA | DDP_LLP;
1163                 attrs.ecode = MPA_INSUFF_IRD;
1164                 attrs.next_state = C4IW_QP_STATE_TERMINATE;
1165                 err = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
1166                                 C4IW_QP_ATTR_NEXT_STATE, &attrs, 0);
1167                 err = -ENOMEM;
1168                 goto out;
1169         }
1170         goto out;
1171 err:
1172         state_set(&ep->com, ABORTING);
1173         send_abort(ep, skb, GFP_KERNEL);
1174 out:
1175         connect_reply_upcall(ep, err);
1176         return;
1177 }
1178
1179 static void process_mpa_request(struct c4iw_ep *ep, struct sk_buff *skb)
1180 {
1181         struct mpa_message *mpa;
1182         struct mpa_v2_conn_params *mpa_v2_params;
1183         u16 plen;
1184
1185         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1186
1187         if (state_read(&ep->com) != MPA_REQ_WAIT)
1188                 return;
1189
1190         /*
1191          * If we get more than the supported amount of private data
1192          * then we must fail this connection.
1193          */
1194         if (ep->mpa_pkt_len + skb->len > sizeof(ep->mpa_pkt)) {
1195                 stop_ep_timer(ep);
1196                 abort_connection(ep, skb, GFP_KERNEL);
1197                 return;
1198         }
1199
1200         PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
1201
1202         /*
1203          * Copy the new data into our accumulation buffer.
1204          */
1205         skb_copy_from_linear_data(skb, &(ep->mpa_pkt[ep->mpa_pkt_len]),
1206                                   skb->len);
1207         ep->mpa_pkt_len += skb->len;
1208
1209         /*
1210          * If we don't even have the mpa message, then bail.
1211          * We'll continue process when more data arrives.
1212          */
1213         if (ep->mpa_pkt_len < sizeof(*mpa))
1214                 return;
1215
1216         PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
1217         stop_ep_timer(ep);
1218         mpa = (struct mpa_message *) ep->mpa_pkt;
1219
1220         /*
1221          * Validate MPA Header.
1222          */
1223         if (mpa->revision > mpa_rev) {
1224                 printk(KERN_ERR MOD "%s MPA version mismatch. Local = %d,"
1225                        " Received = %d\n", __func__, mpa_rev, mpa->revision);
1226                 abort_connection(ep, skb, GFP_KERNEL);
1227                 return;
1228         }
1229
1230         if (memcmp(mpa->key, MPA_KEY_REQ, sizeof(mpa->key))) {
1231                 abort_connection(ep, skb, GFP_KERNEL);
1232                 return;
1233         }
1234
1235         plen = ntohs(mpa->private_data_size);
1236
1237         /*
1238          * Fail if there's too much private data.
1239          */
1240         if (plen > MPA_MAX_PRIVATE_DATA) {
1241                 abort_connection(ep, skb, GFP_KERNEL);
1242                 return;
1243         }
1244
1245         /*
1246          * If plen does not account for pkt size
1247          */
1248         if (ep->mpa_pkt_len > (sizeof(*mpa) + plen)) {
1249                 abort_connection(ep, skb, GFP_KERNEL);
1250                 return;
1251         }
1252         ep->plen = (u8) plen;
1253
1254         /*
1255          * If we don't have all the pdata yet, then bail.
1256          */
1257         if (ep->mpa_pkt_len < (sizeof(*mpa) + plen))
1258                 return;
1259
1260         /*
1261          * If we get here we have accumulated the entire mpa
1262          * start reply message including private data.
1263          */
1264         ep->mpa_attr.initiator = 0;
1265         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
1266         ep->mpa_attr.recv_marker_enabled = markers_enabled;
1267         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
1268         ep->mpa_attr.version = mpa->revision;
1269         if (mpa->revision == 1)
1270                 ep->tried_with_mpa_v1 = 1;
1271         ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
1272
1273         if (mpa->revision == 2) {
1274                 ep->mpa_attr.enhanced_rdma_conn =
1275                         mpa->flags & MPA_ENHANCED_RDMA_CONN ? 1 : 0;
1276                 if (ep->mpa_attr.enhanced_rdma_conn) {
1277                         mpa_v2_params = (struct mpa_v2_conn_params *)
1278                                 (ep->mpa_pkt + sizeof(*mpa));
1279                         ep->ird = ntohs(mpa_v2_params->ird) &
1280                                 MPA_V2_IRD_ORD_MASK;
1281                         ep->ord = ntohs(mpa_v2_params->ord) &
1282                                 MPA_V2_IRD_ORD_MASK;
1283                         if (ntohs(mpa_v2_params->ird) & MPA_V2_PEER2PEER_MODEL)
1284                                 if (peer2peer) {
1285                                         if (ntohs(mpa_v2_params->ord) &
1286                                                         MPA_V2_RDMA_WRITE_RTR)
1287                                                 ep->mpa_attr.p2p_type =
1288                                                 FW_RI_INIT_P2PTYPE_RDMA_WRITE;
1289                                         else if (ntohs(mpa_v2_params->ord) &
1290                                                         MPA_V2_RDMA_READ_RTR)
1291                                                 ep->mpa_attr.p2p_type =
1292                                                 FW_RI_INIT_P2PTYPE_READ_REQ;
1293                                 }
1294                 }
1295         } else if (mpa->revision == 1)
1296                 if (peer2peer)
1297                         ep->mpa_attr.p2p_type = p2p_type;
1298
1299         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
1300              "xmit_marker_enabled=%d, version=%d p2p_type=%d\n", __func__,
1301              ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
1302              ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version,
1303              ep->mpa_attr.p2p_type);
1304
1305         state_set(&ep->com, MPA_REQ_RCVD);
1306
1307         /* drive upcall */
1308         connect_request_upcall(ep);
1309         return;
1310 }
1311
1312 static int rx_data(struct c4iw_dev *dev, struct sk_buff *skb)
1313 {
1314         struct c4iw_ep *ep;
1315         struct cpl_rx_data *hdr = cplhdr(skb);
1316         unsigned int dlen = ntohs(hdr->len);
1317         unsigned int tid = GET_TID(hdr);
1318         struct tid_info *t = dev->rdev.lldi.tids;
1319
1320         ep = lookup_tid(t, tid);
1321         PDBG("%s ep %p tid %u dlen %u\n", __func__, ep, ep->hwtid, dlen);
1322         skb_pull(skb, sizeof(*hdr));
1323         skb_trim(skb, dlen);
1324
1325         ep->rcv_seq += dlen;
1326         BUG_ON(ep->rcv_seq != (ntohl(hdr->seq) + dlen));
1327
1328         /* update RX credits */
1329         update_rx_credits(ep, dlen);
1330
1331         switch (state_read(&ep->com)) {
1332         case MPA_REQ_SENT:
1333                 process_mpa_reply(ep, skb);
1334                 break;
1335         case MPA_REQ_WAIT:
1336                 process_mpa_request(ep, skb);
1337                 break;
1338         case MPA_REP_SENT:
1339                 break;
1340         default:
1341                 printk(KERN_ERR MOD "%s Unexpected streaming data."
1342                        " ep %p state %d tid %u\n",
1343                        __func__, ep, state_read(&ep->com), ep->hwtid);
1344
1345                 /*
1346                  * The ep will timeout and inform the ULP of the failure.
1347                  * See ep_timeout().
1348                  */
1349                 break;
1350         }
1351         return 0;
1352 }
1353
1354 static int abort_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
1355 {
1356         struct c4iw_ep *ep;
1357         struct cpl_abort_rpl_rss *rpl = cplhdr(skb);
1358         int release = 0;
1359         unsigned int tid = GET_TID(rpl);
1360         struct tid_info *t = dev->rdev.lldi.tids;
1361
1362         ep = lookup_tid(t, tid);
1363         if (!ep) {
1364                 printk(KERN_WARNING MOD "Abort rpl to freed endpoint\n");
1365                 return 0;
1366         }
1367         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1368         mutex_lock(&ep->com.mutex);
1369         switch (ep->com.state) {
1370         case ABORTING:
1371                 __state_set(&ep->com, DEAD);
1372                 release = 1;
1373                 break;
1374         default:
1375                 printk(KERN_ERR "%s ep %p state %d\n",
1376                      __func__, ep, ep->com.state);
1377                 break;
1378         }
1379         mutex_unlock(&ep->com.mutex);
1380
1381         if (release)
1382                 release_ep_resources(ep);
1383         return 0;
1384 }
1385
1386 /*
1387  * Return whether a failed active open has allocated a TID
1388  */
1389 static inline int act_open_has_tid(int status)
1390 {
1391         return status != CPL_ERR_TCAM_FULL && status != CPL_ERR_CONN_EXIST &&
1392                status != CPL_ERR_ARP_MISS;
1393 }
1394
1395 static int act_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
1396 {
1397         struct c4iw_ep *ep;
1398         struct cpl_act_open_rpl *rpl = cplhdr(skb);
1399         unsigned int atid = GET_TID_TID(GET_AOPEN_ATID(
1400                                         ntohl(rpl->atid_status)));
1401         struct tid_info *t = dev->rdev.lldi.tids;
1402         int status = GET_AOPEN_STATUS(ntohl(rpl->atid_status));
1403
1404         ep = lookup_atid(t, atid);
1405
1406         PDBG("%s ep %p atid %u status %u errno %d\n", __func__, ep, atid,
1407              status, status2errno(status));
1408
1409         if (status == CPL_ERR_RTX_NEG_ADVICE) {
1410                 printk(KERN_WARNING MOD "Connection problems for atid %u\n",
1411                         atid);
1412                 return 0;
1413         }
1414
1415         /*
1416          * Log interesting failures.
1417          */
1418         switch (status) {
1419         case CPL_ERR_CONN_RESET:
1420         case CPL_ERR_CONN_TIMEDOUT:
1421                 break;
1422         default:
1423                 printk(KERN_INFO MOD "Active open failure - "
1424                        "atid %u status %u errno %d %pI4:%u->%pI4:%u\n",
1425                        atid, status, status2errno(status),
1426                        &ep->com.local_addr.sin_addr.s_addr,
1427                        ntohs(ep->com.local_addr.sin_port),
1428                        &ep->com.remote_addr.sin_addr.s_addr,
1429                        ntohs(ep->com.remote_addr.sin_port));
1430                 break;
1431         }
1432
1433         connect_reply_upcall(ep, status2errno(status));
1434         state_set(&ep->com, DEAD);
1435
1436         if (status && act_open_has_tid(status))
1437                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, GET_TID(rpl));
1438
1439         cxgb4_free_atid(t, atid);
1440         dst_release(ep->dst);
1441         cxgb4_l2t_release(ep->l2t);
1442         c4iw_put_ep(&ep->com);
1443
1444         return 0;
1445 }
1446
1447 static int pass_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
1448 {
1449         struct cpl_pass_open_rpl *rpl = cplhdr(skb);
1450         struct tid_info *t = dev->rdev.lldi.tids;
1451         unsigned int stid = GET_TID(rpl);
1452         struct c4iw_listen_ep *ep = lookup_stid(t, stid);
1453
1454         if (!ep) {
1455                 printk(KERN_ERR MOD "stid %d lookup failure!\n", stid);
1456                 return 0;
1457         }
1458         PDBG("%s ep %p status %d error %d\n", __func__, ep,
1459              rpl->status, status2errno(rpl->status));
1460         c4iw_wake_up(&ep->com.wr_wait, status2errno(rpl->status));
1461
1462         return 0;
1463 }
1464
1465 static int listen_stop(struct c4iw_listen_ep *ep)
1466 {
1467         struct sk_buff *skb;
1468         struct cpl_close_listsvr_req *req;
1469
1470         PDBG("%s ep %p\n", __func__, ep);
1471         skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
1472         if (!skb) {
1473                 printk(KERN_ERR MOD "%s - failed to alloc skb\n", __func__);
1474                 return -ENOMEM;
1475         }
1476         req = (struct cpl_close_listsvr_req *) skb_put(skb, sizeof(*req));
1477         INIT_TP_WR(req, 0);
1478         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_CLOSE_LISTSRV_REQ,
1479                                                     ep->stid));
1480         req->reply_ctrl = cpu_to_be16(
1481                           QUEUENO(ep->com.dev->rdev.lldi.rxq_ids[0]));
1482         set_wr_txq(skb, CPL_PRIORITY_SETUP, 0);
1483         return c4iw_ofld_send(&ep->com.dev->rdev, skb);
1484 }
1485
1486 static int close_listsrv_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
1487 {
1488         struct cpl_close_listsvr_rpl *rpl = cplhdr(skb);
1489         struct tid_info *t = dev->rdev.lldi.tids;
1490         unsigned int stid = GET_TID(rpl);
1491         struct c4iw_listen_ep *ep = lookup_stid(t, stid);
1492
1493         PDBG("%s ep %p\n", __func__, ep);
1494         c4iw_wake_up(&ep->com.wr_wait, status2errno(rpl->status));
1495         return 0;
1496 }
1497
1498 static void accept_cr(struct c4iw_ep *ep, __be32 peer_ip, struct sk_buff *skb,
1499                       struct cpl_pass_accept_req *req)
1500 {
1501         struct cpl_pass_accept_rpl *rpl;
1502         unsigned int mtu_idx;
1503         u64 opt0;
1504         u32 opt2;
1505         int wscale;
1506
1507         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1508         BUG_ON(skb_cloned(skb));
1509         skb_trim(skb, sizeof(*rpl));
1510         skb_get(skb);
1511         cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
1512         wscale = compute_wscale(rcv_win);
1513         opt0 = KEEP_ALIVE(1) |
1514                DELACK(1) |
1515                WND_SCALE(wscale) |
1516                MSS_IDX(mtu_idx) |
1517                L2T_IDX(ep->l2t->idx) |
1518                TX_CHAN(ep->tx_chan) |
1519                SMAC_SEL(ep->smac_idx) |
1520                DSCP(ep->tos) |
1521                ULP_MODE(ULP_MODE_TCPDDP) |
1522                RCV_BUFSIZ(rcv_win>>10);
1523         opt2 = RX_CHANNEL(0) |
1524                RSS_QUEUE_VALID | RSS_QUEUE(ep->rss_qid);
1525
1526         if (enable_tcp_timestamps && req->tcpopt.tstamp)
1527                 opt2 |= TSTAMPS_EN(1);
1528         if (enable_tcp_sack && req->tcpopt.sack)
1529                 opt2 |= SACK_EN(1);
1530         if (wscale && enable_tcp_window_scaling)
1531                 opt2 |= WND_SCALE_EN(1);
1532
1533         rpl = cplhdr(skb);
1534         INIT_TP_WR(rpl, ep->hwtid);
1535         OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_PASS_ACCEPT_RPL,
1536                                       ep->hwtid));
1537         rpl->opt0 = cpu_to_be64(opt0);
1538         rpl->opt2 = cpu_to_be32(opt2);
1539         set_wr_txq(skb, CPL_PRIORITY_SETUP, ep->ctrlq_idx);
1540         c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
1541
1542         return;
1543 }
1544
1545 static void reject_cr(struct c4iw_dev *dev, u32 hwtid, __be32 peer_ip,
1546                       struct sk_buff *skb)
1547 {
1548         PDBG("%s c4iw_dev %p tid %u peer_ip %x\n", __func__, dev, hwtid,
1549              peer_ip);
1550         BUG_ON(skb_cloned(skb));
1551         skb_trim(skb, sizeof(struct cpl_tid_release));
1552         skb_get(skb);
1553         release_tid(&dev->rdev, hwtid, skb);
1554         return;
1555 }
1556
1557 static void get_4tuple(struct cpl_pass_accept_req *req,
1558                        __be32 *local_ip, __be32 *peer_ip,
1559                        __be16 *local_port, __be16 *peer_port)
1560 {
1561         int eth_len = G_ETH_HDR_LEN(be32_to_cpu(req->hdr_len));
1562         int ip_len = G_IP_HDR_LEN(be32_to_cpu(req->hdr_len));
1563         struct iphdr *ip = (struct iphdr *)((u8 *)(req + 1) + eth_len);
1564         struct tcphdr *tcp = (struct tcphdr *)
1565                              ((u8 *)(req + 1) + eth_len + ip_len);
1566
1567         PDBG("%s saddr 0x%x daddr 0x%x sport %u dport %u\n", __func__,
1568              ntohl(ip->saddr), ntohl(ip->daddr), ntohs(tcp->source),
1569              ntohs(tcp->dest));
1570
1571         *peer_ip = ip->saddr;
1572         *local_ip = ip->daddr;
1573         *peer_port = tcp->source;
1574         *local_port = tcp->dest;
1575
1576         return;
1577 }
1578
1579 static int import_ep(struct c4iw_ep *ep, __be32 peer_ip, struct dst_entry *dst,
1580                      struct c4iw_dev *cdev, bool clear_mpa_v1)
1581 {
1582         struct neighbour *n;
1583         int err, step;
1584
1585         n = dst_neigh_lookup(dst, &peer_ip);
1586         if (!n)
1587                 return -ENODEV;
1588
1589         rcu_read_lock();
1590         err = -ENOMEM;
1591         if (n->dev->flags & IFF_LOOPBACK) {
1592                 struct net_device *pdev;
1593
1594                 pdev = ip_dev_find(&init_net, peer_ip);
1595                 if (!pdev) {
1596                         err = -ENODEV;
1597                         goto out;
1598                 }
1599                 ep->l2t = cxgb4_l2t_get(cdev->rdev.lldi.l2t,
1600                                         n, pdev, 0);
1601                 if (!ep->l2t)
1602                         goto out;
1603                 ep->mtu = pdev->mtu;
1604                 ep->tx_chan = cxgb4_port_chan(pdev);
1605                 ep->smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1;
1606                 step = cdev->rdev.lldi.ntxq /
1607                         cdev->rdev.lldi.nchan;
1608                 ep->txq_idx = cxgb4_port_idx(pdev) * step;
1609                 step = cdev->rdev.lldi.nrxq /
1610                         cdev->rdev.lldi.nchan;
1611                 ep->ctrlq_idx = cxgb4_port_idx(pdev);
1612                 ep->rss_qid = cdev->rdev.lldi.rxq_ids[
1613                         cxgb4_port_idx(pdev) * step];
1614                 dev_put(pdev);
1615         } else {
1616                 ep->l2t = cxgb4_l2t_get(cdev->rdev.lldi.l2t,
1617                                         n, n->dev, 0);
1618                 if (!ep->l2t)
1619                         goto out;
1620                 ep->mtu = dst_mtu(dst);
1621                 ep->tx_chan = cxgb4_port_chan(n->dev);
1622                 ep->smac_idx = (cxgb4_port_viid(n->dev) & 0x7F) << 1;
1623                 step = cdev->rdev.lldi.ntxq /
1624                         cdev->rdev.lldi.nchan;
1625                 ep->txq_idx = cxgb4_port_idx(n->dev) * step;
1626                 ep->ctrlq_idx = cxgb4_port_idx(n->dev);
1627                 step = cdev->rdev.lldi.nrxq /
1628                         cdev->rdev.lldi.nchan;
1629                 ep->rss_qid = cdev->rdev.lldi.rxq_ids[
1630                         cxgb4_port_idx(n->dev) * step];
1631
1632                 if (clear_mpa_v1) {
1633                         ep->retry_with_mpa_v1 = 0;
1634                         ep->tried_with_mpa_v1 = 0;
1635                 }
1636         }
1637         err = 0;
1638 out:
1639         rcu_read_unlock();
1640
1641         neigh_release(n);
1642
1643         return err;
1644 }
1645
1646 static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb)
1647 {
1648         struct c4iw_ep *child_ep, *parent_ep;
1649         struct cpl_pass_accept_req *req = cplhdr(skb);
1650         unsigned int stid = GET_POPEN_TID(ntohl(req->tos_stid));
1651         struct tid_info *t = dev->rdev.lldi.tids;
1652         unsigned int hwtid = GET_TID(req);
1653         struct dst_entry *dst;
1654         struct rtable *rt;
1655         __be32 local_ip, peer_ip;
1656         __be16 local_port, peer_port;
1657         int err;
1658
1659         parent_ep = lookup_stid(t, stid);
1660         PDBG("%s parent ep %p tid %u\n", __func__, parent_ep, hwtid);
1661
1662         get_4tuple(req, &local_ip, &peer_ip, &local_port, &peer_port);
1663
1664         if (state_read(&parent_ep->com) != LISTEN) {
1665                 printk(KERN_ERR "%s - listening ep not in LISTEN\n",
1666                        __func__);
1667                 goto reject;
1668         }
1669
1670         /* Find output route */
1671         rt = find_route(dev, local_ip, peer_ip, local_port, peer_port,
1672                         GET_POPEN_TOS(ntohl(req->tos_stid)));
1673         if (!rt) {
1674                 printk(KERN_ERR MOD "%s - failed to find dst entry!\n",
1675                        __func__);
1676                 goto reject;
1677         }
1678         dst = &rt->dst;
1679
1680         child_ep = alloc_ep(sizeof(*child_ep), GFP_KERNEL);
1681         if (!child_ep) {
1682                 printk(KERN_ERR MOD "%s - failed to allocate ep entry!\n",
1683                        __func__);
1684                 dst_release(dst);
1685                 goto reject;
1686         }
1687
1688         err = import_ep(child_ep, peer_ip, dst, dev, false);
1689         if (err) {
1690                 printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
1691                        __func__);
1692                 dst_release(dst);
1693                 kfree(child_ep);
1694                 goto reject;
1695         }
1696
1697         state_set(&child_ep->com, CONNECTING);
1698         child_ep->com.dev = dev;
1699         child_ep->com.cm_id = NULL;
1700         child_ep->com.local_addr.sin_family = PF_INET;
1701         child_ep->com.local_addr.sin_port = local_port;
1702         child_ep->com.local_addr.sin_addr.s_addr = local_ip;
1703         child_ep->com.remote_addr.sin_family = PF_INET;
1704         child_ep->com.remote_addr.sin_port = peer_port;
1705         child_ep->com.remote_addr.sin_addr.s_addr = peer_ip;
1706         c4iw_get_ep(&parent_ep->com);
1707         child_ep->parent_ep = parent_ep;
1708         child_ep->tos = GET_POPEN_TOS(ntohl(req->tos_stid));
1709         child_ep->dst = dst;
1710         child_ep->hwtid = hwtid;
1711
1712         PDBG("%s tx_chan %u smac_idx %u rss_qid %u\n", __func__,
1713              child_ep->tx_chan, child_ep->smac_idx, child_ep->rss_qid);
1714
1715         init_timer(&child_ep->timer);
1716         cxgb4_insert_tid(t, child_ep, hwtid);
1717         accept_cr(child_ep, peer_ip, skb, req);
1718         goto out;
1719 reject:
1720         reject_cr(dev, hwtid, peer_ip, skb);
1721 out:
1722         return 0;
1723 }
1724
1725 static int pass_establish(struct c4iw_dev *dev, struct sk_buff *skb)
1726 {
1727         struct c4iw_ep *ep;
1728         struct cpl_pass_establish *req = cplhdr(skb);
1729         struct tid_info *t = dev->rdev.lldi.tids;
1730         unsigned int tid = GET_TID(req);
1731
1732         ep = lookup_tid(t, tid);
1733         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1734         ep->snd_seq = be32_to_cpu(req->snd_isn);
1735         ep->rcv_seq = be32_to_cpu(req->rcv_isn);
1736
1737         set_emss(ep, ntohs(req->tcp_opt));
1738
1739         dst_confirm(ep->dst);
1740         state_set(&ep->com, MPA_REQ_WAIT);
1741         start_ep_timer(ep);
1742         send_flowc(ep, skb);
1743
1744         return 0;
1745 }
1746
1747 static int peer_close(struct c4iw_dev *dev, struct sk_buff *skb)
1748 {
1749         struct cpl_peer_close *hdr = cplhdr(skb);
1750         struct c4iw_ep *ep;
1751         struct c4iw_qp_attributes attrs;
1752         int disconnect = 1;
1753         int release = 0;
1754         struct tid_info *t = dev->rdev.lldi.tids;
1755         unsigned int tid = GET_TID(hdr);
1756         int ret;
1757
1758         ep = lookup_tid(t, tid);
1759         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1760         dst_confirm(ep->dst);
1761
1762         mutex_lock(&ep->com.mutex);
1763         switch (ep->com.state) {
1764         case MPA_REQ_WAIT:
1765                 __state_set(&ep->com, CLOSING);
1766                 break;
1767         case MPA_REQ_SENT:
1768                 __state_set(&ep->com, CLOSING);
1769                 connect_reply_upcall(ep, -ECONNRESET);
1770                 break;
1771         case MPA_REQ_RCVD:
1772
1773                 /*
1774                  * We're gonna mark this puppy DEAD, but keep
1775                  * the reference on it until the ULP accepts or
1776                  * rejects the CR. Also wake up anyone waiting
1777                  * in rdma connection migration (see c4iw_accept_cr()).
1778                  */
1779                 __state_set(&ep->com, CLOSING);
1780                 PDBG("waking up ep %p tid %u\n", ep, ep->hwtid);
1781                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
1782                 break;
1783         case MPA_REP_SENT:
1784                 __state_set(&ep->com, CLOSING);
1785                 PDBG("waking up ep %p tid %u\n", ep, ep->hwtid);
1786                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
1787                 break;
1788         case FPDU_MODE:
1789                 start_ep_timer(ep);
1790                 __state_set(&ep->com, CLOSING);
1791                 attrs.next_state = C4IW_QP_STATE_CLOSING;
1792                 ret = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
1793                                        C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
1794                 if (ret != -ECONNRESET) {
1795                         peer_close_upcall(ep);
1796                         disconnect = 1;
1797                 }
1798                 break;
1799         case ABORTING:
1800                 disconnect = 0;
1801                 break;
1802         case CLOSING:
1803                 __state_set(&ep->com, MORIBUND);
1804                 disconnect = 0;
1805                 break;
1806         case MORIBUND:
1807                 stop_ep_timer(ep);
1808                 if (ep->com.cm_id && ep->com.qp) {
1809                         attrs.next_state = C4IW_QP_STATE_IDLE;
1810                         c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
1811                                        C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
1812                 }
1813                 close_complete_upcall(ep);
1814                 __state_set(&ep->com, DEAD);
1815                 release = 1;
1816                 disconnect = 0;
1817                 break;
1818         case DEAD:
1819                 disconnect = 0;
1820                 break;
1821         default:
1822                 BUG_ON(1);
1823         }
1824         mutex_unlock(&ep->com.mutex);
1825         if (disconnect)
1826                 c4iw_ep_disconnect(ep, 0, GFP_KERNEL);
1827         if (release)
1828                 release_ep_resources(ep);
1829         return 0;
1830 }
1831
1832 /*
1833  * Returns whether an ABORT_REQ_RSS message is a negative advice.
1834  */
1835 static int is_neg_adv_abort(unsigned int status)
1836 {
1837         return status == CPL_ERR_RTX_NEG_ADVICE ||
1838                status == CPL_ERR_PERSIST_NEG_ADVICE;
1839 }
1840
1841 static int c4iw_reconnect(struct c4iw_ep *ep)
1842 {
1843         struct rtable *rt;
1844         int err = 0;
1845
1846         PDBG("%s qp %p cm_id %p\n", __func__, ep->com.qp, ep->com.cm_id);
1847         init_timer(&ep->timer);
1848
1849         /*
1850          * Allocate an active TID to initiate a TCP connection.
1851          */
1852         ep->atid = cxgb4_alloc_atid(ep->com.dev->rdev.lldi.tids, ep);
1853         if (ep->atid == -1) {
1854                 printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __func__);
1855                 err = -ENOMEM;
1856                 goto fail2;
1857         }
1858
1859         /* find a route */
1860         rt = find_route(ep->com.dev,
1861                         ep->com.cm_id->local_addr.sin_addr.s_addr,
1862                         ep->com.cm_id->remote_addr.sin_addr.s_addr,
1863                         ep->com.cm_id->local_addr.sin_port,
1864                         ep->com.cm_id->remote_addr.sin_port, 0);
1865         if (!rt) {
1866                 printk(KERN_ERR MOD "%s - cannot find route.\n", __func__);
1867                 err = -EHOSTUNREACH;
1868                 goto fail3;
1869         }
1870         ep->dst = &rt->dst;
1871
1872         err = import_ep(ep, ep->com.cm_id->remote_addr.sin_addr.s_addr,
1873                         ep->dst, ep->com.dev, false);
1874         if (err) {
1875                 printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
1876                 goto fail4;
1877         }
1878
1879         PDBG("%s txq_idx %u tx_chan %u smac_idx %u rss_qid %u l2t_idx %u\n",
1880              __func__, ep->txq_idx, ep->tx_chan, ep->smac_idx, ep->rss_qid,
1881              ep->l2t->idx);
1882
1883         state_set(&ep->com, CONNECTING);
1884         ep->tos = 0;
1885
1886         /* send connect request to rnic */
1887         err = send_connect(ep);
1888         if (!err)
1889                 goto out;
1890
1891         cxgb4_l2t_release(ep->l2t);
1892 fail4:
1893         dst_release(ep->dst);
1894 fail3:
1895         cxgb4_free_atid(ep->com.dev->rdev.lldi.tids, ep->atid);
1896 fail2:
1897         /*
1898          * remember to send notification to upper layer.
1899          * We are in here so the upper layer is not aware that this is
1900          * re-connect attempt and so, upper layer is still waiting for
1901          * response of 1st connect request.
1902          */
1903         connect_reply_upcall(ep, -ECONNRESET);
1904         c4iw_put_ep(&ep->com);
1905 out:
1906         return err;
1907 }
1908
1909 static int peer_abort(struct c4iw_dev *dev, struct sk_buff *skb)
1910 {
1911         struct cpl_abort_req_rss *req = cplhdr(skb);
1912         struct c4iw_ep *ep;
1913         struct cpl_abort_rpl *rpl;
1914         struct sk_buff *rpl_skb;
1915         struct c4iw_qp_attributes attrs;
1916         int ret;
1917         int release = 0;
1918         struct tid_info *t = dev->rdev.lldi.tids;
1919         unsigned int tid = GET_TID(req);
1920
1921         ep = lookup_tid(t, tid);
1922         if (is_neg_adv_abort(req->status)) {
1923                 PDBG("%s neg_adv_abort ep %p tid %u\n", __func__, ep,
1924                      ep->hwtid);
1925                 return 0;
1926         }
1927         PDBG("%s ep %p tid %u state %u\n", __func__, ep, ep->hwtid,
1928              ep->com.state);
1929
1930         /*
1931          * Wake up any threads in rdma_init() or rdma_fini().
1932          * However, this is not needed if com state is just
1933          * MPA_REQ_SENT
1934          */
1935         if (ep->com.state != MPA_REQ_SENT)
1936                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
1937
1938         mutex_lock(&ep->com.mutex);
1939         switch (ep->com.state) {
1940         case CONNECTING:
1941                 break;
1942         case MPA_REQ_WAIT:
1943                 stop_ep_timer(ep);
1944                 break;
1945         case MPA_REQ_SENT:
1946                 stop_ep_timer(ep);
1947                 if (mpa_rev == 2 && ep->tried_with_mpa_v1)
1948                         connect_reply_upcall(ep, -ECONNRESET);
1949                 else {
1950                         /*
1951                          * we just don't send notification upwards because we
1952                          * want to retry with mpa_v1 without upper layers even
1953                          * knowing it.
1954                          *
1955                          * do some housekeeping so as to re-initiate the
1956                          * connection
1957                          */
1958                         PDBG("%s: mpa_rev=%d. Retrying with mpav1\n", __func__,
1959                              mpa_rev);
1960                         ep->retry_with_mpa_v1 = 1;
1961                 }
1962                 break;
1963         case MPA_REP_SENT:
1964                 break;
1965         case MPA_REQ_RCVD:
1966                 break;
1967         case MORIBUND:
1968         case CLOSING:
1969                 stop_ep_timer(ep);
1970                 /*FALLTHROUGH*/
1971         case FPDU_MODE:
1972                 if (ep->com.cm_id && ep->com.qp) {
1973                         attrs.next_state = C4IW_QP_STATE_ERROR;
1974                         ret = c4iw_modify_qp(ep->com.qp->rhp,
1975                                      ep->com.qp, C4IW_QP_ATTR_NEXT_STATE,
1976                                      &attrs, 1);
1977                         if (ret)
1978                                 printk(KERN_ERR MOD
1979                                        "%s - qp <- error failed!\n",
1980                                        __func__);
1981                 }
1982                 peer_abort_upcall(ep);
1983                 break;
1984         case ABORTING:
1985                 break;
1986         case DEAD:
1987                 PDBG("%s PEER_ABORT IN DEAD STATE!!!!\n", __func__);
1988                 mutex_unlock(&ep->com.mutex);
1989                 return 0;
1990         default:
1991                 BUG_ON(1);
1992                 break;
1993         }
1994         dst_confirm(ep->dst);
1995         if (ep->com.state != ABORTING) {
1996                 __state_set(&ep->com, DEAD);
1997                 /* we don't release if we want to retry with mpa_v1 */
1998                 if (!ep->retry_with_mpa_v1)
1999                         release = 1;
2000         }
2001         mutex_unlock(&ep->com.mutex);
2002
2003         rpl_skb = get_skb(skb, sizeof(*rpl), GFP_KERNEL);
2004         if (!rpl_skb) {
2005                 printk(KERN_ERR MOD "%s - cannot allocate skb!\n",
2006                        __func__);
2007                 release = 1;
2008                 goto out;
2009         }
2010         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
2011         rpl = (struct cpl_abort_rpl *) skb_put(rpl_skb, sizeof(*rpl));
2012         INIT_TP_WR(rpl, ep->hwtid);
2013         OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_RPL, ep->hwtid));
2014         rpl->cmd = CPL_ABORT_NO_RST;
2015         c4iw_ofld_send(&ep->com.dev->rdev, rpl_skb);
2016 out:
2017         if (release)
2018                 release_ep_resources(ep);
2019
2020         /* retry with mpa-v1 */
2021         if (ep && ep->retry_with_mpa_v1) {
2022                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, ep->hwtid);
2023                 dst_release(ep->dst);
2024                 cxgb4_l2t_release(ep->l2t);
2025                 c4iw_reconnect(ep);
2026         }
2027
2028         return 0;
2029 }
2030
2031 static int close_con_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
2032 {
2033         struct c4iw_ep *ep;
2034         struct c4iw_qp_attributes attrs;
2035         struct cpl_close_con_rpl *rpl = cplhdr(skb);
2036         int release = 0;
2037         struct tid_info *t = dev->rdev.lldi.tids;
2038         unsigned int tid = GET_TID(rpl);
2039
2040         ep = lookup_tid(t, tid);
2041
2042         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2043         BUG_ON(!ep);
2044
2045         /* The cm_id may be null if we failed to connect */
2046         mutex_lock(&ep->com.mutex);
2047         switch (ep->com.state) {
2048         case CLOSING:
2049                 __state_set(&ep->com, MORIBUND);
2050                 break;
2051         case MORIBUND:
2052                 stop_ep_timer(ep);
2053                 if ((ep->com.cm_id) && (ep->com.qp)) {
2054                         attrs.next_state = C4IW_QP_STATE_IDLE;
2055                         c4iw_modify_qp(ep->com.qp->rhp,
2056                                              ep->com.qp,
2057                                              C4IW_QP_ATTR_NEXT_STATE,
2058                                              &attrs, 1);
2059                 }
2060                 close_complete_upcall(ep);
2061                 __state_set(&ep->com, DEAD);
2062                 release = 1;
2063                 break;
2064         case ABORTING:
2065         case DEAD:
2066                 break;
2067         default:
2068                 BUG_ON(1);
2069                 break;
2070         }
2071         mutex_unlock(&ep->com.mutex);
2072         if (release)
2073                 release_ep_resources(ep);
2074         return 0;
2075 }
2076
2077 static int terminate(struct c4iw_dev *dev, struct sk_buff *skb)
2078 {
2079         struct cpl_rdma_terminate *rpl = cplhdr(skb);
2080         struct tid_info *t = dev->rdev.lldi.tids;
2081         unsigned int tid = GET_TID(rpl);
2082         struct c4iw_ep *ep;
2083         struct c4iw_qp_attributes attrs;
2084
2085         ep = lookup_tid(t, tid);
2086         BUG_ON(!ep);
2087
2088         if (ep && ep->com.qp) {
2089                 printk(KERN_WARNING MOD "TERM received tid %u qpid %u\n", tid,
2090                        ep->com.qp->wq.sq.qid);
2091                 attrs.next_state = C4IW_QP_STATE_TERMINATE;
2092                 c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
2093                                C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
2094         } else
2095                 printk(KERN_WARNING MOD "TERM received tid %u no ep/qp\n", tid);
2096
2097         return 0;
2098 }
2099
2100 /*
2101  * Upcall from the adapter indicating data has been transmitted.
2102  * For us its just the single MPA request or reply.  We can now free
2103  * the skb holding the mpa message.
2104  */
2105 static int fw4_ack(struct c4iw_dev *dev, struct sk_buff *skb)
2106 {
2107         struct c4iw_ep *ep;
2108         struct cpl_fw4_ack *hdr = cplhdr(skb);
2109         u8 credits = hdr->credits;
2110         unsigned int tid = GET_TID(hdr);
2111         struct tid_info *t = dev->rdev.lldi.tids;
2112
2113
2114         ep = lookup_tid(t, tid);
2115         PDBG("%s ep %p tid %u credits %u\n", __func__, ep, ep->hwtid, credits);
2116         if (credits == 0) {
2117                 PDBG("%s 0 credit ack ep %p tid %u state %u\n",
2118                      __func__, ep, ep->hwtid, state_read(&ep->com));
2119                 return 0;
2120         }
2121
2122         dst_confirm(ep->dst);
2123         if (ep->mpa_skb) {
2124                 PDBG("%s last streaming msg ack ep %p tid %u state %u "
2125                      "initiator %u freeing skb\n", __func__, ep, ep->hwtid,
2126                      state_read(&ep->com), ep->mpa_attr.initiator ? 1 : 0);
2127                 kfree_skb(ep->mpa_skb);
2128                 ep->mpa_skb = NULL;
2129         }
2130         return 0;
2131 }
2132
2133 int c4iw_reject_cr(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
2134 {
2135         int err;
2136         struct c4iw_ep *ep = to_ep(cm_id);
2137         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2138
2139         if (state_read(&ep->com) == DEAD) {
2140                 c4iw_put_ep(&ep->com);
2141                 return -ECONNRESET;
2142         }
2143         BUG_ON(state_read(&ep->com) != MPA_REQ_RCVD);
2144         if (mpa_rev == 0)
2145                 abort_connection(ep, NULL, GFP_KERNEL);
2146         else {
2147                 err = send_mpa_reject(ep, pdata, pdata_len);
2148                 err = c4iw_ep_disconnect(ep, 0, GFP_KERNEL);
2149         }
2150         c4iw_put_ep(&ep->com);
2151         return 0;
2152 }
2153
2154 int c4iw_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
2155 {
2156         int err;
2157         struct c4iw_qp_attributes attrs;
2158         enum c4iw_qp_attr_mask mask;
2159         struct c4iw_ep *ep = to_ep(cm_id);
2160         struct c4iw_dev *h = to_c4iw_dev(cm_id->device);
2161         struct c4iw_qp *qp = get_qhp(h, conn_param->qpn);
2162
2163         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2164         if (state_read(&ep->com) == DEAD) {
2165                 err = -ECONNRESET;
2166                 goto err;
2167         }
2168
2169         BUG_ON(state_read(&ep->com) != MPA_REQ_RCVD);
2170         BUG_ON(!qp);
2171
2172         if ((conn_param->ord > c4iw_max_read_depth) ||
2173             (conn_param->ird > c4iw_max_read_depth)) {
2174                 abort_connection(ep, NULL, GFP_KERNEL);
2175                 err = -EINVAL;
2176                 goto err;
2177         }
2178
2179         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
2180                 if (conn_param->ord > ep->ird) {
2181                         ep->ird = conn_param->ird;
2182                         ep->ord = conn_param->ord;
2183                         send_mpa_reject(ep, conn_param->private_data,
2184                                         conn_param->private_data_len);
2185                         abort_connection(ep, NULL, GFP_KERNEL);
2186                         err = -ENOMEM;
2187                         goto err;
2188                 }
2189                 if (conn_param->ird > ep->ord) {
2190                         if (!ep->ord)
2191                                 conn_param->ird = 1;
2192                         else {
2193                                 abort_connection(ep, NULL, GFP_KERNEL);
2194                                 err = -ENOMEM;
2195                                 goto err;
2196                         }
2197                 }
2198
2199         }
2200         ep->ird = conn_param->ird;
2201         ep->ord = conn_param->ord;
2202
2203         if (ep->mpa_attr.version != 2)
2204                 if (peer2peer && ep->ird == 0)
2205                         ep->ird = 1;
2206
2207         PDBG("%s %d ird %d ord %d\n", __func__, __LINE__, ep->ird, ep->ord);
2208
2209         cm_id->add_ref(cm_id);
2210         ep->com.cm_id = cm_id;
2211         ep->com.qp = qp;
2212
2213         /* bind QP to EP and move to RTS */
2214         attrs.mpa_attr = ep->mpa_attr;
2215         attrs.max_ird = ep->ird;
2216         attrs.max_ord = ep->ord;
2217         attrs.llp_stream_handle = ep;
2218         attrs.next_state = C4IW_QP_STATE_RTS;
2219
2220         /* bind QP and TID with INIT_WR */
2221         mask = C4IW_QP_ATTR_NEXT_STATE |
2222                              C4IW_QP_ATTR_LLP_STREAM_HANDLE |
2223                              C4IW_QP_ATTR_MPA_ATTR |
2224                              C4IW_QP_ATTR_MAX_IRD |
2225                              C4IW_QP_ATTR_MAX_ORD;
2226
2227         err = c4iw_modify_qp(ep->com.qp->rhp,
2228                              ep->com.qp, mask, &attrs, 1);
2229         if (err)
2230                 goto err1;
2231         err = send_mpa_reply(ep, conn_param->private_data,
2232                              conn_param->private_data_len);
2233         if (err)
2234                 goto err1;
2235
2236         state_set(&ep->com, FPDU_MODE);
2237         established_upcall(ep);
2238         c4iw_put_ep(&ep->com);
2239         return 0;
2240 err1:
2241         ep->com.cm_id = NULL;
2242         ep->com.qp = NULL;
2243         cm_id->rem_ref(cm_id);
2244 err:
2245         c4iw_put_ep(&ep->com);
2246         return err;
2247 }
2248
2249 int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
2250 {
2251         struct c4iw_dev *dev = to_c4iw_dev(cm_id->device);
2252         struct c4iw_ep *ep;
2253         struct rtable *rt;
2254         int err = 0;
2255
2256         if ((conn_param->ord > c4iw_max_read_depth) ||
2257             (conn_param->ird > c4iw_max_read_depth)) {
2258                 err = -EINVAL;
2259                 goto out;
2260         }
2261         ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
2262         if (!ep) {
2263                 printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
2264                 err = -ENOMEM;
2265                 goto out;
2266         }
2267         init_timer(&ep->timer);
2268         ep->plen = conn_param->private_data_len;
2269         if (ep->plen)
2270                 memcpy(ep->mpa_pkt + sizeof(struct mpa_message),
2271                        conn_param->private_data, ep->plen);
2272         ep->ird = conn_param->ird;
2273         ep->ord = conn_param->ord;
2274
2275         if (peer2peer && ep->ord == 0)
2276                 ep->ord = 1;
2277
2278         cm_id->add_ref(cm_id);
2279         ep->com.dev = dev;
2280         ep->com.cm_id = cm_id;
2281         ep->com.qp = get_qhp(dev, conn_param->qpn);
2282         BUG_ON(!ep->com.qp);
2283         PDBG("%s qpn 0x%x qp %p cm_id %p\n", __func__, conn_param->qpn,
2284              ep->com.qp, cm_id);
2285
2286         /*
2287          * Allocate an active TID to initiate a TCP connection.
2288          */
2289         ep->atid = cxgb4_alloc_atid(dev->rdev.lldi.tids, ep);
2290         if (ep->atid == -1) {
2291                 printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __func__);
2292                 err = -ENOMEM;
2293                 goto fail2;
2294         }
2295
2296         PDBG("%s saddr 0x%x sport 0x%x raddr 0x%x rport 0x%x\n", __func__,
2297              ntohl(cm_id->local_addr.sin_addr.s_addr),
2298              ntohs(cm_id->local_addr.sin_port),
2299              ntohl(cm_id->remote_addr.sin_addr.s_addr),
2300              ntohs(cm_id->remote_addr.sin_port));
2301
2302         /* find a route */
2303         rt = find_route(dev,
2304                         cm_id->local_addr.sin_addr.s_addr,
2305                         cm_id->remote_addr.sin_addr.s_addr,
2306                         cm_id->local_addr.sin_port,
2307                         cm_id->remote_addr.sin_port, 0);
2308         if (!rt) {
2309                 printk(KERN_ERR MOD "%s - cannot find route.\n", __func__);
2310                 err = -EHOSTUNREACH;
2311                 goto fail3;
2312         }
2313         ep->dst = &rt->dst;
2314
2315         err = import_ep(ep, cm_id->remote_addr.sin_addr.s_addr,
2316                         ep->dst, ep->com.dev, true);
2317         if (err) {
2318                 printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
2319                 goto fail4;
2320         }
2321
2322         PDBG("%s txq_idx %u tx_chan %u smac_idx %u rss_qid %u l2t_idx %u\n",
2323                 __func__, ep->txq_idx, ep->tx_chan, ep->smac_idx, ep->rss_qid,
2324                 ep->l2t->idx);
2325
2326         state_set(&ep->com, CONNECTING);
2327         ep->tos = 0;
2328         ep->com.local_addr = cm_id->local_addr;
2329         ep->com.remote_addr = cm_id->remote_addr;
2330
2331         /* send connect request to rnic */
2332         err = send_connect(ep);
2333         if (!err)
2334                 goto out;
2335
2336         cxgb4_l2t_release(ep->l2t);
2337 fail4:
2338         dst_release(ep->dst);
2339 fail3:
2340         cxgb4_free_atid(ep->com.dev->rdev.lldi.tids, ep->atid);
2341 fail2:
2342         cm_id->rem_ref(cm_id);
2343         c4iw_put_ep(&ep->com);
2344 out:
2345         return err;
2346 }
2347
2348 int c4iw_create_listen(struct iw_cm_id *cm_id, int backlog)
2349 {
2350         int err = 0;
2351         struct c4iw_dev *dev = to_c4iw_dev(cm_id->device);
2352         struct c4iw_listen_ep *ep;
2353
2354
2355         might_sleep();
2356
2357         ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
2358         if (!ep) {
2359                 printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
2360                 err = -ENOMEM;
2361                 goto fail1;
2362         }
2363         PDBG("%s ep %p\n", __func__, ep);
2364         cm_id->add_ref(cm_id);
2365         ep->com.cm_id = cm_id;
2366         ep->com.dev = dev;
2367         ep->backlog = backlog;
2368         ep->com.local_addr = cm_id->local_addr;
2369
2370         /*
2371          * Allocate a server TID.
2372          */
2373         ep->stid = cxgb4_alloc_stid(dev->rdev.lldi.tids, PF_INET, ep);
2374         if (ep->stid == -1) {
2375                 printk(KERN_ERR MOD "%s - cannot alloc stid.\n", __func__);
2376                 err = -ENOMEM;
2377                 goto fail2;
2378         }
2379
2380         state_set(&ep->com, LISTEN);
2381         c4iw_init_wr_wait(&ep->com.wr_wait);
2382         err = cxgb4_create_server(ep->com.dev->rdev.lldi.ports[0], ep->stid,
2383                                   ep->com.local_addr.sin_addr.s_addr,
2384                                   ep->com.local_addr.sin_port,
2385                                   ep->com.dev->rdev.lldi.rxq_ids[0]);
2386         if (err)
2387                 goto fail3;
2388
2389         /* wait for pass_open_rpl */
2390         err = c4iw_wait_for_reply(&ep->com.dev->rdev, &ep->com.wr_wait, 0, 0,
2391                                   __func__);
2392         if (!err) {
2393                 cm_id->provider_data = ep;
2394                 goto out;
2395         }
2396 fail3:
2397         cxgb4_free_stid(ep->com.dev->rdev.lldi.tids, ep->stid, PF_INET);
2398 fail2:
2399         cm_id->rem_ref(cm_id);
2400         c4iw_put_ep(&ep->com);
2401 fail1:
2402 out:
2403         return err;
2404 }
2405
2406 int c4iw_destroy_listen(struct iw_cm_id *cm_id)
2407 {
2408         int err;
2409         struct c4iw_listen_ep *ep = to_listen_ep(cm_id);
2410
2411         PDBG("%s ep %p\n", __func__, ep);
2412
2413         might_sleep();
2414         state_set(&ep->com, DEAD);
2415         c4iw_init_wr_wait(&ep->com.wr_wait);
2416         err = listen_stop(ep);
2417         if (err)
2418                 goto done;
2419         err = c4iw_wait_for_reply(&ep->com.dev->rdev, &ep->com.wr_wait, 0, 0,
2420                                   __func__);
2421         cxgb4_free_stid(ep->com.dev->rdev.lldi.tids, ep->stid, PF_INET);
2422 done:
2423         cm_id->rem_ref(cm_id);
2424         c4iw_put_ep(&ep->com);
2425         return err;
2426 }
2427
2428 int c4iw_ep_disconnect(struct c4iw_ep *ep, int abrupt, gfp_t gfp)
2429 {
2430         int ret = 0;
2431         int close = 0;
2432         int fatal = 0;
2433         struct c4iw_rdev *rdev;
2434
2435         mutex_lock(&ep->com.mutex);
2436
2437         PDBG("%s ep %p state %s, abrupt %d\n", __func__, ep,
2438              states[ep->com.state], abrupt);
2439
2440         rdev = &ep->com.dev->rdev;
2441         if (c4iw_fatal_error(rdev)) {
2442                 fatal = 1;
2443                 close_complete_upcall(ep);
2444                 ep->com.state = DEAD;
2445         }
2446         switch (ep->com.state) {
2447         case MPA_REQ_WAIT:
2448         case MPA_REQ_SENT:
2449         case MPA_REQ_RCVD:
2450         case MPA_REP_SENT:
2451         case FPDU_MODE:
2452                 close = 1;
2453                 if (abrupt)
2454                         ep->com.state = ABORTING;
2455                 else {
2456                         ep->com.state = CLOSING;
2457                         start_ep_timer(ep);
2458                 }
2459                 set_bit(CLOSE_SENT, &ep->com.flags);
2460                 break;
2461         case CLOSING:
2462                 if (!test_and_set_bit(CLOSE_SENT, &ep->com.flags)) {
2463                         close = 1;
2464                         if (abrupt) {
2465                                 stop_ep_timer(ep);
2466                                 ep->com.state = ABORTING;
2467                         } else
2468                                 ep->com.state = MORIBUND;
2469                 }
2470                 break;
2471         case MORIBUND:
2472         case ABORTING:
2473         case DEAD:
2474                 PDBG("%s ignoring disconnect ep %p state %u\n",
2475                      __func__, ep, ep->com.state);
2476                 break;
2477         default:
2478                 BUG();
2479                 break;
2480         }
2481
2482         if (close) {
2483                 if (abrupt) {
2484                         close_complete_upcall(ep);
2485                         ret = send_abort(ep, NULL, gfp);
2486                 } else
2487                         ret = send_halfclose(ep, gfp);
2488                 if (ret)
2489                         fatal = 1;
2490         }
2491         mutex_unlock(&ep->com.mutex);
2492         if (fatal)
2493                 release_ep_resources(ep);
2494         return ret;
2495 }
2496
2497 static int async_event(struct c4iw_dev *dev, struct sk_buff *skb)
2498 {
2499         struct cpl_fw6_msg *rpl = cplhdr(skb);
2500         c4iw_ev_dispatch(dev, (struct t4_cqe *)&rpl->data[0]);
2501         return 0;
2502 }
2503
2504 /*
2505  * These are the real handlers that are called from a
2506  * work queue.
2507  */
2508 static c4iw_handler_func work_handlers[NUM_CPL_CMDS] = {
2509         [CPL_ACT_ESTABLISH] = act_establish,
2510         [CPL_ACT_OPEN_RPL] = act_open_rpl,
2511         [CPL_RX_DATA] = rx_data,
2512         [CPL_ABORT_RPL_RSS] = abort_rpl,
2513         [CPL_ABORT_RPL] = abort_rpl,
2514         [CPL_PASS_OPEN_RPL] = pass_open_rpl,
2515         [CPL_CLOSE_LISTSRV_RPL] = close_listsrv_rpl,
2516         [CPL_PASS_ACCEPT_REQ] = pass_accept_req,
2517         [CPL_PASS_ESTABLISH] = pass_establish,
2518         [CPL_PEER_CLOSE] = peer_close,
2519         [CPL_ABORT_REQ_RSS] = peer_abort,
2520         [CPL_CLOSE_CON_RPL] = close_con_rpl,
2521         [CPL_RDMA_TERMINATE] = terminate,
2522         [CPL_FW4_ACK] = fw4_ack,
2523         [CPL_FW6_MSG] = async_event
2524 };
2525
2526 static void process_timeout(struct c4iw_ep *ep)
2527 {
2528         struct c4iw_qp_attributes attrs;
2529         int abort = 1;
2530
2531         mutex_lock(&ep->com.mutex);
2532         PDBG("%s ep %p tid %u state %d\n", __func__, ep, ep->hwtid,
2533              ep->com.state);
2534         switch (ep->com.state) {
2535         case MPA_REQ_SENT:
2536                 __state_set(&ep->com, ABORTING);
2537                 connect_reply_upcall(ep, -ETIMEDOUT);
2538                 break;
2539         case MPA_REQ_WAIT:
2540                 __state_set(&ep->com, ABORTING);
2541                 break;
2542         case CLOSING:
2543         case MORIBUND:
2544                 if (ep->com.cm_id && ep->com.qp) {
2545                         attrs.next_state = C4IW_QP_STATE_ERROR;
2546                         c4iw_modify_qp(ep->com.qp->rhp,
2547                                      ep->com.qp, C4IW_QP_ATTR_NEXT_STATE,
2548                                      &attrs, 1);
2549                 }
2550                 __state_set(&ep->com, ABORTING);
2551                 break;
2552         default:
2553                 WARN(1, "%s unexpected state ep %p tid %u state %u\n",
2554                         __func__, ep, ep->hwtid, ep->com.state);
2555                 abort = 0;
2556         }
2557         mutex_unlock(&ep->com.mutex);
2558         if (abort)
2559                 abort_connection(ep, NULL, GFP_KERNEL);
2560         c4iw_put_ep(&ep->com);
2561 }
2562
2563 static void process_timedout_eps(void)
2564 {
2565         struct c4iw_ep *ep;
2566
2567         spin_lock_irq(&timeout_lock);
2568         while (!list_empty(&timeout_list)) {
2569                 struct list_head *tmp;
2570
2571                 tmp = timeout_list.next;
2572                 list_del(tmp);
2573                 spin_unlock_irq(&timeout_lock);
2574                 ep = list_entry(tmp, struct c4iw_ep, entry);
2575                 process_timeout(ep);
2576                 spin_lock_irq(&timeout_lock);
2577         }
2578         spin_unlock_irq(&timeout_lock);
2579 }
2580
2581 static void process_work(struct work_struct *work)
2582 {
2583         struct sk_buff *skb = NULL;
2584         struct c4iw_dev *dev;
2585         struct cpl_act_establish *rpl;
2586         unsigned int opcode;
2587         int ret;
2588
2589         while ((skb = skb_dequeue(&rxq))) {
2590                 rpl = cplhdr(skb);
2591                 dev = *((struct c4iw_dev **) (skb->cb + sizeof(void *)));
2592                 opcode = rpl->ot.opcode;
2593
2594                 BUG_ON(!work_handlers[opcode]);
2595                 ret = work_handlers[opcode](dev, skb);
2596                 if (!ret)
2597                         kfree_skb(skb);
2598         }
2599         process_timedout_eps();
2600 }
2601
2602 static DECLARE_WORK(skb_work, process_work);
2603
2604 static void ep_timeout(unsigned long arg)
2605 {
2606         struct c4iw_ep *ep = (struct c4iw_ep *)arg;
2607
2608         spin_lock(&timeout_lock);
2609         list_add_tail(&ep->entry, &timeout_list);
2610         spin_unlock(&timeout_lock);
2611         queue_work(workq, &skb_work);
2612 }
2613
2614 /*
2615  * All the CM events are handled on a work queue to have a safe context.
2616  */
2617 static int sched(struct c4iw_dev *dev, struct sk_buff *skb)
2618 {
2619
2620         /*
2621          * Save dev in the skb->cb area.
2622          */
2623         *((struct c4iw_dev **) (skb->cb + sizeof(void *))) = dev;
2624
2625         /*
2626          * Queue the skb and schedule the worker thread.
2627          */
2628         skb_queue_tail(&rxq, skb);
2629         queue_work(workq, &skb_work);
2630         return 0;
2631 }
2632
2633 static int set_tcb_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
2634 {
2635         struct cpl_set_tcb_rpl *rpl = cplhdr(skb);
2636
2637         if (rpl->status != CPL_ERR_NONE) {
2638                 printk(KERN_ERR MOD "Unexpected SET_TCB_RPL status %u "
2639                        "for tid %u\n", rpl->status, GET_TID(rpl));
2640         }
2641         kfree_skb(skb);
2642         return 0;
2643 }
2644
2645 static int fw6_msg(struct c4iw_dev *dev, struct sk_buff *skb)
2646 {
2647         struct cpl_fw6_msg *rpl = cplhdr(skb);
2648         struct c4iw_wr_wait *wr_waitp;
2649         int ret;
2650
2651         PDBG("%s type %u\n", __func__, rpl->type);
2652
2653         switch (rpl->type) {
2654         case 1:
2655                 ret = (int)((be64_to_cpu(rpl->data[0]) >> 8) & 0xff);
2656                 wr_waitp = (struct c4iw_wr_wait *)(__force unsigned long) rpl->data[1];
2657                 PDBG("%s wr_waitp %p ret %u\n", __func__, wr_waitp, ret);
2658                 if (wr_waitp)
2659                         c4iw_wake_up(wr_waitp, ret ? -ret : 0);
2660                 kfree_skb(skb);
2661                 break;
2662         case 2:
2663                 sched(dev, skb);
2664                 break;
2665         default:
2666                 printk(KERN_ERR MOD "%s unexpected fw6 msg type %u\n", __func__,
2667                        rpl->type);
2668                 kfree_skb(skb);
2669                 break;
2670         }
2671         return 0;
2672 }
2673
2674 static int peer_abort_intr(struct c4iw_dev *dev, struct sk_buff *skb)
2675 {
2676         struct cpl_abort_req_rss *req = cplhdr(skb);
2677         struct c4iw_ep *ep;
2678         struct tid_info *t = dev->rdev.lldi.tids;
2679         unsigned int tid = GET_TID(req);
2680
2681         ep = lookup_tid(t, tid);
2682         if (!ep) {
2683                 printk(KERN_WARNING MOD
2684                        "Abort on non-existent endpoint, tid %d\n", tid);
2685                 kfree_skb(skb);
2686                 return 0;
2687         }
2688         if (is_neg_adv_abort(req->status)) {
2689                 PDBG("%s neg_adv_abort ep %p tid %u\n", __func__, ep,
2690                      ep->hwtid);
2691                 kfree_skb(skb);
2692                 return 0;
2693         }
2694         PDBG("%s ep %p tid %u state %u\n", __func__, ep, ep->hwtid,
2695              ep->com.state);
2696
2697         /*
2698          * Wake up any threads in rdma_init() or rdma_fini().
2699          */
2700         c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
2701         sched(dev, skb);
2702         return 0;
2703 }
2704
2705 /*
2706  * Most upcalls from the T4 Core go to sched() to
2707  * schedule the processing on a work queue.
2708  */
2709 c4iw_handler_func c4iw_handlers[NUM_CPL_CMDS] = {
2710         [CPL_ACT_ESTABLISH] = sched,
2711         [CPL_ACT_OPEN_RPL] = sched,
2712         [CPL_RX_DATA] = sched,
2713         [CPL_ABORT_RPL_RSS] = sched,
2714         [CPL_ABORT_RPL] = sched,
2715         [CPL_PASS_OPEN_RPL] = sched,
2716         [CPL_CLOSE_LISTSRV_RPL] = sched,
2717         [CPL_PASS_ACCEPT_REQ] = sched,
2718         [CPL_PASS_ESTABLISH] = sched,
2719         [CPL_PEER_CLOSE] = sched,
2720         [CPL_CLOSE_CON_RPL] = sched,
2721         [CPL_ABORT_REQ_RSS] = peer_abort_intr,
2722         [CPL_RDMA_TERMINATE] = sched,
2723         [CPL_FW4_ACK] = sched,
2724         [CPL_SET_TCB_RPL] = set_tcb_rpl,
2725         [CPL_FW6_MSG] = fw6_msg
2726 };
2727
2728 int __init c4iw_cm_init(void)
2729 {
2730         spin_lock_init(&timeout_lock);
2731         skb_queue_head_init(&rxq);
2732
2733         workq = create_singlethread_workqueue("iw_cxgb4");
2734         if (!workq)
2735                 return -ENOMEM;
2736
2737         return 0;
2738 }
2739
2740 void __exit c4iw_cm_term(void)
2741 {
2742         WARN_ON(!list_empty(&timeout_list));
2743         flush_workqueue(workq);
2744         destroy_workqueue(workq);
2745 }