Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6.git] / drivers / infiniband / hw / cxgb3 / iwch_cm.c
1 /*
2  * Copyright (c) 2006 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
40 #include <net/neighbour.h>
41 #include <net/netevent.h>
42 #include <net/route.h>
43
44 #include "tcb.h"
45 #include "cxgb3_offload.h"
46 #include "iwch.h"
47 #include "iwch_provider.h"
48 #include "iwch_cm.h"
49
50 static char *states[] = {
51         "idle",
52         "listen",
53         "connecting",
54         "mpa_wait_req",
55         "mpa_req_sent",
56         "mpa_req_rcvd",
57         "mpa_rep_sent",
58         "fpdu_mode",
59         "aborting",
60         "closing",
61         "moribund",
62         "dead",
63         NULL,
64 };
65
66 int peer2peer = 0;
67 module_param(peer2peer, int, 0644);
68 MODULE_PARM_DESC(peer2peer, "Support peer2peer ULPs (default=0)");
69
70 static int ep_timeout_secs = 60;
71 module_param(ep_timeout_secs, int, 0644);
72 MODULE_PARM_DESC(ep_timeout_secs, "CM Endpoint operation timeout "
73                                    "in seconds (default=60)");
74
75 static int mpa_rev = 1;
76 module_param(mpa_rev, int, 0644);
77 MODULE_PARM_DESC(mpa_rev, "MPA Revision, 0 supports amso1100, "
78                  "1 is spec compliant. (default=1)");
79
80 static int markers_enabled = 0;
81 module_param(markers_enabled, int, 0644);
82 MODULE_PARM_DESC(markers_enabled, "Enable MPA MARKERS (default(0)=disabled)");
83
84 static int crc_enabled = 1;
85 module_param(crc_enabled, int, 0644);
86 MODULE_PARM_DESC(crc_enabled, "Enable MPA CRC (default(1)=enabled)");
87
88 static int rcv_win = 256 * 1024;
89 module_param(rcv_win, int, 0644);
90 MODULE_PARM_DESC(rcv_win, "TCP receive window in bytes (default=256)");
91
92 static int snd_win = 32 * 1024;
93 module_param(snd_win, int, 0644);
94 MODULE_PARM_DESC(snd_win, "TCP send window in bytes (default=32KB)");
95
96 static unsigned int nocong = 0;
97 module_param(nocong, uint, 0644);
98 MODULE_PARM_DESC(nocong, "Turn off congestion control (default=0)");
99
100 static unsigned int cong_flavor = 1;
101 module_param(cong_flavor, uint, 0644);
102 MODULE_PARM_DESC(cong_flavor, "TCP Congestion control flavor (default=1)");
103
104 static void process_work(struct work_struct *work);
105 static struct workqueue_struct *workq;
106 static DECLARE_WORK(skb_work, process_work);
107
108 static struct sk_buff_head rxq;
109 static cxgb3_cpl_handler_func work_handlers[NUM_CPL_CMDS];
110
111 static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp);
112 static void ep_timeout(unsigned long arg);
113 static void connect_reply_upcall(struct iwch_ep *ep, int status);
114
115 static void start_ep_timer(struct iwch_ep *ep)
116 {
117         PDBG("%s ep %p\n", __func__, ep);
118         if (timer_pending(&ep->timer)) {
119                 PDBG("%s stopped / restarted timer ep %p\n", __func__, ep);
120                 del_timer_sync(&ep->timer);
121         } else
122                 get_ep(&ep->com);
123         ep->timer.expires = jiffies + ep_timeout_secs * HZ;
124         ep->timer.data = (unsigned long)ep;
125         ep->timer.function = ep_timeout;
126         add_timer(&ep->timer);
127 }
128
129 static void stop_ep_timer(struct iwch_ep *ep)
130 {
131         PDBG("%s ep %p\n", __func__, ep);
132         if (!timer_pending(&ep->timer)) {
133                 printk(KERN_ERR "%s timer stopped when its not running!  ep %p state %u\n",
134                         __func__, ep, ep->com.state);
135                 WARN_ON(1);
136                 return;
137         }
138         del_timer_sync(&ep->timer);
139         put_ep(&ep->com);
140 }
141
142 static void release_tid(struct t3cdev *tdev, u32 hwtid, struct sk_buff *skb)
143 {
144         struct cpl_tid_release *req;
145
146         skb = get_skb(skb, sizeof *req, GFP_KERNEL);
147         if (!skb)
148                 return;
149         req = (struct cpl_tid_release *) skb_put(skb, sizeof(*req));
150         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
151         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_TID_RELEASE, hwtid));
152         skb->priority = CPL_PRIORITY_SETUP;
153         cxgb3_ofld_send(tdev, skb);
154         return;
155 }
156
157 int iwch_quiesce_tid(struct iwch_ep *ep)
158 {
159         struct cpl_set_tcb_field *req;
160         struct sk_buff *skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
161
162         if (!skb)
163                 return -ENOMEM;
164         req = (struct cpl_set_tcb_field *) skb_put(skb, sizeof(*req));
165         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
166         req->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
167         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, ep->hwtid));
168         req->reply = 0;
169         req->cpu_idx = 0;
170         req->word = htons(W_TCB_RX_QUIESCE);
171         req->mask = cpu_to_be64(1ULL << S_TCB_RX_QUIESCE);
172         req->val = cpu_to_be64(1 << S_TCB_RX_QUIESCE);
173
174         skb->priority = CPL_PRIORITY_DATA;
175         cxgb3_ofld_send(ep->com.tdev, skb);
176         return 0;
177 }
178
179 int iwch_resume_tid(struct iwch_ep *ep)
180 {
181         struct cpl_set_tcb_field *req;
182         struct sk_buff *skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
183
184         if (!skb)
185                 return -ENOMEM;
186         req = (struct cpl_set_tcb_field *) skb_put(skb, sizeof(*req));
187         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
188         req->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
189         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, ep->hwtid));
190         req->reply = 0;
191         req->cpu_idx = 0;
192         req->word = htons(W_TCB_RX_QUIESCE);
193         req->mask = cpu_to_be64(1ULL << S_TCB_RX_QUIESCE);
194         req->val = 0;
195
196         skb->priority = CPL_PRIORITY_DATA;
197         cxgb3_ofld_send(ep->com.tdev, skb);
198         return 0;
199 }
200
201 static void set_emss(struct iwch_ep *ep, u16 opt)
202 {
203         PDBG("%s ep %p opt %u\n", __func__, ep, opt);
204         ep->emss = T3C_DATA(ep->com.tdev)->mtus[G_TCPOPT_MSS(opt)] - 40;
205         if (G_TCPOPT_TSTAMP(opt))
206                 ep->emss -= 12;
207         if (ep->emss < 128)
208                 ep->emss = 128;
209         PDBG("emss=%d\n", ep->emss);
210 }
211
212 static enum iwch_ep_state state_read(struct iwch_ep_common *epc)
213 {
214         unsigned long flags;
215         enum iwch_ep_state state;
216
217         spin_lock_irqsave(&epc->lock, flags);
218         state = epc->state;
219         spin_unlock_irqrestore(&epc->lock, flags);
220         return state;
221 }
222
223 static void __state_set(struct iwch_ep_common *epc, enum iwch_ep_state new)
224 {
225         epc->state = new;
226 }
227
228 static void state_set(struct iwch_ep_common *epc, enum iwch_ep_state new)
229 {
230         unsigned long flags;
231
232         spin_lock_irqsave(&epc->lock, flags);
233         PDBG("%s - %s -> %s\n", __func__, states[epc->state], states[new]);
234         __state_set(epc, new);
235         spin_unlock_irqrestore(&epc->lock, flags);
236         return;
237 }
238
239 static void *alloc_ep(int size, gfp_t gfp)
240 {
241         struct iwch_ep_common *epc;
242
243         epc = kzalloc(size, gfp);
244         if (epc) {
245                 kref_init(&epc->kref);
246                 spin_lock_init(&epc->lock);
247                 init_waitqueue_head(&epc->waitq);
248         }
249         PDBG("%s alloc ep %p\n", __func__, epc);
250         return epc;
251 }
252
253 void __free_ep(struct kref *kref)
254 {
255         struct iwch_ep_common *epc;
256         epc = container_of(kref, struct iwch_ep_common, kref);
257         PDBG("%s ep %p state %s\n", __func__, epc, states[state_read(epc)]);
258         kfree(epc);
259 }
260
261 static void release_ep_resources(struct iwch_ep *ep)
262 {
263         PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
264         cxgb3_remove_tid(ep->com.tdev, (void *)ep, ep->hwtid);
265         dst_release(ep->dst);
266         l2t_release(L2DATA(ep->com.tdev), ep->l2t);
267         put_ep(&ep->com);
268 }
269
270 static void process_work(struct work_struct *work)
271 {
272         struct sk_buff *skb = NULL;
273         void *ep;
274         struct t3cdev *tdev;
275         int ret;
276
277         while ((skb = skb_dequeue(&rxq))) {
278                 ep = *((void **) (skb->cb));
279                 tdev = *((struct t3cdev **) (skb->cb + sizeof(void *)));
280                 ret = work_handlers[G_OPCODE(ntohl((__force __be32)skb->csum))](tdev, skb, ep);
281                 if (ret & CPL_RET_BUF_DONE)
282                         kfree_skb(skb);
283
284                 /*
285                  * ep was referenced in sched(), and is freed here.
286                  */
287                 put_ep((struct iwch_ep_common *)ep);
288         }
289 }
290
291 static int status2errno(int status)
292 {
293         switch (status) {
294         case CPL_ERR_NONE:
295                 return 0;
296         case CPL_ERR_CONN_RESET:
297                 return -ECONNRESET;
298         case CPL_ERR_ARP_MISS:
299                 return -EHOSTUNREACH;
300         case CPL_ERR_CONN_TIMEDOUT:
301                 return -ETIMEDOUT;
302         case CPL_ERR_TCAM_FULL:
303                 return -ENOMEM;
304         case CPL_ERR_CONN_EXIST:
305                 return -EADDRINUSE;
306         default:
307                 return -EIO;
308         }
309 }
310
311 /*
312  * Try and reuse skbs already allocated...
313  */
314 static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp)
315 {
316         if (skb && !skb_is_nonlinear(skb) && !skb_cloned(skb)) {
317                 skb_trim(skb, 0);
318                 skb_get(skb);
319         } else {
320                 skb = alloc_skb(len, gfp);
321         }
322         return skb;
323 }
324
325 static struct rtable *find_route(struct t3cdev *dev, __be32 local_ip,
326                                  __be32 peer_ip, __be16 local_port,
327                                  __be16 peer_port, u8 tos)
328 {
329         struct rtable *rt;
330         struct flowi fl = {
331                 .oif = 0,
332                 .nl_u = {
333                          .ip4_u = {
334                                    .daddr = peer_ip,
335                                    .saddr = local_ip,
336                                    .tos = tos}
337                          },
338                 .proto = IPPROTO_TCP,
339                 .uli_u = {
340                           .ports = {
341                                     .sport = local_port,
342                                     .dport = peer_port}
343                           }
344         };
345
346         if (ip_route_output_flow(&init_net, &rt, &fl, NULL, 0))
347                 return NULL;
348         return rt;
349 }
350
351 static unsigned int find_best_mtu(const struct t3c_data *d, unsigned short mtu)
352 {
353         int i = 0;
354
355         while (i < d->nmtus - 1 && d->mtus[i + 1] <= mtu)
356                 ++i;
357         return i;
358 }
359
360 static void arp_failure_discard(struct t3cdev *dev, struct sk_buff *skb)
361 {
362         PDBG("%s t3cdev %p\n", __func__, dev);
363         kfree_skb(skb);
364 }
365
366 /*
367  * Handle an ARP failure for an active open.
368  */
369 static void act_open_req_arp_failure(struct t3cdev *dev, struct sk_buff *skb)
370 {
371         printk(KERN_ERR MOD "ARP failure duing connect\n");
372         kfree_skb(skb);
373 }
374
375 /*
376  * Handle an ARP failure for a CPL_ABORT_REQ.  Change it into a no RST variant
377  * and send it along.
378  */
379 static void abort_arp_failure(struct t3cdev *dev, struct sk_buff *skb)
380 {
381         struct cpl_abort_req *req = cplhdr(skb);
382
383         PDBG("%s t3cdev %p\n", __func__, dev);
384         req->cmd = CPL_ABORT_NO_RST;
385         cxgb3_ofld_send(dev, skb);
386 }
387
388 static int send_halfclose(struct iwch_ep *ep, gfp_t gfp)
389 {
390         struct cpl_close_con_req *req;
391         struct sk_buff *skb;
392
393         PDBG("%s ep %p\n", __func__, ep);
394         skb = get_skb(NULL, sizeof(*req), gfp);
395         if (!skb) {
396                 printk(KERN_ERR MOD "%s - failed to alloc skb\n", __func__);
397                 return -ENOMEM;
398         }
399         skb->priority = CPL_PRIORITY_DATA;
400         set_arp_failure_handler(skb, arp_failure_discard);
401         req = (struct cpl_close_con_req *) skb_put(skb, sizeof(*req));
402         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_CLOSE_CON));
403         req->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
404         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_CLOSE_CON_REQ, ep->hwtid));
405         l2t_send(ep->com.tdev, skb, ep->l2t);
406         return 0;
407 }
408
409 static int send_abort(struct iwch_ep *ep, struct sk_buff *skb, gfp_t gfp)
410 {
411         struct cpl_abort_req *req;
412
413         PDBG("%s ep %p\n", __func__, ep);
414         skb = get_skb(skb, sizeof(*req), gfp);
415         if (!skb) {
416                 printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
417                        __func__);
418                 return -ENOMEM;
419         }
420         skb->priority = CPL_PRIORITY_DATA;
421         set_arp_failure_handler(skb, abort_arp_failure);
422         req = (struct cpl_abort_req *) skb_put(skb, sizeof(*req));
423         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_HOST_ABORT_CON_REQ));
424         req->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
425         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_ABORT_REQ, ep->hwtid));
426         req->cmd = CPL_ABORT_SEND_RST;
427         l2t_send(ep->com.tdev, skb, ep->l2t);
428         return 0;
429 }
430
431 static int send_connect(struct iwch_ep *ep)
432 {
433         struct cpl_act_open_req *req;
434         struct sk_buff *skb;
435         u32 opt0h, opt0l, opt2;
436         unsigned int mtu_idx;
437         int wscale;
438
439         PDBG("%s ep %p\n", __func__, ep);
440
441         skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
442         if (!skb) {
443                 printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
444                        __func__);
445                 return -ENOMEM;
446         }
447         mtu_idx = find_best_mtu(T3C_DATA(ep->com.tdev), dst_mtu(ep->dst));
448         wscale = compute_wscale(rcv_win);
449         opt0h = V_NAGLE(0) |
450             V_NO_CONG(nocong) |
451             V_KEEP_ALIVE(1) |
452             F_TCAM_BYPASS |
453             V_WND_SCALE(wscale) |
454             V_MSS_IDX(mtu_idx) |
455             V_L2T_IDX(ep->l2t->idx) | V_TX_CHANNEL(ep->l2t->smt_idx);
456         opt0l = V_TOS((ep->tos >> 2) & M_TOS) | V_RCV_BUFSIZ(rcv_win>>10);
457         opt2 = V_FLAVORS_VALID(1) | V_CONG_CONTROL_FLAVOR(cong_flavor);
458         skb->priority = CPL_PRIORITY_SETUP;
459         set_arp_failure_handler(skb, act_open_req_arp_failure);
460
461         req = (struct cpl_act_open_req *) skb_put(skb, sizeof(*req));
462         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
463         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_ACT_OPEN_REQ, ep->atid));
464         req->local_port = ep->com.local_addr.sin_port;
465         req->peer_port = ep->com.remote_addr.sin_port;
466         req->local_ip = ep->com.local_addr.sin_addr.s_addr;
467         req->peer_ip = ep->com.remote_addr.sin_addr.s_addr;
468         req->opt0h = htonl(opt0h);
469         req->opt0l = htonl(opt0l);
470         req->params = 0;
471         req->opt2 = htonl(opt2);
472         l2t_send(ep->com.tdev, skb, ep->l2t);
473         return 0;
474 }
475
476 static void send_mpa_req(struct iwch_ep *ep, struct sk_buff *skb)
477 {
478         int mpalen;
479         struct tx_data_wr *req;
480         struct mpa_message *mpa;
481         int len;
482
483         PDBG("%s ep %p pd_len %d\n", __func__, ep, ep->plen);
484
485         BUG_ON(skb_cloned(skb));
486
487         mpalen = sizeof(*mpa) + ep->plen;
488         if (skb->data + mpalen + sizeof(*req) > skb_end_pointer(skb)) {
489                 kfree_skb(skb);
490                 skb=alloc_skb(mpalen + sizeof(*req), GFP_KERNEL);
491                 if (!skb) {
492                         connect_reply_upcall(ep, -ENOMEM);
493                         return;
494                 }
495         }
496         skb_trim(skb, 0);
497         skb_reserve(skb, sizeof(*req));
498         skb_put(skb, mpalen);
499         skb->priority = CPL_PRIORITY_DATA;
500         mpa = (struct mpa_message *) skb->data;
501         memset(mpa, 0, sizeof(*mpa));
502         memcpy(mpa->key, MPA_KEY_REQ, sizeof(mpa->key));
503         mpa->flags = (crc_enabled ? MPA_CRC : 0) |
504                      (markers_enabled ? MPA_MARKERS : 0);
505         mpa->private_data_size = htons(ep->plen);
506         mpa->revision = mpa_rev;
507
508         if (ep->plen)
509                 memcpy(mpa->private_data, ep->mpa_pkt + sizeof(*mpa), ep->plen);
510
511         /*
512          * Reference the mpa skb.  This ensures the data area
513          * will remain in memory until the hw acks the tx.
514          * Function tx_ack() will deref it.
515          */
516         skb_get(skb);
517         set_arp_failure_handler(skb, arp_failure_discard);
518         skb_reset_transport_header(skb);
519         len = skb->len;
520         req = (struct tx_data_wr *) skb_push(skb, sizeof(*req));
521         req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA)|F_WR_COMPL);
522         req->wr_lo = htonl(V_WR_TID(ep->hwtid));
523         req->len = htonl(len);
524         req->param = htonl(V_TX_PORT(ep->l2t->smt_idx) |
525                            V_TX_SNDBUF(snd_win>>15));
526         req->flags = htonl(F_TX_INIT);
527         req->sndseq = htonl(ep->snd_seq);
528         BUG_ON(ep->mpa_skb);
529         ep->mpa_skb = skb;
530         l2t_send(ep->com.tdev, skb, ep->l2t);
531         start_ep_timer(ep);
532         state_set(&ep->com, MPA_REQ_SENT);
533         return;
534 }
535
536 static int send_mpa_reject(struct iwch_ep *ep, const void *pdata, u8 plen)
537 {
538         int mpalen;
539         struct tx_data_wr *req;
540         struct mpa_message *mpa;
541         struct sk_buff *skb;
542
543         PDBG("%s ep %p plen %d\n", __func__, ep, plen);
544
545         mpalen = sizeof(*mpa) + plen;
546
547         skb = get_skb(NULL, mpalen + sizeof(*req), GFP_KERNEL);
548         if (!skb) {
549                 printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
550                 return -ENOMEM;
551         }
552         skb_reserve(skb, sizeof(*req));
553         mpa = (struct mpa_message *) skb_put(skb, mpalen);
554         memset(mpa, 0, sizeof(*mpa));
555         memcpy(mpa->key, MPA_KEY_REP, sizeof(mpa->key));
556         mpa->flags = MPA_REJECT;
557         mpa->revision = mpa_rev;
558         mpa->private_data_size = htons(plen);
559         if (plen)
560                 memcpy(mpa->private_data, pdata, plen);
561
562         /*
563          * Reference the mpa skb again.  This ensures the data area
564          * will remain in memory until the hw acks the tx.
565          * Function tx_ack() will deref it.
566          */
567         skb_get(skb);
568         skb->priority = CPL_PRIORITY_DATA;
569         set_arp_failure_handler(skb, arp_failure_discard);
570         skb_reset_transport_header(skb);
571         req = (struct tx_data_wr *) skb_push(skb, sizeof(*req));
572         req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA)|F_WR_COMPL);
573         req->wr_lo = htonl(V_WR_TID(ep->hwtid));
574         req->len = htonl(mpalen);
575         req->param = htonl(V_TX_PORT(ep->l2t->smt_idx) |
576                            V_TX_SNDBUF(snd_win>>15));
577         req->flags = htonl(F_TX_INIT);
578         req->sndseq = htonl(ep->snd_seq);
579         BUG_ON(ep->mpa_skb);
580         ep->mpa_skb = skb;
581         l2t_send(ep->com.tdev, skb, ep->l2t);
582         return 0;
583 }
584
585 static int send_mpa_reply(struct iwch_ep *ep, const void *pdata, u8 plen)
586 {
587         int mpalen;
588         struct tx_data_wr *req;
589         struct mpa_message *mpa;
590         int len;
591         struct sk_buff *skb;
592
593         PDBG("%s ep %p plen %d\n", __func__, ep, plen);
594
595         mpalen = sizeof(*mpa) + plen;
596
597         skb = get_skb(NULL, mpalen + sizeof(*req), GFP_KERNEL);
598         if (!skb) {
599                 printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
600                 return -ENOMEM;
601         }
602         skb->priority = CPL_PRIORITY_DATA;
603         skb_reserve(skb, sizeof(*req));
604         mpa = (struct mpa_message *) skb_put(skb, mpalen);
605         memset(mpa, 0, sizeof(*mpa));
606         memcpy(mpa->key, MPA_KEY_REP, sizeof(mpa->key));
607         mpa->flags = (ep->mpa_attr.crc_enabled ? MPA_CRC : 0) |
608                      (markers_enabled ? MPA_MARKERS : 0);
609         mpa->revision = mpa_rev;
610         mpa->private_data_size = htons(plen);
611         if (plen)
612                 memcpy(mpa->private_data, pdata, plen);
613
614         /*
615          * Reference the mpa skb.  This ensures the data area
616          * will remain in memory until the hw acks the tx.
617          * Function tx_ack() will deref it.
618          */
619         skb_get(skb);
620         set_arp_failure_handler(skb, arp_failure_discard);
621         skb_reset_transport_header(skb);
622         len = skb->len;
623         req = (struct tx_data_wr *) skb_push(skb, sizeof(*req));
624         req->wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_TX_DATA)|F_WR_COMPL);
625         req->wr_lo = htonl(V_WR_TID(ep->hwtid));
626         req->len = htonl(len);
627         req->param = htonl(V_TX_PORT(ep->l2t->smt_idx) |
628                            V_TX_SNDBUF(snd_win>>15));
629         req->flags = htonl(F_TX_INIT);
630         req->sndseq = htonl(ep->snd_seq);
631         ep->mpa_skb = skb;
632         state_set(&ep->com, MPA_REP_SENT);
633         l2t_send(ep->com.tdev, skb, ep->l2t);
634         return 0;
635 }
636
637 static int act_establish(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
638 {
639         struct iwch_ep *ep = ctx;
640         struct cpl_act_establish *req = cplhdr(skb);
641         unsigned int tid = GET_TID(req);
642
643         PDBG("%s ep %p tid %d\n", __func__, ep, tid);
644
645         dst_confirm(ep->dst);
646
647         /* setup the hwtid for this connection */
648         ep->hwtid = tid;
649         cxgb3_insert_tid(ep->com.tdev, &t3c_client, ep, tid);
650
651         ep->snd_seq = ntohl(req->snd_isn);
652         ep->rcv_seq = ntohl(req->rcv_isn);
653
654         set_emss(ep, ntohs(req->tcp_opt));
655
656         /* dealloc the atid */
657         cxgb3_free_atid(ep->com.tdev, ep->atid);
658
659         /* start MPA negotiation */
660         send_mpa_req(ep, skb);
661
662         return 0;
663 }
664
665 static void abort_connection(struct iwch_ep *ep, struct sk_buff *skb, gfp_t gfp)
666 {
667         PDBG("%s ep %p\n", __FILE__, ep);
668         state_set(&ep->com, ABORTING);
669         send_abort(ep, skb, gfp);
670 }
671
672 static void close_complete_upcall(struct iwch_ep *ep)
673 {
674         struct iw_cm_event event;
675
676         PDBG("%s ep %p\n", __func__, ep);
677         memset(&event, 0, sizeof(event));
678         event.event = IW_CM_EVENT_CLOSE;
679         if (ep->com.cm_id) {
680                 PDBG("close complete delivered ep %p cm_id %p tid %d\n",
681                      ep, ep->com.cm_id, ep->hwtid);
682                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
683                 ep->com.cm_id->rem_ref(ep->com.cm_id);
684                 ep->com.cm_id = NULL;
685                 ep->com.qp = NULL;
686         }
687 }
688
689 static void peer_close_upcall(struct iwch_ep *ep)
690 {
691         struct iw_cm_event event;
692
693         PDBG("%s ep %p\n", __func__, ep);
694         memset(&event, 0, sizeof(event));
695         event.event = IW_CM_EVENT_DISCONNECT;
696         if (ep->com.cm_id) {
697                 PDBG("peer close delivered ep %p cm_id %p tid %d\n",
698                      ep, ep->com.cm_id, ep->hwtid);
699                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
700         }
701 }
702
703 static void peer_abort_upcall(struct iwch_ep *ep)
704 {
705         struct iw_cm_event event;
706
707         PDBG("%s ep %p\n", __func__, ep);
708         memset(&event, 0, sizeof(event));
709         event.event = IW_CM_EVENT_CLOSE;
710         event.status = -ECONNRESET;
711         if (ep->com.cm_id) {
712                 PDBG("abort delivered ep %p cm_id %p tid %d\n", ep,
713                      ep->com.cm_id, ep->hwtid);
714                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
715                 ep->com.cm_id->rem_ref(ep->com.cm_id);
716                 ep->com.cm_id = NULL;
717                 ep->com.qp = NULL;
718         }
719 }
720
721 static void connect_reply_upcall(struct iwch_ep *ep, int status)
722 {
723         struct iw_cm_event event;
724
725         PDBG("%s ep %p status %d\n", __func__, ep, status);
726         memset(&event, 0, sizeof(event));
727         event.event = IW_CM_EVENT_CONNECT_REPLY;
728         event.status = status;
729         event.local_addr = ep->com.local_addr;
730         event.remote_addr = ep->com.remote_addr;
731
732         if ((status == 0) || (status == -ECONNREFUSED)) {
733                 event.private_data_len = ep->plen;
734                 event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
735         }
736         if (ep->com.cm_id) {
737                 PDBG("%s ep %p tid %d status %d\n", __func__, ep,
738                      ep->hwtid, status);
739                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
740         }
741         if (status < 0) {
742                 ep->com.cm_id->rem_ref(ep->com.cm_id);
743                 ep->com.cm_id = NULL;
744                 ep->com.qp = NULL;
745         }
746 }
747
748 static void connect_request_upcall(struct iwch_ep *ep)
749 {
750         struct iw_cm_event event;
751
752         PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
753         memset(&event, 0, sizeof(event));
754         event.event = IW_CM_EVENT_CONNECT_REQUEST;
755         event.local_addr = ep->com.local_addr;
756         event.remote_addr = ep->com.remote_addr;
757         event.private_data_len = ep->plen;
758         event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
759         event.provider_data = ep;
760         if (state_read(&ep->parent_ep->com) != DEAD)
761                 ep->parent_ep->com.cm_id->event_handler(
762                                                 ep->parent_ep->com.cm_id,
763                                                 &event);
764         put_ep(&ep->parent_ep->com);
765         ep->parent_ep = NULL;
766 }
767
768 static void established_upcall(struct iwch_ep *ep)
769 {
770         struct iw_cm_event event;
771
772         PDBG("%s ep %p\n", __func__, ep);
773         memset(&event, 0, sizeof(event));
774         event.event = IW_CM_EVENT_ESTABLISHED;
775         if (ep->com.cm_id) {
776                 PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
777                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
778         }
779 }
780
781 static int update_rx_credits(struct iwch_ep *ep, u32 credits)
782 {
783         struct cpl_rx_data_ack *req;
784         struct sk_buff *skb;
785
786         PDBG("%s ep %p credits %u\n", __func__, ep, credits);
787         skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
788         if (!skb) {
789                 printk(KERN_ERR MOD "update_rx_credits - cannot alloc skb!\n");
790                 return 0;
791         }
792
793         req = (struct cpl_rx_data_ack *) skb_put(skb, sizeof(*req));
794         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
795         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_RX_DATA_ACK, ep->hwtid));
796         req->credit_dack = htonl(V_RX_CREDITS(credits) | V_RX_FORCE_ACK(1));
797         skb->priority = CPL_PRIORITY_ACK;
798         cxgb3_ofld_send(ep->com.tdev, skb);
799         return credits;
800 }
801
802 static void process_mpa_reply(struct iwch_ep *ep, struct sk_buff *skb)
803 {
804         struct mpa_message *mpa;
805         u16 plen;
806         struct iwch_qp_attributes attrs;
807         enum iwch_qp_attr_mask mask;
808         int err;
809
810         PDBG("%s ep %p\n", __func__, ep);
811
812         /*
813          * Stop mpa timer.  If it expired, then the state has
814          * changed and we bail since ep_timeout already aborted
815          * the connection.
816          */
817         stop_ep_timer(ep);
818         if (state_read(&ep->com) != MPA_REQ_SENT)
819                 return;
820
821         /*
822          * If we get more than the supported amount of private data
823          * then we must fail this connection.
824          */
825         if (ep->mpa_pkt_len + skb->len > sizeof(ep->mpa_pkt)) {
826                 err = -EINVAL;
827                 goto err;
828         }
829
830         /*
831          * copy the new data into our accumulation buffer.
832          */
833         skb_copy_from_linear_data(skb, &(ep->mpa_pkt[ep->mpa_pkt_len]),
834                                   skb->len);
835         ep->mpa_pkt_len += skb->len;
836
837         /*
838          * if we don't even have the mpa message, then bail.
839          */
840         if (ep->mpa_pkt_len < sizeof(*mpa))
841                 return;
842         mpa = (struct mpa_message *) ep->mpa_pkt;
843
844         /* Validate MPA header. */
845         if (mpa->revision != mpa_rev) {
846                 err = -EPROTO;
847                 goto err;
848         }
849         if (memcmp(mpa->key, MPA_KEY_REP, sizeof(mpa->key))) {
850                 err = -EPROTO;
851                 goto err;
852         }
853
854         plen = ntohs(mpa->private_data_size);
855
856         /*
857          * Fail if there's too much private data.
858          */
859         if (plen > MPA_MAX_PRIVATE_DATA) {
860                 err = -EPROTO;
861                 goto err;
862         }
863
864         /*
865          * If plen does not account for pkt size
866          */
867         if (ep->mpa_pkt_len > (sizeof(*mpa) + plen)) {
868                 err = -EPROTO;
869                 goto err;
870         }
871
872         ep->plen = (u8) plen;
873
874         /*
875          * If we don't have all the pdata yet, then bail.
876          * We'll continue process when more data arrives.
877          */
878         if (ep->mpa_pkt_len < (sizeof(*mpa) + plen))
879                 return;
880
881         if (mpa->flags & MPA_REJECT) {
882                 err = -ECONNREFUSED;
883                 goto err;
884         }
885
886         /*
887          * If we get here we have accumulated the entire mpa
888          * start reply message including private data. And
889          * the MPA header is valid.
890          */
891         state_set(&ep->com, FPDU_MODE);
892         ep->mpa_attr.initiator = 1;
893         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
894         ep->mpa_attr.recv_marker_enabled = markers_enabled;
895         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
896         ep->mpa_attr.version = mpa_rev;
897         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
898              "xmit_marker_enabled=%d, version=%d\n", __func__,
899              ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
900              ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version);
901
902         attrs.mpa_attr = ep->mpa_attr;
903         attrs.max_ird = ep->ird;
904         attrs.max_ord = ep->ord;
905         attrs.llp_stream_handle = ep;
906         attrs.next_state = IWCH_QP_STATE_RTS;
907
908         mask = IWCH_QP_ATTR_NEXT_STATE |
909             IWCH_QP_ATTR_LLP_STREAM_HANDLE | IWCH_QP_ATTR_MPA_ATTR |
910             IWCH_QP_ATTR_MAX_IRD | IWCH_QP_ATTR_MAX_ORD;
911
912         /* bind QP and TID with INIT_WR */
913         err = iwch_modify_qp(ep->com.qp->rhp,
914                              ep->com.qp, mask, &attrs, 1);
915         if (err)
916                 goto err;
917
918         if (peer2peer && iwch_rqes_posted(ep->com.qp) == 0) {
919                 iwch_post_zb_read(ep->com.qp);
920         }
921
922         goto out;
923 err:
924         abort_connection(ep, skb, GFP_KERNEL);
925 out:
926         connect_reply_upcall(ep, err);
927         return;
928 }
929
930 static void process_mpa_request(struct iwch_ep *ep, struct sk_buff *skb)
931 {
932         struct mpa_message *mpa;
933         u16 plen;
934
935         PDBG("%s ep %p\n", __func__, ep);
936
937         /*
938          * Stop mpa timer.  If it expired, then the state has
939          * changed and we bail since ep_timeout already aborted
940          * the connection.
941          */
942         stop_ep_timer(ep);
943         if (state_read(&ep->com) != MPA_REQ_WAIT)
944                 return;
945
946         /*
947          * If we get more than the supported amount of private data
948          * then we must fail this connection.
949          */
950         if (ep->mpa_pkt_len + skb->len > sizeof(ep->mpa_pkt)) {
951                 abort_connection(ep, skb, GFP_KERNEL);
952                 return;
953         }
954
955         PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
956
957         /*
958          * Copy the new data into our accumulation buffer.
959          */
960         skb_copy_from_linear_data(skb, &(ep->mpa_pkt[ep->mpa_pkt_len]),
961                                   skb->len);
962         ep->mpa_pkt_len += skb->len;
963
964         /*
965          * If we don't even have the mpa message, then bail.
966          * We'll continue process when more data arrives.
967          */
968         if (ep->mpa_pkt_len < sizeof(*mpa))
969                 return;
970         PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
971         mpa = (struct mpa_message *) ep->mpa_pkt;
972
973         /*
974          * Validate MPA Header.
975          */
976         if (mpa->revision != mpa_rev) {
977                 abort_connection(ep, skb, GFP_KERNEL);
978                 return;
979         }
980
981         if (memcmp(mpa->key, MPA_KEY_REQ, sizeof(mpa->key))) {
982                 abort_connection(ep, skb, GFP_KERNEL);
983                 return;
984         }
985
986         plen = ntohs(mpa->private_data_size);
987
988         /*
989          * Fail if there's too much private data.
990          */
991         if (plen > MPA_MAX_PRIVATE_DATA) {
992                 abort_connection(ep, skb, GFP_KERNEL);
993                 return;
994         }
995
996         /*
997          * If plen does not account for pkt size
998          */
999         if (ep->mpa_pkt_len > (sizeof(*mpa) + plen)) {
1000                 abort_connection(ep, skb, GFP_KERNEL);
1001                 return;
1002         }
1003         ep->plen = (u8) plen;
1004
1005         /*
1006          * If we don't have all the pdata yet, then bail.
1007          */
1008         if (ep->mpa_pkt_len < (sizeof(*mpa) + plen))
1009                 return;
1010
1011         /*
1012          * If we get here we have accumulated the entire mpa
1013          * start reply message including private data.
1014          */
1015         ep->mpa_attr.initiator = 0;
1016         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
1017         ep->mpa_attr.recv_marker_enabled = markers_enabled;
1018         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
1019         ep->mpa_attr.version = mpa_rev;
1020         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
1021              "xmit_marker_enabled=%d, version=%d\n", __func__,
1022              ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
1023              ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version);
1024
1025         state_set(&ep->com, MPA_REQ_RCVD);
1026
1027         /* drive upcall */
1028         connect_request_upcall(ep);
1029         return;
1030 }
1031
1032 static int rx_data(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1033 {
1034         struct iwch_ep *ep = ctx;
1035         struct cpl_rx_data *hdr = cplhdr(skb);
1036         unsigned int dlen = ntohs(hdr->len);
1037
1038         PDBG("%s ep %p dlen %u\n", __func__, ep, dlen);
1039
1040         skb_pull(skb, sizeof(*hdr));
1041         skb_trim(skb, dlen);
1042
1043         ep->rcv_seq += dlen;
1044         BUG_ON(ep->rcv_seq != (ntohl(hdr->seq) + dlen));
1045
1046         switch (state_read(&ep->com)) {
1047         case MPA_REQ_SENT:
1048                 process_mpa_reply(ep, skb);
1049                 break;
1050         case MPA_REQ_WAIT:
1051                 process_mpa_request(ep, skb);
1052                 break;
1053         case MPA_REP_SENT:
1054                 break;
1055         default:
1056                 printk(KERN_ERR MOD "%s Unexpected streaming data."
1057                        " ep %p state %d tid %d\n",
1058                        __func__, ep, state_read(&ep->com), ep->hwtid);
1059
1060                 /*
1061                  * The ep will timeout and inform the ULP of the failure.
1062                  * See ep_timeout().
1063                  */
1064                 break;
1065         }
1066
1067         /* update RX credits */
1068         update_rx_credits(ep, dlen);
1069
1070         return CPL_RET_BUF_DONE;
1071 }
1072
1073 /*
1074  * Upcall from the adapter indicating data has been transmitted.
1075  * For us its just the single MPA request or reply.  We can now free
1076  * the skb holding the mpa message.
1077  */
1078 static int tx_ack(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1079 {
1080         struct iwch_ep *ep = ctx;
1081         struct cpl_wr_ack *hdr = cplhdr(skb);
1082         unsigned int credits = ntohs(hdr->credits);
1083
1084         PDBG("%s ep %p credits %u\n", __func__, ep, credits);
1085
1086         if (credits == 0) {
1087                 PDBG(KERN_ERR "%s 0 credit ack  ep %p state %u\n",
1088                         __func__, ep, state_read(&ep->com));
1089                 return CPL_RET_BUF_DONE;
1090         }
1091
1092         BUG_ON(credits != 1);
1093         dst_confirm(ep->dst);
1094         if (!ep->mpa_skb) {
1095                 PDBG("%s rdma_init wr_ack ep %p state %u\n",
1096                         __func__, ep, state_read(&ep->com));
1097                 if (ep->mpa_attr.initiator) {
1098                         PDBG("%s initiator ep %p state %u\n",
1099                                 __func__, ep, state_read(&ep->com));
1100                         if (peer2peer)
1101                                 iwch_post_zb_read(ep->com.qp);
1102                 } else {
1103                         PDBG("%s responder ep %p state %u\n",
1104                                 __func__, ep, state_read(&ep->com));
1105                         ep->com.rpl_done = 1;
1106                         wake_up(&ep->com.waitq);
1107                 }
1108         } else {
1109                 PDBG("%s lsm ack ep %p state %u freeing skb\n",
1110                         __func__, ep, state_read(&ep->com));
1111                 kfree_skb(ep->mpa_skb);
1112                 ep->mpa_skb = NULL;
1113         }
1114         return CPL_RET_BUF_DONE;
1115 }
1116
1117 static int abort_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1118 {
1119         struct iwch_ep *ep = ctx;
1120         unsigned long flags;
1121         int release = 0;
1122
1123         PDBG("%s ep %p\n", __func__, ep);
1124         BUG_ON(!ep);
1125
1126         /*
1127          * We get 2 abort replies from the HW.  The first one must
1128          * be ignored except for scribbling that we need one more.
1129          */
1130         if (!(ep->flags & ABORT_REQ_IN_PROGRESS)) {
1131                 ep->flags |= ABORT_REQ_IN_PROGRESS;
1132                 return CPL_RET_BUF_DONE;
1133         }
1134
1135         spin_lock_irqsave(&ep->com.lock, flags);
1136         switch (ep->com.state) {
1137         case ABORTING:
1138                 close_complete_upcall(ep);
1139                 __state_set(&ep->com, DEAD);
1140                 release = 1;
1141                 break;
1142         default:
1143                 printk(KERN_ERR "%s ep %p state %d\n",
1144                      __func__, ep, ep->com.state);
1145                 break;
1146         }
1147         spin_unlock_irqrestore(&ep->com.lock, flags);
1148
1149         if (release)
1150                 release_ep_resources(ep);
1151         return CPL_RET_BUF_DONE;
1152 }
1153
1154 /*
1155  * Return whether a failed active open has allocated a TID
1156  */
1157 static inline int act_open_has_tid(int status)
1158 {
1159         return status != CPL_ERR_TCAM_FULL && status != CPL_ERR_CONN_EXIST &&
1160                status != CPL_ERR_ARP_MISS;
1161 }
1162
1163 static int act_open_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1164 {
1165         struct iwch_ep *ep = ctx;
1166         struct cpl_act_open_rpl *rpl = cplhdr(skb);
1167
1168         PDBG("%s ep %p status %u errno %d\n", __func__, ep, rpl->status,
1169              status2errno(rpl->status));
1170         connect_reply_upcall(ep, status2errno(rpl->status));
1171         state_set(&ep->com, DEAD);
1172         if (ep->com.tdev->type != T3A && act_open_has_tid(rpl->status))
1173                 release_tid(ep->com.tdev, GET_TID(rpl), NULL);
1174         cxgb3_free_atid(ep->com.tdev, ep->atid);
1175         dst_release(ep->dst);
1176         l2t_release(L2DATA(ep->com.tdev), ep->l2t);
1177         put_ep(&ep->com);
1178         return CPL_RET_BUF_DONE;
1179 }
1180
1181 static int listen_start(struct iwch_listen_ep *ep)
1182 {
1183         struct sk_buff *skb;
1184         struct cpl_pass_open_req *req;
1185
1186         PDBG("%s ep %p\n", __func__, ep);
1187         skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
1188         if (!skb) {
1189                 printk(KERN_ERR MOD "t3c_listen_start failed to alloc skb!\n");
1190                 return -ENOMEM;
1191         }
1192
1193         req = (struct cpl_pass_open_req *) skb_put(skb, sizeof(*req));
1194         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1195         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_PASS_OPEN_REQ, ep->stid));
1196         req->local_port = ep->com.local_addr.sin_port;
1197         req->local_ip = ep->com.local_addr.sin_addr.s_addr;
1198         req->peer_port = 0;
1199         req->peer_ip = 0;
1200         req->peer_netmask = 0;
1201         req->opt0h = htonl(F_DELACK | F_TCAM_BYPASS);
1202         req->opt0l = htonl(V_RCV_BUFSIZ(rcv_win>>10));
1203         req->opt1 = htonl(V_CONN_POLICY(CPL_CONN_POLICY_ASK));
1204
1205         skb->priority = 1;
1206         cxgb3_ofld_send(ep->com.tdev, skb);
1207         return 0;
1208 }
1209
1210 static int pass_open_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1211 {
1212         struct iwch_listen_ep *ep = ctx;
1213         struct cpl_pass_open_rpl *rpl = cplhdr(skb);
1214
1215         PDBG("%s ep %p status %d error %d\n", __func__, ep,
1216              rpl->status, status2errno(rpl->status));
1217         ep->com.rpl_err = status2errno(rpl->status);
1218         ep->com.rpl_done = 1;
1219         wake_up(&ep->com.waitq);
1220
1221         return CPL_RET_BUF_DONE;
1222 }
1223
1224 static int listen_stop(struct iwch_listen_ep *ep)
1225 {
1226         struct sk_buff *skb;
1227         struct cpl_close_listserv_req *req;
1228
1229         PDBG("%s ep %p\n", __func__, ep);
1230         skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
1231         if (!skb) {
1232                 printk(KERN_ERR MOD "%s - failed to alloc skb\n", __func__);
1233                 return -ENOMEM;
1234         }
1235         req = (struct cpl_close_listserv_req *) skb_put(skb, sizeof(*req));
1236         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1237         req->cpu_idx = 0;
1238         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_CLOSE_LISTSRV_REQ, ep->stid));
1239         skb->priority = 1;
1240         cxgb3_ofld_send(ep->com.tdev, skb);
1241         return 0;
1242 }
1243
1244 static int close_listsrv_rpl(struct t3cdev *tdev, struct sk_buff *skb,
1245                              void *ctx)
1246 {
1247         struct iwch_listen_ep *ep = ctx;
1248         struct cpl_close_listserv_rpl *rpl = cplhdr(skb);
1249
1250         PDBG("%s ep %p\n", __func__, ep);
1251         ep->com.rpl_err = status2errno(rpl->status);
1252         ep->com.rpl_done = 1;
1253         wake_up(&ep->com.waitq);
1254         return CPL_RET_BUF_DONE;
1255 }
1256
1257 static void accept_cr(struct iwch_ep *ep, __be32 peer_ip, struct sk_buff *skb)
1258 {
1259         struct cpl_pass_accept_rpl *rpl;
1260         unsigned int mtu_idx;
1261         u32 opt0h, opt0l, opt2;
1262         int wscale;
1263
1264         PDBG("%s ep %p\n", __func__, ep);
1265         BUG_ON(skb_cloned(skb));
1266         skb_trim(skb, sizeof(*rpl));
1267         skb_get(skb);
1268         mtu_idx = find_best_mtu(T3C_DATA(ep->com.tdev), dst_mtu(ep->dst));
1269         wscale = compute_wscale(rcv_win);
1270         opt0h = V_NAGLE(0) |
1271             V_NO_CONG(nocong) |
1272             V_KEEP_ALIVE(1) |
1273             F_TCAM_BYPASS |
1274             V_WND_SCALE(wscale) |
1275             V_MSS_IDX(mtu_idx) |
1276             V_L2T_IDX(ep->l2t->idx) | V_TX_CHANNEL(ep->l2t->smt_idx);
1277         opt0l = V_TOS((ep->tos >> 2) & M_TOS) | V_RCV_BUFSIZ(rcv_win>>10);
1278         opt2 = V_FLAVORS_VALID(1) | V_CONG_CONTROL_FLAVOR(cong_flavor);
1279
1280         rpl = cplhdr(skb);
1281         rpl->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1282         OPCODE_TID(rpl) = htonl(MK_OPCODE_TID(CPL_PASS_ACCEPT_RPL, ep->hwtid));
1283         rpl->peer_ip = peer_ip;
1284         rpl->opt0h = htonl(opt0h);
1285         rpl->opt0l_status = htonl(opt0l | CPL_PASS_OPEN_ACCEPT);
1286         rpl->opt2 = htonl(opt2);
1287         rpl->rsvd = rpl->opt2;  /* workaround for HW bug */
1288         skb->priority = CPL_PRIORITY_SETUP;
1289         l2t_send(ep->com.tdev, skb, ep->l2t);
1290
1291         return;
1292 }
1293
1294 static void reject_cr(struct t3cdev *tdev, u32 hwtid, __be32 peer_ip,
1295                       struct sk_buff *skb)
1296 {
1297         PDBG("%s t3cdev %p tid %u peer_ip %x\n", __func__, tdev, hwtid,
1298              peer_ip);
1299         BUG_ON(skb_cloned(skb));
1300         skb_trim(skb, sizeof(struct cpl_tid_release));
1301         skb_get(skb);
1302
1303         if (tdev->type != T3A)
1304                 release_tid(tdev, hwtid, skb);
1305         else {
1306                 struct cpl_pass_accept_rpl *rpl;
1307
1308                 rpl = cplhdr(skb);
1309                 skb->priority = CPL_PRIORITY_SETUP;
1310                 rpl->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
1311                 OPCODE_TID(rpl) = htonl(MK_OPCODE_TID(CPL_PASS_ACCEPT_RPL,
1312                                                       hwtid));
1313                 rpl->peer_ip = peer_ip;
1314                 rpl->opt0h = htonl(F_TCAM_BYPASS);
1315                 rpl->opt0l_status = htonl(CPL_PASS_OPEN_REJECT);
1316                 rpl->opt2 = 0;
1317                 rpl->rsvd = rpl->opt2;
1318                 cxgb3_ofld_send(tdev, skb);
1319         }
1320 }
1321
1322 static int pass_accept_req(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1323 {
1324         struct iwch_ep *child_ep, *parent_ep = ctx;
1325         struct cpl_pass_accept_req *req = cplhdr(skb);
1326         unsigned int hwtid = GET_TID(req);
1327         struct dst_entry *dst;
1328         struct l2t_entry *l2t;
1329         struct rtable *rt;
1330         struct iff_mac tim;
1331
1332         PDBG("%s parent ep %p tid %u\n", __func__, parent_ep, hwtid);
1333
1334         if (state_read(&parent_ep->com) != LISTEN) {
1335                 printk(KERN_ERR "%s - listening ep not in LISTEN\n",
1336                        __func__);
1337                 goto reject;
1338         }
1339
1340         /*
1341          * Find the netdev for this connection request.
1342          */
1343         tim.mac_addr = req->dst_mac;
1344         tim.vlan_tag = ntohs(req->vlan_tag);
1345         if (tdev->ctl(tdev, GET_IFF_FROM_MAC, &tim) < 0 || !tim.dev) {
1346                 printk(KERN_ERR
1347                         "%s bad dst mac %02x %02x %02x %02x %02x %02x\n",
1348                         __func__,
1349                         req->dst_mac[0],
1350                         req->dst_mac[1],
1351                         req->dst_mac[2],
1352                         req->dst_mac[3],
1353                         req->dst_mac[4],
1354                         req->dst_mac[5]);
1355                 goto reject;
1356         }
1357
1358         /* Find output route */
1359         rt = find_route(tdev,
1360                         req->local_ip,
1361                         req->peer_ip,
1362                         req->local_port,
1363                         req->peer_port, G_PASS_OPEN_TOS(ntohl(req->tos_tid)));
1364         if (!rt) {
1365                 printk(KERN_ERR MOD "%s - failed to find dst entry!\n",
1366                        __func__);
1367                 goto reject;
1368         }
1369         dst = &rt->u.dst;
1370         l2t = t3_l2t_get(tdev, dst->neighbour, dst->neighbour->dev);
1371         if (!l2t) {
1372                 printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
1373                        __func__);
1374                 dst_release(dst);
1375                 goto reject;
1376         }
1377         child_ep = alloc_ep(sizeof(*child_ep), GFP_KERNEL);
1378         if (!child_ep) {
1379                 printk(KERN_ERR MOD "%s - failed to allocate ep entry!\n",
1380                        __func__);
1381                 l2t_release(L2DATA(tdev), l2t);
1382                 dst_release(dst);
1383                 goto reject;
1384         }
1385         state_set(&child_ep->com, CONNECTING);
1386         child_ep->com.tdev = tdev;
1387         child_ep->com.cm_id = NULL;
1388         child_ep->com.local_addr.sin_family = PF_INET;
1389         child_ep->com.local_addr.sin_port = req->local_port;
1390         child_ep->com.local_addr.sin_addr.s_addr = req->local_ip;
1391         child_ep->com.remote_addr.sin_family = PF_INET;
1392         child_ep->com.remote_addr.sin_port = req->peer_port;
1393         child_ep->com.remote_addr.sin_addr.s_addr = req->peer_ip;
1394         get_ep(&parent_ep->com);
1395         child_ep->parent_ep = parent_ep;
1396         child_ep->tos = G_PASS_OPEN_TOS(ntohl(req->tos_tid));
1397         child_ep->l2t = l2t;
1398         child_ep->dst = dst;
1399         child_ep->hwtid = hwtid;
1400         init_timer(&child_ep->timer);
1401         cxgb3_insert_tid(tdev, &t3c_client, child_ep, hwtid);
1402         accept_cr(child_ep, req->peer_ip, skb);
1403         goto out;
1404 reject:
1405         reject_cr(tdev, hwtid, req->peer_ip, skb);
1406 out:
1407         return CPL_RET_BUF_DONE;
1408 }
1409
1410 static int pass_establish(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1411 {
1412         struct iwch_ep *ep = ctx;
1413         struct cpl_pass_establish *req = cplhdr(skb);
1414
1415         PDBG("%s ep %p\n", __func__, ep);
1416         ep->snd_seq = ntohl(req->snd_isn);
1417         ep->rcv_seq = ntohl(req->rcv_isn);
1418
1419         set_emss(ep, ntohs(req->tcp_opt));
1420
1421         dst_confirm(ep->dst);
1422         state_set(&ep->com, MPA_REQ_WAIT);
1423         start_ep_timer(ep);
1424
1425         return CPL_RET_BUF_DONE;
1426 }
1427
1428 static int peer_close(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1429 {
1430         struct iwch_ep *ep = ctx;
1431         struct iwch_qp_attributes attrs;
1432         unsigned long flags;
1433         int disconnect = 1;
1434         int release = 0;
1435
1436         PDBG("%s ep %p\n", __func__, ep);
1437         dst_confirm(ep->dst);
1438
1439         spin_lock_irqsave(&ep->com.lock, flags);
1440         switch (ep->com.state) {
1441         case MPA_REQ_WAIT:
1442                 __state_set(&ep->com, CLOSING);
1443                 break;
1444         case MPA_REQ_SENT:
1445                 __state_set(&ep->com, CLOSING);
1446                 connect_reply_upcall(ep, -ECONNRESET);
1447                 break;
1448         case MPA_REQ_RCVD:
1449
1450                 /*
1451                  * We're gonna mark this puppy DEAD, but keep
1452                  * the reference on it until the ULP accepts or
1453                  * rejects the CR.
1454                  */
1455                 __state_set(&ep->com, CLOSING);
1456                 get_ep(&ep->com);
1457                 break;
1458         case MPA_REP_SENT:
1459                 __state_set(&ep->com, CLOSING);
1460                 ep->com.rpl_done = 1;
1461                 ep->com.rpl_err = -ECONNRESET;
1462                 PDBG("waking up ep %p\n", ep);
1463                 wake_up(&ep->com.waitq);
1464                 break;
1465         case FPDU_MODE:
1466                 start_ep_timer(ep);
1467                 __state_set(&ep->com, CLOSING);
1468                 attrs.next_state = IWCH_QP_STATE_CLOSING;
1469                 iwch_modify_qp(ep->com.qp->rhp, ep->com.qp,
1470                                IWCH_QP_ATTR_NEXT_STATE, &attrs, 1);
1471                 peer_close_upcall(ep);
1472                 break;
1473         case ABORTING:
1474                 disconnect = 0;
1475                 break;
1476         case CLOSING:
1477                 __state_set(&ep->com, MORIBUND);
1478                 disconnect = 0;
1479                 break;
1480         case MORIBUND:
1481                 stop_ep_timer(ep);
1482                 if (ep->com.cm_id && ep->com.qp) {
1483                         attrs.next_state = IWCH_QP_STATE_IDLE;
1484                         iwch_modify_qp(ep->com.qp->rhp, ep->com.qp,
1485                                        IWCH_QP_ATTR_NEXT_STATE, &attrs, 1);
1486                 }
1487                 close_complete_upcall(ep);
1488                 __state_set(&ep->com, DEAD);
1489                 release = 1;
1490                 disconnect = 0;
1491                 break;
1492         case DEAD:
1493                 disconnect = 0;
1494                 break;
1495         default:
1496                 BUG_ON(1);
1497         }
1498         spin_unlock_irqrestore(&ep->com.lock, flags);
1499         if (disconnect)
1500                 iwch_ep_disconnect(ep, 0, GFP_KERNEL);
1501         if (release)
1502                 release_ep_resources(ep);
1503         return CPL_RET_BUF_DONE;
1504 }
1505
1506 /*
1507  * Returns whether an ABORT_REQ_RSS message is a negative advice.
1508  */
1509 static int is_neg_adv_abort(unsigned int status)
1510 {
1511         return status == CPL_ERR_RTX_NEG_ADVICE ||
1512                status == CPL_ERR_PERSIST_NEG_ADVICE;
1513 }
1514
1515 static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1516 {
1517         struct cpl_abort_req_rss *req = cplhdr(skb);
1518         struct iwch_ep *ep = ctx;
1519         struct cpl_abort_rpl *rpl;
1520         struct sk_buff *rpl_skb;
1521         struct iwch_qp_attributes attrs;
1522         int ret;
1523         int release = 0;
1524         unsigned long flags;
1525
1526         if (is_neg_adv_abort(req->status)) {
1527                 PDBG("%s neg_adv_abort ep %p tid %d\n", __func__, ep,
1528                      ep->hwtid);
1529                 t3_l2t_send_event(ep->com.tdev, ep->l2t);
1530                 return CPL_RET_BUF_DONE;
1531         }
1532
1533         /*
1534          * We get 2 peer aborts from the HW.  The first one must
1535          * be ignored except for scribbling that we need one more.
1536          */
1537         if (!(ep->flags & PEER_ABORT_IN_PROGRESS)) {
1538                 ep->flags |= PEER_ABORT_IN_PROGRESS;
1539                 return CPL_RET_BUF_DONE;
1540         }
1541
1542         spin_lock_irqsave(&ep->com.lock, flags);
1543         PDBG("%s ep %p state %u\n", __func__, ep, ep->com.state);
1544         switch (ep->com.state) {
1545         case CONNECTING:
1546                 break;
1547         case MPA_REQ_WAIT:
1548                 stop_ep_timer(ep);
1549                 break;
1550         case MPA_REQ_SENT:
1551                 stop_ep_timer(ep);
1552                 connect_reply_upcall(ep, -ECONNRESET);
1553                 break;
1554         case MPA_REP_SENT:
1555                 ep->com.rpl_done = 1;
1556                 ep->com.rpl_err = -ECONNRESET;
1557                 PDBG("waking up ep %p\n", ep);
1558                 wake_up(&ep->com.waitq);
1559                 break;
1560         case MPA_REQ_RCVD:
1561
1562                 /*
1563                  * We're gonna mark this puppy DEAD, but keep
1564                  * the reference on it until the ULP accepts or
1565                  * rejects the CR.
1566                  */
1567                 get_ep(&ep->com);
1568                 break;
1569         case MORIBUND:
1570         case CLOSING:
1571                 stop_ep_timer(ep);
1572                 /*FALLTHROUGH*/
1573         case FPDU_MODE:
1574                 if (ep->com.cm_id && ep->com.qp) {
1575                         attrs.next_state = IWCH_QP_STATE_ERROR;
1576                         ret = iwch_modify_qp(ep->com.qp->rhp,
1577                                      ep->com.qp, IWCH_QP_ATTR_NEXT_STATE,
1578                                      &attrs, 1);
1579                         if (ret)
1580                                 printk(KERN_ERR MOD
1581                                        "%s - qp <- error failed!\n",
1582                                        __func__);
1583                 }
1584                 peer_abort_upcall(ep);
1585                 break;
1586         case ABORTING:
1587                 break;
1588         case DEAD:
1589                 PDBG("%s PEER_ABORT IN DEAD STATE!!!!\n", __func__);
1590                 spin_unlock_irqrestore(&ep->com.lock, flags);
1591                 return CPL_RET_BUF_DONE;
1592         default:
1593                 BUG_ON(1);
1594                 break;
1595         }
1596         dst_confirm(ep->dst);
1597         if (ep->com.state != ABORTING) {
1598                 __state_set(&ep->com, DEAD);
1599                 release = 1;
1600         }
1601         spin_unlock_irqrestore(&ep->com.lock, flags);
1602
1603         rpl_skb = get_skb(skb, sizeof(*rpl), GFP_KERNEL);
1604         if (!rpl_skb) {
1605                 printk(KERN_ERR MOD "%s - cannot allocate skb!\n",
1606                        __func__);
1607                 release = 1;
1608                 goto out;
1609         }
1610         rpl_skb->priority = CPL_PRIORITY_DATA;
1611         rpl = (struct cpl_abort_rpl *) skb_put(rpl_skb, sizeof(*rpl));
1612         rpl->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_OFLD_HOST_ABORT_CON_RPL));
1613         rpl->wr.wr_lo = htonl(V_WR_TID(ep->hwtid));
1614         OPCODE_TID(rpl) = htonl(MK_OPCODE_TID(CPL_ABORT_RPL, ep->hwtid));
1615         rpl->cmd = CPL_ABORT_NO_RST;
1616         cxgb3_ofld_send(ep->com.tdev, rpl_skb);
1617 out:
1618         if (release)
1619                 release_ep_resources(ep);
1620         return CPL_RET_BUF_DONE;
1621 }
1622
1623 static int close_con_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1624 {
1625         struct iwch_ep *ep = ctx;
1626         struct iwch_qp_attributes attrs;
1627         unsigned long flags;
1628         int release = 0;
1629
1630         PDBG("%s ep %p\n", __func__, ep);
1631         BUG_ON(!ep);
1632
1633         /* The cm_id may be null if we failed to connect */
1634         spin_lock_irqsave(&ep->com.lock, flags);
1635         switch (ep->com.state) {
1636         case CLOSING:
1637                 __state_set(&ep->com, MORIBUND);
1638                 break;
1639         case MORIBUND:
1640                 stop_ep_timer(ep);
1641                 if ((ep->com.cm_id) && (ep->com.qp)) {
1642                         attrs.next_state = IWCH_QP_STATE_IDLE;
1643                         iwch_modify_qp(ep->com.qp->rhp,
1644                                              ep->com.qp,
1645                                              IWCH_QP_ATTR_NEXT_STATE,
1646                                              &attrs, 1);
1647                 }
1648                 close_complete_upcall(ep);
1649                 __state_set(&ep->com, DEAD);
1650                 release = 1;
1651                 break;
1652         case ABORTING:
1653         case DEAD:
1654                 break;
1655         default:
1656                 BUG_ON(1);
1657                 break;
1658         }
1659         spin_unlock_irqrestore(&ep->com.lock, flags);
1660         if (release)
1661                 release_ep_resources(ep);
1662         return CPL_RET_BUF_DONE;
1663 }
1664
1665 /*
1666  * T3A does 3 things when a TERM is received:
1667  * 1) send up a CPL_RDMA_TERMINATE message with the TERM packet
1668  * 2) generate an async event on the QP with the TERMINATE opcode
1669  * 3) post a TERMINATE opcde cqe into the associated CQ.
1670  *
1671  * For (1), we save the message in the qp for later consumer consumption.
1672  * For (2), we move the QP into TERMINATE, post a QP event and disconnect.
1673  * For (3), we toss the CQE in cxio_poll_cq().
1674  *
1675  * terminate() handles case (1)...
1676  */
1677 static int terminate(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1678 {
1679         struct iwch_ep *ep = ctx;
1680
1681         PDBG("%s ep %p\n", __func__, ep);
1682         skb_pull(skb, sizeof(struct cpl_rdma_terminate));
1683         PDBG("%s saving %d bytes of term msg\n", __func__, skb->len);
1684         skb_copy_from_linear_data(skb, ep->com.qp->attr.terminate_buffer,
1685                                   skb->len);
1686         ep->com.qp->attr.terminate_msg_len = skb->len;
1687         ep->com.qp->attr.is_terminate_local = 0;
1688         return CPL_RET_BUF_DONE;
1689 }
1690
1691 static int ec_status(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
1692 {
1693         struct cpl_rdma_ec_status *rep = cplhdr(skb);
1694         struct iwch_ep *ep = ctx;
1695
1696         PDBG("%s ep %p tid %u status %d\n", __func__, ep, ep->hwtid,
1697              rep->status);
1698         if (rep->status) {
1699                 struct iwch_qp_attributes attrs;
1700
1701                 printk(KERN_ERR MOD "%s BAD CLOSE - Aborting tid %u\n",
1702                        __func__, ep->hwtid);
1703                 stop_ep_timer(ep);
1704                 attrs.next_state = IWCH_QP_STATE_ERROR;
1705                 iwch_modify_qp(ep->com.qp->rhp,
1706                                ep->com.qp, IWCH_QP_ATTR_NEXT_STATE,
1707                                &attrs, 1);
1708                 abort_connection(ep, NULL, GFP_KERNEL);
1709         }
1710         return CPL_RET_BUF_DONE;
1711 }
1712
1713 static void ep_timeout(unsigned long arg)
1714 {
1715         struct iwch_ep *ep = (struct iwch_ep *)arg;
1716         struct iwch_qp_attributes attrs;
1717         unsigned long flags;
1718         int abort = 1;
1719
1720         spin_lock_irqsave(&ep->com.lock, flags);
1721         PDBG("%s ep %p tid %u state %d\n", __func__, ep, ep->hwtid,
1722              ep->com.state);
1723         switch (ep->com.state) {
1724         case MPA_REQ_SENT:
1725                 __state_set(&ep->com, ABORTING);
1726                 connect_reply_upcall(ep, -ETIMEDOUT);
1727                 break;
1728         case MPA_REQ_WAIT:
1729                 __state_set(&ep->com, ABORTING);
1730                 break;
1731         case CLOSING:
1732         case MORIBUND:
1733                 if (ep->com.cm_id && ep->com.qp) {
1734                         attrs.next_state = IWCH_QP_STATE_ERROR;
1735                         iwch_modify_qp(ep->com.qp->rhp,
1736                                      ep->com.qp, IWCH_QP_ATTR_NEXT_STATE,
1737                                      &attrs, 1);
1738                 }
1739                 __state_set(&ep->com, ABORTING);
1740                 break;
1741         default:
1742                 printk(KERN_ERR "%s unexpected state ep %p state %u\n",
1743                         __func__, ep, ep->com.state);
1744                 WARN_ON(1);
1745                 abort = 0;
1746         }
1747         spin_unlock_irqrestore(&ep->com.lock, flags);
1748         if (abort)
1749                 abort_connection(ep, NULL, GFP_ATOMIC);
1750         put_ep(&ep->com);
1751 }
1752
1753 int iwch_reject_cr(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
1754 {
1755         int err;
1756         struct iwch_ep *ep = to_ep(cm_id);
1757         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1758
1759         if (state_read(&ep->com) == DEAD) {
1760                 put_ep(&ep->com);
1761                 return -ECONNRESET;
1762         }
1763         BUG_ON(state_read(&ep->com) != MPA_REQ_RCVD);
1764         if (mpa_rev == 0)
1765                 abort_connection(ep, NULL, GFP_KERNEL);
1766         else {
1767                 err = send_mpa_reject(ep, pdata, pdata_len);
1768                 err = iwch_ep_disconnect(ep, 0, GFP_KERNEL);
1769         }
1770         return 0;
1771 }
1772
1773 int iwch_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
1774 {
1775         int err;
1776         struct iwch_qp_attributes attrs;
1777         enum iwch_qp_attr_mask mask;
1778         struct iwch_ep *ep = to_ep(cm_id);
1779         struct iwch_dev *h = to_iwch_dev(cm_id->device);
1780         struct iwch_qp *qp = get_qhp(h, conn_param->qpn);
1781
1782         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1783         if (state_read(&ep->com) == DEAD)
1784                 return -ECONNRESET;
1785
1786         BUG_ON(state_read(&ep->com) != MPA_REQ_RCVD);
1787         BUG_ON(!qp);
1788
1789         if ((conn_param->ord > qp->rhp->attr.max_rdma_read_qp_depth) ||
1790             (conn_param->ird > qp->rhp->attr.max_rdma_reads_per_qp)) {
1791                 abort_connection(ep, NULL, GFP_KERNEL);
1792                 return -EINVAL;
1793         }
1794
1795         cm_id->add_ref(cm_id);
1796         ep->com.cm_id = cm_id;
1797         ep->com.qp = qp;
1798
1799         ep->com.rpl_done = 0;
1800         ep->com.rpl_err = 0;
1801         ep->ird = conn_param->ird;
1802         ep->ord = conn_param->ord;
1803         PDBG("%s %d ird %d ord %d\n", __func__, __LINE__, ep->ird, ep->ord);
1804
1805         get_ep(&ep->com);
1806
1807         /* bind QP to EP and move to RTS */
1808         attrs.mpa_attr = ep->mpa_attr;
1809         attrs.max_ird = ep->ird;
1810         attrs.max_ord = ep->ord;
1811         attrs.llp_stream_handle = ep;
1812         attrs.next_state = IWCH_QP_STATE_RTS;
1813
1814         /* bind QP and TID with INIT_WR */
1815         mask = IWCH_QP_ATTR_NEXT_STATE |
1816                              IWCH_QP_ATTR_LLP_STREAM_HANDLE |
1817                              IWCH_QP_ATTR_MPA_ATTR |
1818                              IWCH_QP_ATTR_MAX_IRD |
1819                              IWCH_QP_ATTR_MAX_ORD;
1820
1821         err = iwch_modify_qp(ep->com.qp->rhp,
1822                              ep->com.qp, mask, &attrs, 1);
1823         if (err)
1824                 goto err;
1825
1826         /* if needed, wait for wr_ack */
1827         if (iwch_rqes_posted(qp)) {
1828                 wait_event(ep->com.waitq, ep->com.rpl_done);
1829                 err = ep->com.rpl_err;
1830                 if (err)
1831                         goto err;
1832         }
1833
1834         err = send_mpa_reply(ep, conn_param->private_data,
1835                              conn_param->private_data_len);
1836         if (err)
1837                 goto err;
1838
1839
1840         state_set(&ep->com, FPDU_MODE);
1841         established_upcall(ep);
1842         put_ep(&ep->com);
1843         return 0;
1844 err:
1845         ep->com.cm_id = NULL;
1846         ep->com.qp = NULL;
1847         cm_id->rem_ref(cm_id);
1848         put_ep(&ep->com);
1849         return err;
1850 }
1851
1852 static int is_loopback_dst(struct iw_cm_id *cm_id)
1853 {
1854         struct net_device *dev;
1855
1856         dev = ip_dev_find(&init_net, cm_id->remote_addr.sin_addr.s_addr);
1857         if (!dev)
1858                 return 0;
1859         dev_put(dev);
1860         return 1;
1861 }
1862
1863 int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
1864 {
1865         int err = 0;
1866         struct iwch_dev *h = to_iwch_dev(cm_id->device);
1867         struct iwch_ep *ep;
1868         struct rtable *rt;
1869
1870         if (is_loopback_dst(cm_id)) {
1871                 err = -ENOSYS;
1872                 goto out;
1873         }
1874
1875         ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
1876         if (!ep) {
1877                 printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
1878                 err = -ENOMEM;
1879                 goto out;
1880         }
1881         init_timer(&ep->timer);
1882         ep->plen = conn_param->private_data_len;
1883         if (ep->plen)
1884                 memcpy(ep->mpa_pkt + sizeof(struct mpa_message),
1885                        conn_param->private_data, ep->plen);
1886         ep->ird = conn_param->ird;
1887         ep->ord = conn_param->ord;
1888         ep->com.tdev = h->rdev.t3cdev_p;
1889
1890         cm_id->add_ref(cm_id);
1891         ep->com.cm_id = cm_id;
1892         ep->com.qp = get_qhp(h, conn_param->qpn);
1893         BUG_ON(!ep->com.qp);
1894         PDBG("%s qpn 0x%x qp %p cm_id %p\n", __func__, conn_param->qpn,
1895              ep->com.qp, cm_id);
1896
1897         /*
1898          * Allocate an active TID to initiate a TCP connection.
1899          */
1900         ep->atid = cxgb3_alloc_atid(h->rdev.t3cdev_p, &t3c_client, ep);
1901         if (ep->atid == -1) {
1902                 printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __func__);
1903                 err = -ENOMEM;
1904                 goto fail2;
1905         }
1906
1907         /* find a route */
1908         rt = find_route(h->rdev.t3cdev_p,
1909                         cm_id->local_addr.sin_addr.s_addr,
1910                         cm_id->remote_addr.sin_addr.s_addr,
1911                         cm_id->local_addr.sin_port,
1912                         cm_id->remote_addr.sin_port, IPTOS_LOWDELAY);
1913         if (!rt) {
1914                 printk(KERN_ERR MOD "%s - cannot find route.\n", __func__);
1915                 err = -EHOSTUNREACH;
1916                 goto fail3;
1917         }
1918         ep->dst = &rt->u.dst;
1919
1920         /* get a l2t entry */
1921         ep->l2t = t3_l2t_get(ep->com.tdev, ep->dst->neighbour,
1922                              ep->dst->neighbour->dev);
1923         if (!ep->l2t) {
1924                 printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
1925                 err = -ENOMEM;
1926                 goto fail4;
1927         }
1928
1929         state_set(&ep->com, CONNECTING);
1930         ep->tos = IPTOS_LOWDELAY;
1931         ep->com.local_addr = cm_id->local_addr;
1932         ep->com.remote_addr = cm_id->remote_addr;
1933
1934         /* send connect request to rnic */
1935         err = send_connect(ep);
1936         if (!err)
1937                 goto out;
1938
1939         l2t_release(L2DATA(h->rdev.t3cdev_p), ep->l2t);
1940 fail4:
1941         dst_release(ep->dst);
1942 fail3:
1943         cxgb3_free_atid(ep->com.tdev, ep->atid);
1944 fail2:
1945         put_ep(&ep->com);
1946 out:
1947         return err;
1948 }
1949
1950 int iwch_create_listen(struct iw_cm_id *cm_id, int backlog)
1951 {
1952         int err = 0;
1953         struct iwch_dev *h = to_iwch_dev(cm_id->device);
1954         struct iwch_listen_ep *ep;
1955
1956
1957         might_sleep();
1958
1959         ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
1960         if (!ep) {
1961                 printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
1962                 err = -ENOMEM;
1963                 goto fail1;
1964         }
1965         PDBG("%s ep %p\n", __func__, ep);
1966         ep->com.tdev = h->rdev.t3cdev_p;
1967         cm_id->add_ref(cm_id);
1968         ep->com.cm_id = cm_id;
1969         ep->backlog = backlog;
1970         ep->com.local_addr = cm_id->local_addr;
1971
1972         /*
1973          * Allocate a server TID.
1974          */
1975         ep->stid = cxgb3_alloc_stid(h->rdev.t3cdev_p, &t3c_client, ep);
1976         if (ep->stid == -1) {
1977                 printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __func__);
1978                 err = -ENOMEM;
1979                 goto fail2;
1980         }
1981
1982         state_set(&ep->com, LISTEN);
1983         err = listen_start(ep);
1984         if (err)
1985                 goto fail3;
1986
1987         /* wait for pass_open_rpl */
1988         wait_event(ep->com.waitq, ep->com.rpl_done);
1989         err = ep->com.rpl_err;
1990         if (!err) {
1991                 cm_id->provider_data = ep;
1992                 goto out;
1993         }
1994 fail3:
1995         cxgb3_free_stid(ep->com.tdev, ep->stid);
1996 fail2:
1997         cm_id->rem_ref(cm_id);
1998         put_ep(&ep->com);
1999 fail1:
2000 out:
2001         return err;
2002 }
2003
2004 int iwch_destroy_listen(struct iw_cm_id *cm_id)
2005 {
2006         int err;
2007         struct iwch_listen_ep *ep = to_listen_ep(cm_id);
2008
2009         PDBG("%s ep %p\n", __func__, ep);
2010
2011         might_sleep();
2012         state_set(&ep->com, DEAD);
2013         ep->com.rpl_done = 0;
2014         ep->com.rpl_err = 0;
2015         err = listen_stop(ep);
2016         wait_event(ep->com.waitq, ep->com.rpl_done);
2017         cxgb3_free_stid(ep->com.tdev, ep->stid);
2018         err = ep->com.rpl_err;
2019         cm_id->rem_ref(cm_id);
2020         put_ep(&ep->com);
2021         return err;
2022 }
2023
2024 int iwch_ep_disconnect(struct iwch_ep *ep, int abrupt, gfp_t gfp)
2025 {
2026         int ret=0;
2027         unsigned long flags;
2028         int close = 0;
2029
2030         spin_lock_irqsave(&ep->com.lock, flags);
2031
2032         PDBG("%s ep %p state %s, abrupt %d\n", __func__, ep,
2033              states[ep->com.state], abrupt);
2034
2035         switch (ep->com.state) {
2036         case MPA_REQ_WAIT:
2037         case MPA_REQ_SENT:
2038         case MPA_REQ_RCVD:
2039         case MPA_REP_SENT:
2040         case FPDU_MODE:
2041                 close = 1;
2042                 if (abrupt)
2043                         ep->com.state = ABORTING;
2044                 else {
2045                         ep->com.state = CLOSING;
2046                         start_ep_timer(ep);
2047                 }
2048                 break;
2049         case CLOSING:
2050                 close = 1;
2051                 if (abrupt) {
2052                         stop_ep_timer(ep);
2053                         ep->com.state = ABORTING;
2054                 } else
2055                         ep->com.state = MORIBUND;
2056                 break;
2057         case MORIBUND:
2058         case ABORTING:
2059         case DEAD:
2060                 PDBG("%s ignoring disconnect ep %p state %u\n",
2061                      __func__, ep, ep->com.state);
2062                 break;
2063         default:
2064                 BUG();
2065                 break;
2066         }
2067
2068         spin_unlock_irqrestore(&ep->com.lock, flags);
2069         if (close) {
2070                 if (abrupt)
2071                         ret = send_abort(ep, NULL, gfp);
2072                 else
2073                         ret = send_halfclose(ep, gfp);
2074         }
2075         return ret;
2076 }
2077
2078 int iwch_ep_redirect(void *ctx, struct dst_entry *old, struct dst_entry *new,
2079                      struct l2t_entry *l2t)
2080 {
2081         struct iwch_ep *ep = ctx;
2082
2083         if (ep->dst != old)
2084                 return 0;
2085
2086         PDBG("%s ep %p redirect to dst %p l2t %p\n", __func__, ep, new,
2087              l2t);
2088         dst_hold(new);
2089         l2t_release(L2DATA(ep->com.tdev), ep->l2t);
2090         ep->l2t = l2t;
2091         dst_release(old);
2092         ep->dst = new;
2093         return 1;
2094 }
2095
2096 /*
2097  * All the CM events are handled on a work queue to have a safe context.
2098  */
2099 static int sched(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
2100 {
2101         struct iwch_ep_common *epc = ctx;
2102
2103         get_ep(epc);
2104
2105         /*
2106          * Save ctx and tdev in the skb->cb area.
2107          */
2108         *((void **) skb->cb) = ctx;
2109         *((struct t3cdev **) (skb->cb + sizeof(void *))) = tdev;
2110
2111         /*
2112          * Queue the skb and schedule the worker thread.
2113          */
2114         skb_queue_tail(&rxq, skb);
2115         queue_work(workq, &skb_work);
2116         return 0;
2117 }
2118
2119 static int set_tcb_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
2120 {
2121         struct cpl_set_tcb_rpl *rpl = cplhdr(skb);
2122
2123         if (rpl->status != CPL_ERR_NONE) {
2124                 printk(KERN_ERR MOD "Unexpected SET_TCB_RPL status %u "
2125                        "for tid %u\n", rpl->status, GET_TID(rpl));
2126         }
2127         return CPL_RET_BUF_DONE;
2128 }
2129
2130 int __init iwch_cm_init(void)
2131 {
2132         skb_queue_head_init(&rxq);
2133
2134         workq = create_singlethread_workqueue("iw_cxgb3");
2135         if (!workq)
2136                 return -ENOMEM;
2137
2138         /*
2139          * All upcalls from the T3 Core go to sched() to
2140          * schedule the processing on a work queue.
2141          */
2142         t3c_handlers[CPL_ACT_ESTABLISH] = sched;
2143         t3c_handlers[CPL_ACT_OPEN_RPL] = sched;
2144         t3c_handlers[CPL_RX_DATA] = sched;
2145         t3c_handlers[CPL_TX_DMA_ACK] = sched;
2146         t3c_handlers[CPL_ABORT_RPL_RSS] = sched;
2147         t3c_handlers[CPL_ABORT_RPL] = sched;
2148         t3c_handlers[CPL_PASS_OPEN_RPL] = sched;
2149         t3c_handlers[CPL_CLOSE_LISTSRV_RPL] = sched;
2150         t3c_handlers[CPL_PASS_ACCEPT_REQ] = sched;
2151         t3c_handlers[CPL_PASS_ESTABLISH] = sched;
2152         t3c_handlers[CPL_PEER_CLOSE] = sched;
2153         t3c_handlers[CPL_CLOSE_CON_RPL] = sched;
2154         t3c_handlers[CPL_ABORT_REQ_RSS] = sched;
2155         t3c_handlers[CPL_RDMA_TERMINATE] = sched;
2156         t3c_handlers[CPL_RDMA_EC_STATUS] = sched;
2157         t3c_handlers[CPL_SET_TCB_RPL] = set_tcb_rpl;
2158
2159         /*
2160          * These are the real handlers that are called from a
2161          * work queue.
2162          */
2163         work_handlers[CPL_ACT_ESTABLISH] = act_establish;
2164         work_handlers[CPL_ACT_OPEN_RPL] = act_open_rpl;
2165         work_handlers[CPL_RX_DATA] = rx_data;
2166         work_handlers[CPL_TX_DMA_ACK] = tx_ack;
2167         work_handlers[CPL_ABORT_RPL_RSS] = abort_rpl;
2168         work_handlers[CPL_ABORT_RPL] = abort_rpl;
2169         work_handlers[CPL_PASS_OPEN_RPL] = pass_open_rpl;
2170         work_handlers[CPL_CLOSE_LISTSRV_RPL] = close_listsrv_rpl;
2171         work_handlers[CPL_PASS_ACCEPT_REQ] = pass_accept_req;
2172         work_handlers[CPL_PASS_ESTABLISH] = pass_establish;
2173         work_handlers[CPL_PEER_CLOSE] = peer_close;
2174         work_handlers[CPL_ABORT_REQ_RSS] = peer_abort;
2175         work_handlers[CPL_CLOSE_CON_RPL] = close_con_rpl;
2176         work_handlers[CPL_RDMA_TERMINATE] = terminate;
2177         work_handlers[CPL_RDMA_EC_STATUS] = ec_status;
2178         return 0;
2179 }
2180
2181 void __exit iwch_cm_term(void)
2182 {
2183         flush_workqueue(workq);
2184         destroy_workqueue(workq);
2185 }