SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 = 10;
  71 module_param(ep_timeout_secs, int, 0644);
  72 MODULE_PARM_DESC(ep_timeout_secs, "CM Endpoint operation timeout "
  73                                    "in seconds (default=10)");
  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 }