drivers/infiniband/hw/cxgb4/cm.c

   1 /*
   2  * Copyright (c) 2009-2014 Chelsio, Inc. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32 #include <linux/module.h>
  33 #include <linux/list.h>
  34 #include <linux/workqueue.h>
  35 #include <linux/skbuff.h>
  36 #include <linux/timer.h>
  37 #include <linux/notifier.h>
  38 #include <linux/inetdevice.h>
  39 #include <linux/ip.h>
  40 #include <linux/tcp.h>
  41 #include <linux/if_vlan.h>
  42
  43 #include <net/neighbour.h>
  44 #include <net/netevent.h>
  45 #include <net/route.h>
  46 #include <net/tcp.h>
  47 #include <net/ip6_route.h>
  48 #include <net/addrconf.h>
  49
  50 #include <rdma/ib_addr.h>
  51
  52 #include "iw_cxgb4.h"
  53 #include "clip_tbl.h"
  54
  55 static char *states[] = {
  56         "idle",
  57         "listen",
  58         "connecting",
  59         "mpa_wait_req",
  60         "mpa_req_sent",
  61         "mpa_req_rcvd",
  62         "mpa_rep_sent",
  63         "fpdu_mode",
  64         "aborting",
  65         "closing",
  66         "moribund",
  67         "dead",
  68         NULL,
  69 };
  70
  71 static int nocong;
  72 module_param(nocong, int, 0644);
  73 MODULE_PARM_DESC(nocong, "Turn of congestion control (default=0)");
  74
  75 static int enable_ecn;
  76 module_param(enable_ecn, int, 0644);
  77 MODULE_PARM_DESC(enable_ecn, "Enable ECN (default=0/disabled)");
  78
  79 static int dack_mode = 1;
  80 module_param(dack_mode, int, 0644);
  81 MODULE_PARM_DESC(dack_mode, "Delayed ack mode (default=1)");
  82
  83 uint c4iw_max_read_depth = 32;
  84 module_param(c4iw_max_read_depth, int, 0644);
  85 MODULE_PARM_DESC(c4iw_max_read_depth,
  86                  "Per-connection max ORD/IRD (default=32)");
  87
  88 static int enable_tcp_timestamps;
  89 module_param(enable_tcp_timestamps, int, 0644);
  90 MODULE_PARM_DESC(enable_tcp_timestamps, "Enable tcp timestamps (default=0)");
  91
  92 static int enable_tcp_sack;
  93 module_param(enable_tcp_sack, int, 0644);
  94 MODULE_PARM_DESC(enable_tcp_sack, "Enable tcp SACK (default=0)");
  95
  96 static int enable_tcp_window_scaling = 1;
  97 module_param(enable_tcp_window_scaling, int, 0644);
  98 MODULE_PARM_DESC(enable_tcp_window_scaling,
  99                  "Enable tcp window scaling (default=1)");
 100
 101 int c4iw_debug;
 102 module_param(c4iw_debug, int, 0644);
 103 MODULE_PARM_DESC(c4iw_debug, "Enable debug logging (default=0)");
 104
 105 static int peer2peer = 1;
 106 module_param(peer2peer, int, 0644);
 107 MODULE_PARM_DESC(peer2peer, "Support peer2peer ULPs (default=1)");
 108
 109 static int p2p_type = FW_RI_INIT_P2PTYPE_READ_REQ;
 110 module_param(p2p_type, int, 0644);
 111 MODULE_PARM_DESC(p2p_type, "RDMAP opcode to use for the RTR message: "
 112                            "1=RDMA_READ 0=RDMA_WRITE (default 1)");
 113
 114 static int ep_timeout_secs = 60;
 115 module_param(ep_timeout_secs, int, 0644);
 116 MODULE_PARM_DESC(ep_timeout_secs, "CM Endpoint operation timeout "
 117                                    "in seconds (default=60)");
 118
 119 static int mpa_rev = 2;
 120 module_param(mpa_rev, int, 0644);
 121 MODULE_PARM_DESC(mpa_rev, "MPA Revision, 0 supports amso1100, "
 122                 "1 is RFC0544 spec compliant, 2 is IETF MPA Peer Connect Draft"
 123                 " compliant (default=2)");
 124
 125 static int markers_enabled;
 126 module_param(markers_enabled, int, 0644);
 127 MODULE_PARM_DESC(markers_enabled, "Enable MPA MARKERS (default(0)=disabled)");
 128
 129 static int crc_enabled = 1;
 130 module_param(crc_enabled, int, 0644);
 131 MODULE_PARM_DESC(crc_enabled, "Enable MPA CRC (default(1)=enabled)");
 132
 133 static int rcv_win = 256 * 1024;
 134 module_param(rcv_win, int, 0644);
 135 MODULE_PARM_DESC(rcv_win, "TCP receive window in bytes (default=256KB)");
 136
 137 static int snd_win = 128 * 1024;
 138 module_param(snd_win, int, 0644);
 139 MODULE_PARM_DESC(snd_win, "TCP send window in bytes (default=128KB)");
 140
 141 static struct workqueue_struct *workq;
 142
 143 static struct sk_buff_head rxq;
 144
 145 static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp);
 146 static void ep_timeout(unsigned long arg);
 147 static void connect_reply_upcall(struct c4iw_ep *ep, int status);
 148
 149 static LIST_HEAD(timeout_list);
 150 static spinlock_t timeout_lock;
 151
 152 static void deref_qp(struct c4iw_ep *ep)
 153 {
 154         c4iw_qp_rem_ref(&ep->com.qp->ibqp);
 155         clear_bit(QP_REFERENCED, &ep->com.flags);
 156 }
 157
 158 static void ref_qp(struct c4iw_ep *ep)
 159 {
 160         set_bit(QP_REFERENCED, &ep->com.flags);
 161         c4iw_qp_add_ref(&ep->com.qp->ibqp);
 162 }
 163
 164 static void start_ep_timer(struct c4iw_ep *ep)
 165 {
 166         PDBG("%s ep %p\n", __func__, ep);
 167         if (timer_pending(&ep->timer)) {
 168                 pr_err("%s timer already started! ep %p\n",
 169                        __func__, ep);
 170                 return;
 171         }
 172         clear_bit(TIMEOUT, &ep->com.flags);
 173         c4iw_get_ep(&ep->com);
 174         ep->timer.expires = jiffies + ep_timeout_secs * HZ;
 175         ep->timer.data = (unsigned long)ep;
 176         ep->timer.function = ep_timeout;
 177         add_timer(&ep->timer);
 178 }
 179
 180 static int stop_ep_timer(struct c4iw_ep *ep)
 181 {
 182         PDBG("%s ep %p stopping\n", __func__, ep);
 183         del_timer_sync(&ep->timer);
 184         if (!test_and_set_bit(TIMEOUT, &ep->com.flags)) {
 185                 c4iw_put_ep(&ep->com);
 186                 return 0;
 187         }
 188         return 1;
 189 }
 190
 191 static int c4iw_l2t_send(struct c4iw_rdev *rdev, struct sk_buff *skb,
 192                   struct l2t_entry *l2e)
 193 {
 194         int     error = 0;
 195
 196         if (c4iw_fatal_error(rdev)) {
 197                 kfree_skb(skb);
 198                 PDBG("%s - device in error state - dropping\n", __func__);
 199                 return -EIO;
 200         }
 201         error = cxgb4_l2t_send(rdev->lldi.ports[0], skb, l2e);
 202         if (error < 0)
 203                 kfree_skb(skb);
 204         return error < 0 ? error : 0;
 205 }
 206
 207 int c4iw_ofld_send(struct c4iw_rdev *rdev, struct sk_buff *skb)
 208 {
 209         int     error = 0;
 210
 211         if (c4iw_fatal_error(rdev)) {
 212                 kfree_skb(skb);
 213                 PDBG("%s - device in error state - dropping\n", __func__);
 214                 return -EIO;
 215         }
 216         error = cxgb4_ofld_send(rdev->lldi.ports[0], skb);
 217         if (error < 0)
 218                 kfree_skb(skb);
 219         return error < 0 ? error : 0;
 220 }
 221
 222 static void release_tid(struct c4iw_rdev *rdev, u32 hwtid, struct sk_buff *skb)
 223 {
 224         struct cpl_tid_release *req;
 225
 226         skb = get_skb(skb, sizeof *req, GFP_KERNEL);
 227         if (!skb)
 228                 return;
 229         req = (struct cpl_tid_release *) skb_put(skb, sizeof(*req));
 230         INIT_TP_WR(req, hwtid);
 231         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_TID_RELEASE, hwtid));
 232         set_wr_txq(skb, CPL_PRIORITY_SETUP, 0);
 233         c4iw_ofld_send(rdev, skb);
 234         return;
 235 }
 236
 237 static void set_emss(struct c4iw_ep *ep, u16 opt)
 238 {
 239         ep->emss = ep->com.dev->rdev.lldi.mtus[TCPOPT_MSS_G(opt)] -
 240                    ((AF_INET == ep->com.remote_addr.ss_family) ?
 241                     sizeof(struct iphdr) : sizeof(struct ipv6hdr)) -
 242                    sizeof(struct tcphdr);
 243         ep->mss = ep->emss;
 244         if (TCPOPT_TSTAMP_G(opt))
 245                 ep->emss -= round_up(TCPOLEN_TIMESTAMP, 4);
 246         if (ep->emss < 128)
 247                 ep->emss = 128;
 248         if (ep->emss & 7)
 249                 PDBG("Warning: misaligned mtu idx %u mss %u emss=%u\n",
 250                      TCPOPT_MSS_G(opt), ep->mss, ep->emss);
 251         PDBG("%s mss_idx %u mss %u emss=%u\n", __func__, TCPOPT_MSS_G(opt),
 252              ep->mss, ep->emss);
 253 }
 254
 255 static enum c4iw_ep_state state_read(struct c4iw_ep_common *epc)
 256 {
 257         enum c4iw_ep_state state;
 258
 259         mutex_lock(&epc->mutex);
 260         state = epc->state;
 261         mutex_unlock(&epc->mutex);
 262         return state;
 263 }
 264
 265 static void __state_set(struct c4iw_ep_common *epc, enum c4iw_ep_state new)
 266 {
 267         epc->state = new;
 268 }
 269
 270 static void state_set(struct c4iw_ep_common *epc, enum c4iw_ep_state new)
 271 {
 272         mutex_lock(&epc->mutex);
 273         PDBG("%s - %s -> %s\n", __func__, states[epc->state], states[new]);
 274         __state_set(epc, new);
 275         mutex_unlock(&epc->mutex);
 276         return;
 277 }
 278
 279 static void *alloc_ep(int size, gfp_t gfp)
 280 {
 281         struct c4iw_ep_common *epc;
 282
 283         epc = kzalloc(size, gfp);
 284         if (epc) {
 285                 kref_init(&epc->kref);
 286                 mutex_init(&epc->mutex);
 287                 c4iw_init_wr_wait(&epc->wr_wait);
 288         }
 289         PDBG("%s alloc ep %p\n", __func__, epc);
 290         return epc;
 291 }
 292
 293 void _c4iw_free_ep(struct kref *kref)
 294 {
 295         struct c4iw_ep *ep;
 296
 297         ep = container_of(kref, struct c4iw_ep, com.kref);
 298         PDBG("%s ep %p state %s\n", __func__, ep, states[state_read(&ep->com)]);
 299         if (test_bit(QP_REFERENCED, &ep->com.flags))
 300                 deref_qp(ep);
 301         if (test_bit(RELEASE_RESOURCES, &ep->com.flags)) {
 302                 if (ep->com.remote_addr.ss_family == AF_INET6) {
 303                         struct sockaddr_in6 *sin6 =
 304                                         (struct sockaddr_in6 *)
 305                                         &ep->com.local_addr;
 306
 307                         cxgb4_clip_release(
 308                                         ep->com.dev->rdev.lldi.ports[0],
 309                                         (const u32 *)&sin6->sin6_addr.s6_addr,
 310                                         1);
 311                 }
 312                 remove_handle(ep->com.dev, &ep->com.dev->hwtid_idr, ep->hwtid);
 313                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, ep->hwtid);
 314                 dst_release(ep->dst);
 315                 cxgb4_l2t_release(ep->l2t);
 316         }
 317         kfree(ep);
 318 }
 319
 320 static void release_ep_resources(struct c4iw_ep *ep)
 321 {
 322         set_bit(RELEASE_RESOURCES, &ep->com.flags);
 323         c4iw_put_ep(&ep->com);
 324 }
 325
 326 static int status2errno(int status)
 327 {
 328         switch (status) {
 329         case CPL_ERR_NONE:
 330                 return 0;
 331         case CPL_ERR_CONN_RESET:
 332                 return -ECONNRESET;
 333         case CPL_ERR_ARP_MISS:
 334                 return -EHOSTUNREACH;
 335         case CPL_ERR_CONN_TIMEDOUT:
 336                 return -ETIMEDOUT;
 337         case CPL_ERR_TCAM_FULL:
 338                 return -ENOMEM;
 339         case CPL_ERR_CONN_EXIST:
 340                 return -EADDRINUSE;
 341         default:
 342                 return -EIO;
 343         }
 344 }
 345
 346 /*
 347  * Try and reuse skbs already allocated...
 348  */
 349 static struct sk_buff *get_skb(struct sk_buff *skb, int len, gfp_t gfp)
 350 {
 351         if (skb && !skb_is_nonlinear(skb) && !skb_cloned(skb)) {
 352                 skb_trim(skb, 0);
 353                 skb_get(skb);
 354                 skb_reset_transport_header(skb);
 355         } else {
 356                 skb = alloc_skb(len, gfp);
 357         }
 358         t4_set_arp_err_handler(skb, NULL, NULL);
 359         return skb;
 360 }
 361
 362 static struct net_device *get_real_dev(struct net_device *egress_dev)
 363 {
 364         return rdma_vlan_dev_real_dev(egress_dev) ? : egress_dev;
 365 }
 366
 367 static int our_interface(struct c4iw_dev *dev, struct net_device *egress_dev)
 368 {
 369         int i;
 370
 371         egress_dev = get_real_dev(egress_dev);
 372         for (i = 0; i < dev->rdev.lldi.nports; i++)
 373                 if (dev->rdev.lldi.ports[i] == egress_dev)
 374                         return 1;
 375         return 0;
 376 }
 377
 378 static struct dst_entry *find_route6(struct c4iw_dev *dev, __u8 *local_ip,
 379                                      __u8 *peer_ip, __be16 local_port,
 380                                      __be16 peer_port, u8 tos,
 381                                      __u32 sin6_scope_id)
 382 {
 383         struct dst_entry *dst = NULL;
 384
 385         if (IS_ENABLED(CONFIG_IPV6)) {
 386                 struct flowi6 fl6;
 387
 388                 memset(&fl6, 0, sizeof(fl6));
 389                 memcpy(&fl6.daddr, peer_ip, 16);
 390                 memcpy(&fl6.saddr, local_ip, 16);
 391                 if (ipv6_addr_type(&fl6.daddr) & IPV6_ADDR_LINKLOCAL)
 392                         fl6.flowi6_oif = sin6_scope_id;
 393                 dst = ip6_route_output(&init_net, NULL, &fl6);
 394                 if (!dst)
 395                         goto out;
 396                 if (!our_interface(dev, ip6_dst_idev(dst)->dev) &&
 397                     !(ip6_dst_idev(dst)->dev->flags & IFF_LOOPBACK)) {
 398                         dst_release(dst);
 399                         dst = NULL;
 400                 }
 401         }
 402
 403 out:
 404         return dst;
 405 }
 406
 407 static struct dst_entry *find_route(struct c4iw_dev *dev, __be32 local_ip,
 408                                  __be32 peer_ip, __be16 local_port,
 409                                  __be16 peer_port, u8 tos)
 410 {
 411         struct rtable *rt;
 412         struct flowi4 fl4;
 413         struct neighbour *n;
 414
 415         rt = ip_route_output_ports(&init_net, &fl4, NULL, peer_ip, local_ip,
 416                                    peer_port, local_port, IPPROTO_TCP,
 417                                    tos, 0);
 418         if (IS_ERR(rt))
 419                 return NULL;
 420         n = dst_neigh_lookup(&rt->dst, &peer_ip);
 421         if (!n)
 422                 return NULL;
 423         if (!our_interface(dev, n->dev) &&
 424             !(n->dev->flags & IFF_LOOPBACK)) {
 425                 neigh_release(n);
 426                 dst_release(&rt->dst);
 427                 return NULL;
 428         }
 429         neigh_release(n);
 430         return &rt->dst;
 431 }
 432
 433 static void arp_failure_discard(void *handle, struct sk_buff *skb)
 434 {
 435         PDBG("%s c4iw_dev %p\n", __func__, handle);
 436         kfree_skb(skb);
 437 }
 438
 439 /*
 440  * Handle an ARP failure for an active open.
 441  */
 442 static void act_open_req_arp_failure(void *handle, struct sk_buff *skb)
 443 {
 444         struct c4iw_ep *ep = handle;
 445
 446         printk(KERN_ERR MOD "ARP failure during connect\n");
 447         kfree_skb(skb);
 448         connect_reply_upcall(ep, -EHOSTUNREACH);
 449         state_set(&ep->com, DEAD);
 450         if (ep->com.remote_addr.ss_family == AF_INET6) {
 451                 struct sockaddr_in6 *sin6 =
 452                         (struct sockaddr_in6 *)&ep->com.local_addr;
 453                 cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
 454                                    (const u32 *)&sin6->sin6_addr.s6_addr, 1);
 455         }
 456         remove_handle(ep->com.dev, &ep->com.dev->atid_idr, ep->atid);
 457         cxgb4_free_atid(ep->com.dev->rdev.lldi.tids, ep->atid);
 458         dst_release(ep->dst);
 459         cxgb4_l2t_release(ep->l2t);
 460         c4iw_put_ep(&ep->com);
 461 }
 462
 463 /*
 464  * Handle an ARP failure for a CPL_ABORT_REQ.  Change it into a no RST variant
 465  * and send it along.
 466  */
 467 static void abort_arp_failure(void *handle, struct sk_buff *skb)
 468 {
 469         struct c4iw_rdev *rdev = handle;
 470         struct cpl_abort_req *req = cplhdr(skb);
 471
 472         PDBG("%s rdev %p\n", __func__, rdev);
 473         req->cmd = CPL_ABORT_NO_RST;
 474         c4iw_ofld_send(rdev, skb);
 475 }
 476
 477 static void send_flowc(struct c4iw_ep *ep, struct sk_buff *skb)
 478 {
 479         unsigned int flowclen = 80;
 480         struct fw_flowc_wr *flowc;
 481         int i;
 482
 483         skb = get_skb(skb, flowclen, GFP_KERNEL);
 484         flowc = (struct fw_flowc_wr *)__skb_put(skb, flowclen);
 485
 486         flowc->op_to_nparams = cpu_to_be32(FW_WR_OP_V(FW_FLOWC_WR) |
 487                                            FW_FLOWC_WR_NPARAMS_V(8));
 488         flowc->flowid_len16 = cpu_to_be32(FW_WR_LEN16_V(DIV_ROUND_UP(flowclen,
 489                                           16)) | FW_WR_FLOWID_V(ep->hwtid));
 490
 491         flowc->mnemval[0].mnemonic = FW_FLOWC_MNEM_PFNVFN;
 492         flowc->mnemval[0].val = cpu_to_be32(FW_PFVF_CMD_PFN_V
 493                                             (ep->com.dev->rdev.lldi.pf));
 494         flowc->mnemval[1].mnemonic = FW_FLOWC_MNEM_CH;
 495         flowc->mnemval[1].val = cpu_to_be32(ep->tx_chan);
 496         flowc->mnemval[2].mnemonic = FW_FLOWC_MNEM_PORT;
 497         flowc->mnemval[2].val = cpu_to_be32(ep->tx_chan);
 498         flowc->mnemval[3].mnemonic = FW_FLOWC_MNEM_IQID;
 499         flowc->mnemval[3].val = cpu_to_be32(ep->rss_qid);
 500         flowc->mnemval[4].mnemonic = FW_FLOWC_MNEM_SNDNXT;
 501         flowc->mnemval[4].val = cpu_to_be32(ep->snd_seq);
 502         flowc->mnemval[5].mnemonic = FW_FLOWC_MNEM_RCVNXT;
 503         flowc->mnemval[5].val = cpu_to_be32(ep->rcv_seq);
 504         flowc->mnemval[6].mnemonic = FW_FLOWC_MNEM_SNDBUF;
 505         flowc->mnemval[6].val = cpu_to_be32(ep->snd_win);
 506         flowc->mnemval[7].mnemonic = FW_FLOWC_MNEM_MSS;
 507         flowc->mnemval[7].val = cpu_to_be32(ep->emss);
 508         /* Pad WR to 16 byte boundary */
 509         flowc->mnemval[8].mnemonic = 0;
 510         flowc->mnemval[8].val = 0;
 511         for (i = 0; i < 9; i++) {
 512                 flowc->mnemval[i].r4[0] = 0;
 513                 flowc->mnemval[i].r4[1] = 0;
 514                 flowc->mnemval[i].r4[2] = 0;
 515         }
 516
 517         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
 518         c4iw_ofld_send(&ep->com.dev->rdev, skb);
 519 }
 520
 521 static int send_halfclose(struct c4iw_ep *ep, gfp_t gfp)
 522 {
 523         struct cpl_close_con_req *req;
 524         struct sk_buff *skb;
 525         int wrlen = roundup(sizeof *req, 16);
 526
 527         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
 528         skb = get_skb(NULL, wrlen, gfp);
 529         if (!skb) {
 530                 printk(KERN_ERR MOD "%s - failed to alloc skb\n", __func__);
 531                 return -ENOMEM;
 532         }
 533         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
 534         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
 535         req = (struct cpl_close_con_req *) skb_put(skb, wrlen);
 536         memset(req, 0, wrlen);
 537         INIT_TP_WR(req, ep->hwtid);
 538         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_CLOSE_CON_REQ,
 539                                                     ep->hwtid));
 540         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
 541 }
 542
 543 static int send_abort(struct c4iw_ep *ep, struct sk_buff *skb, gfp_t gfp)
 544 {
 545         struct cpl_abort_req *req;
 546         int wrlen = roundup(sizeof *req, 16);
 547
 548         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
 549         skb = get_skb(skb, wrlen, gfp);
 550         if (!skb) {
 551                 printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
 552                        __func__);
 553                 return -ENOMEM;
 554         }
 555         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
 556         t4_set_arp_err_handler(skb, &ep->com.dev->rdev, abort_arp_failure);
 557         req = (struct cpl_abort_req *) skb_put(skb, wrlen);
 558         memset(req, 0, wrlen);
 559         INIT_TP_WR(req, ep->hwtid);
 560         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_REQ, ep->hwtid));
 561         req->cmd = CPL_ABORT_SEND_RST;
 562         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
 563 }
 564
 565 static void best_mtu(const unsigned short *mtus, unsigned short mtu,
 566                      unsigned int *idx, int use_ts, int ipv6)
 567 {
 568         unsigned short hdr_size = (ipv6 ?
 569                                    sizeof(struct ipv6hdr) :
 570                                    sizeof(struct iphdr)) +
 571                                   sizeof(struct tcphdr) +
 572                                   (use_ts ?
 573                                    round_up(TCPOLEN_TIMESTAMP, 4) : 0);
 574         unsigned short data_size = mtu - hdr_size;
 575
 576         cxgb4_best_aligned_mtu(mtus, hdr_size, data_size, 8, idx);
 577 }
 578
 579 static int send_connect(struct c4iw_ep *ep)
 580 {
 581         struct cpl_act_open_req *req = NULL;
 582         struct cpl_t5_act_open_req *t5req = NULL;
 583         struct cpl_t6_act_open_req *t6req = NULL;
 584         struct cpl_act_open_req6 *req6 = NULL;
 585         struct cpl_t5_act_open_req6 *t5req6 = NULL;
 586         struct cpl_t6_act_open_req6 *t6req6 = NULL;
 587         struct sk_buff *skb;
 588         u64 opt0;
 589         u32 opt2;
 590         unsigned int mtu_idx;
 591         int wscale;
 592         int win, sizev4, sizev6, wrlen;
 593         struct sockaddr_in *la = (struct sockaddr_in *)
 594                                  &ep->com.local_addr;
 595         struct sockaddr_in *ra = (struct sockaddr_in *)
 596                                  &ep->com.remote_addr;
 597         struct sockaddr_in6 *la6 = (struct sockaddr_in6 *)
 598                                    &ep->com.local_addr;
 599         struct sockaddr_in6 *ra6 = (struct sockaddr_in6 *)
 600                                    &ep->com.remote_addr;
 601         int ret;
 602         enum chip_type adapter_type = ep->com.dev->rdev.lldi.adapter_type;
 603         u32 isn = (prandom_u32() & ~7UL) - 1;
 604
 605         switch (CHELSIO_CHIP_VERSION(adapter_type)) {
 606         case CHELSIO_T4:
 607                 sizev4 = sizeof(struct cpl_act_open_req);
 608                 sizev6 = sizeof(struct cpl_act_open_req6);
 609                 break;
 610         case CHELSIO_T5:
 611                 sizev4 = sizeof(struct cpl_t5_act_open_req);
 612                 sizev6 = sizeof(struct cpl_t5_act_open_req6);
 613                 break;
 614         case CHELSIO_T6:
 615                 sizev4 = sizeof(struct cpl_t6_act_open_req);
 616                 sizev6 = sizeof(struct cpl_t6_act_open_req6);
 617                 break;
 618         default:
 619                 pr_err("T%d Chip is not supported\n",
 620                        CHELSIO_CHIP_VERSION(adapter_type));
 621                 return -EINVAL;
 622         }
 623
 624         wrlen = (ep->com.remote_addr.ss_family == AF_INET) ?
 625                         roundup(sizev4, 16) :
 626                         roundup(sizev6, 16);
 627
 628         PDBG("%s ep %p atid %u\n", __func__, ep, ep->atid);
 629
 630         skb = get_skb(NULL, wrlen, GFP_KERNEL);
 631         if (!skb) {
 632                 printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
 633                        __func__);
 634                 return -ENOMEM;
 635         }
 636         set_wr_txq(skb, CPL_PRIORITY_SETUP, ep->ctrlq_idx);
 637
 638         best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx,
 639                  enable_tcp_timestamps,
 640                  (AF_INET == ep->com.remote_addr.ss_family) ? 0 : 1);
 641         wscale = compute_wscale(rcv_win);
 642
 643         /*
 644          * Specify the largest window that will fit in opt0. The
 645          * remainder will be specified in the rx_data_ack.
 646          */
 647         win = ep->rcv_win >> 10;
 648         if (win > RCV_BUFSIZ_M)
 649                 win = RCV_BUFSIZ_M;
 650
 651         opt0 = (nocong ? NO_CONG_F : 0) |
 652                KEEP_ALIVE_F |
 653                DELACK_F |
 654                WND_SCALE_V(wscale) |
 655                MSS_IDX_V(mtu_idx) |
 656                L2T_IDX_V(ep->l2t->idx) |
 657                TX_CHAN_V(ep->tx_chan) |
 658                SMAC_SEL_V(ep->smac_idx) |
 659                DSCP_V(ep->tos) |
 660                ULP_MODE_V(ULP_MODE_TCPDDP) |
 661                RCV_BUFSIZ_V(win);
 662         opt2 = RX_CHANNEL_V(0) |
 663                CCTRL_ECN_V(enable_ecn) |
 664                RSS_QUEUE_VALID_F | RSS_QUEUE_V(ep->rss_qid);
 665         if (enable_tcp_timestamps)
 666                 opt2 |= TSTAMPS_EN_F;
 667         if (enable_tcp_sack)
 668                 opt2 |= SACK_EN_F;
 669         if (wscale && enable_tcp_window_scaling)
 670                 opt2 |= WND_SCALE_EN_F;
 671         if (CHELSIO_CHIP_VERSION(adapter_type) > CHELSIO_T4) {
 672                 if (peer2peer)
 673                         isn += 4;
 674
 675                 opt2 |= T5_OPT_2_VALID_F;
 676                 opt2 |= CONG_CNTRL_V(CONG_ALG_TAHOE);
 677                 opt2 |= T5_ISS_F;
 678         }
 679
 680         if (ep->com.remote_addr.ss_family == AF_INET6)
 681                 cxgb4_clip_get(ep->com.dev->rdev.lldi.ports[0],
 682                                (const u32 *)&la6->sin6_addr.s6_addr, 1);
 683
 684         t4_set_arp_err_handler(skb, ep, act_open_req_arp_failure);
 685
 686         if (ep->com.remote_addr.ss_family == AF_INET) {
 687                 switch (CHELSIO_CHIP_VERSION(adapter_type)) {
 688                 case CHELSIO_T4:
 689                         req = (struct cpl_act_open_req *)skb_put(skb, wrlen);
 690                         INIT_TP_WR(req, 0);
 691                         break;
 692                 case CHELSIO_T5:
 693                         t5req = (struct cpl_t5_act_open_req *)skb_put(skb,
 694                                         wrlen);
 695                         INIT_TP_WR(t5req, 0);
 696                         req = (struct cpl_act_open_req *)t5req;
 697                         break;
 698                 case CHELSIO_T6:
 699                         t6req = (struct cpl_t6_act_open_req *)skb_put(skb,
 700                                         wrlen);
 701                         INIT_TP_WR(t6req, 0);
 702                         req = (struct cpl_act_open_req *)t6req;
 703                         t5req = (struct cpl_t5_act_open_req *)t6req;
 704                         break;
 705                 default:
 706                         pr_err("T%d Chip is not supported\n",
 707                                CHELSIO_CHIP_VERSION(adapter_type));
 708                         ret = -EINVAL;
 709                         goto clip_release;
 710                 }
 711
 712                 OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ,
 713                                         ((ep->rss_qid<<14) | ep->atid)));
 714                 req->local_port = la->sin_port;
 715                 req->peer_port = ra->sin_port;
 716                 req->local_ip = la->sin_addr.s_addr;
 717                 req->peer_ip = ra->sin_addr.s_addr;
 718                 req->opt0 = cpu_to_be64(opt0);
 719
 720                 if (is_t4(ep->com.dev->rdev.lldi.adapter_type)) {
 721                         req->params = cpu_to_be32(cxgb4_select_ntuple(
 722                                                 ep->com.dev->rdev.lldi.ports[0],
 723                                                 ep->l2t));
 724                         req->opt2 = cpu_to_be32(opt2);
 725                 } else {
 726                         t5req->params = cpu_to_be64(FILTER_TUPLE_V(
 727                                                 cxgb4_select_ntuple(
 728                                                 ep->com.dev->rdev.lldi.ports[0],
 729                                                 ep->l2t)));
 730                         t5req->rsvd = cpu_to_be32(isn);
 731                         PDBG("%s snd_isn %u\n", __func__, t5req->rsvd);
 732                         t5req->opt2 = cpu_to_be32(opt2);
 733                 }
 734         } else {
 735                 switch (CHELSIO_CHIP_VERSION(adapter_type)) {
 736                 case CHELSIO_T4:
 737                         req6 = (struct cpl_act_open_req6 *)skb_put(skb, wrlen);
 738                         INIT_TP_WR(req6, 0);
 739                         break;
 740                 case CHELSIO_T5:
 741                         t5req6 = (struct cpl_t5_act_open_req6 *)skb_put(skb,
 742                                         wrlen);
 743                         INIT_TP_WR(t5req6, 0);
 744                         req6 = (struct cpl_act_open_req6 *)t5req6;
 745                         break;
 746                 case CHELSIO_T6:
 747                         t6req6 = (struct cpl_t6_act_open_req6 *)skb_put(skb,
 748                                         wrlen);
 749                         INIT_TP_WR(t6req6, 0);
 750                         req6 = (struct cpl_act_open_req6 *)t6req6;
 751                         t5req6 = (struct cpl_t5_act_open_req6 *)t6req6;
 752                         break;
 753                 default:
 754                         pr_err("T%d Chip is not supported\n",
 755                                CHELSIO_CHIP_VERSION(adapter_type));
 756                         ret = -EINVAL;
 757                         goto clip_release;
 758                 }
 759
 760                 OPCODE_TID(req6) = cpu_to_be32(MK_OPCODE_TID(CPL_ACT_OPEN_REQ6,
 761                                         ((ep->rss_qid<<14)|ep->atid)));
 762                 req6->local_port = la6->sin6_port;
 763                 req6->peer_port = ra6->sin6_port;
 764                 req6->local_ip_hi = *((__be64 *)(la6->sin6_addr.s6_addr));
 765                 req6->local_ip_lo = *((__be64 *)(la6->sin6_addr.s6_addr + 8));
 766                 req6->peer_ip_hi = *((__be64 *)(ra6->sin6_addr.s6_addr));
 767                 req6->peer_ip_lo = *((__be64 *)(ra6->sin6_addr.s6_addr + 8));
 768                 req6->opt0 = cpu_to_be64(opt0);
 769
 770                 if (is_t4(ep->com.dev->rdev.lldi.adapter_type)) {
 771                         req6->params = cpu_to_be32(cxgb4_select_ntuple(
 772                                                 ep->com.dev->rdev.lldi.ports[0],
 773                                                 ep->l2t));
 774                         req6->opt2 = cpu_to_be32(opt2);
 775                 } else {
 776                         t5req6->params = cpu_to_be64(FILTER_TUPLE_V(
 777                                                 cxgb4_select_ntuple(
 778                                                 ep->com.dev->rdev.lldi.ports[0],
 779                                                 ep->l2t)));
 780                         t5req6->rsvd = cpu_to_be32(isn);
 781                         PDBG("%s snd_isn %u\n", __func__, t5req6->rsvd);
 782                         t5req6->opt2 = cpu_to_be32(opt2);
 783                 }
 784         }
 785
 786         set_bit(ACT_OPEN_REQ, &ep->com.history);
 787         ret = c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
 788 clip_release:
 789         if (ret && ep->com.remote_addr.ss_family == AF_INET6)
 790                 cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
 791                                    (const u32 *)&la6->sin6_addr.s6_addr, 1);
 792         return ret;
 793 }
 794
 795 static void send_mpa_req(struct c4iw_ep *ep, struct sk_buff *skb,
 796                 u8 mpa_rev_to_use)
 797 {
 798         int mpalen, wrlen;
 799         struct fw_ofld_tx_data_wr *req;
 800         struct mpa_message *mpa;
 801         struct mpa_v2_conn_params mpa_v2_params;
 802
 803         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
 804
 805         BUG_ON(skb_cloned(skb));
 806
 807         mpalen = sizeof(*mpa) + ep->plen;
 808         if (mpa_rev_to_use == 2)
 809                 mpalen += sizeof(struct mpa_v2_conn_params);
 810         wrlen = roundup(mpalen + sizeof *req, 16);
 811         skb = get_skb(skb, wrlen, GFP_KERNEL);
 812         if (!skb) {
 813                 connect_reply_upcall(ep, -ENOMEM);
 814                 return;
 815         }
 816         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
 817
 818         req = (struct fw_ofld_tx_data_wr *)skb_put(skb, wrlen);
 819         memset(req, 0, wrlen);
 820         req->op_to_immdlen = cpu_to_be32(
 821                 FW_WR_OP_V(FW_OFLD_TX_DATA_WR) |
 822                 FW_WR_COMPL_F |
 823                 FW_WR_IMMDLEN_V(mpalen));
 824         req->flowid_len16 = cpu_to_be32(
 825                 FW_WR_FLOWID_V(ep->hwtid) |
 826                 FW_WR_LEN16_V(wrlen >> 4));
 827         req->plen = cpu_to_be32(mpalen);
 828         req->tunnel_to_proxy = cpu_to_be32(
 829                 FW_OFLD_TX_DATA_WR_FLUSH_F |
 830                 FW_OFLD_TX_DATA_WR_SHOVE_F);
 831
 832         mpa = (struct mpa_message *)(req + 1);
 833         memcpy(mpa->key, MPA_KEY_REQ, sizeof(mpa->key));
 834         mpa->flags = (crc_enabled ? MPA_CRC : 0) |
 835                      (markers_enabled ? MPA_MARKERS : 0) |
 836                      (mpa_rev_to_use == 2 ? MPA_ENHANCED_RDMA_CONN : 0);
 837         mpa->private_data_size = htons(ep->plen);
 838         mpa->revision = mpa_rev_to_use;
 839         if (mpa_rev_to_use == 1) {
 840                 ep->tried_with_mpa_v1 = 1;
 841                 ep->retry_with_mpa_v1 = 0;
 842         }
 843
 844         if (mpa_rev_to_use == 2) {
 845                 mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
 846                                                sizeof (struct mpa_v2_conn_params));
 847                 PDBG("%s initiator ird %u ord %u\n", __func__, ep->ird,
 848                      ep->ord);
 849                 mpa_v2_params.ird = htons((u16)ep->ird);
 850                 mpa_v2_params.ord = htons((u16)ep->ord);
 851
 852                 if (peer2peer) {
 853                         mpa_v2_params.ird |= htons(MPA_V2_PEER2PEER_MODEL);
 854                         if (p2p_type == FW_RI_INIT_P2PTYPE_RDMA_WRITE)
 855                                 mpa_v2_params.ord |=
 856                                         htons(MPA_V2_RDMA_WRITE_RTR);
 857                         else if (p2p_type == FW_RI_INIT_P2PTYPE_READ_REQ)
 858                                 mpa_v2_params.ord |=
 859                                         htons(MPA_V2_RDMA_READ_RTR);
 860                 }
 861                 memcpy(mpa->private_data, &mpa_v2_params,
 862                        sizeof(struct mpa_v2_conn_params));
 863
 864                 if (ep->plen)
 865                         memcpy(mpa->private_data +
 866                                sizeof(struct mpa_v2_conn_params),
 867                                ep->mpa_pkt + sizeof(*mpa), ep->plen);
 868         } else
 869                 if (ep->plen)
 870                         memcpy(mpa->private_data,
 871                                         ep->mpa_pkt + sizeof(*mpa), ep->plen);
 872
 873         /*
 874          * Reference the mpa skb.  This ensures the data area
 875          * will remain in memory until the hw acks the tx.
 876          * Function fw4_ack() will deref it.
 877          */
 878         skb_get(skb);
 879         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
 880         BUG_ON(ep->mpa_skb);
 881         ep->mpa_skb = skb;
 882         c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
 883         start_ep_timer(ep);
 884         __state_set(&ep->com, MPA_REQ_SENT);
 885         ep->mpa_attr.initiator = 1;
 886         ep->snd_seq += mpalen;
 887         return;
 888 }
 889
 890 static int send_mpa_reject(struct c4iw_ep *ep, const void *pdata, u8 plen)
 891 {
 892         int mpalen, wrlen;
 893         struct fw_ofld_tx_data_wr *req;
 894         struct mpa_message *mpa;
 895         struct sk_buff *skb;
 896         struct mpa_v2_conn_params mpa_v2_params;
 897
 898         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
 899
 900         mpalen = sizeof(*mpa) + plen;
 901         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn)
 902                 mpalen += sizeof(struct mpa_v2_conn_params);
 903         wrlen = roundup(mpalen + sizeof *req, 16);
 904
 905         skb = get_skb(NULL, wrlen, GFP_KERNEL);
 906         if (!skb) {
 907                 printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
 908                 return -ENOMEM;
 909         }
 910         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
 911
 912         req = (struct fw_ofld_tx_data_wr *)skb_put(skb, wrlen);
 913         memset(req, 0, wrlen);
 914         req->op_to_immdlen = cpu_to_be32(
 915                 FW_WR_OP_V(FW_OFLD_TX_DATA_WR) |
 916                 FW_WR_COMPL_F |
 917                 FW_WR_IMMDLEN_V(mpalen));
 918         req->flowid_len16 = cpu_to_be32(
 919                 FW_WR_FLOWID_V(ep->hwtid) |
 920                 FW_WR_LEN16_V(wrlen >> 4));
 921         req->plen = cpu_to_be32(mpalen);
 922         req->tunnel_to_proxy = cpu_to_be32(
 923                 FW_OFLD_TX_DATA_WR_FLUSH_F |
 924                 FW_OFLD_TX_DATA_WR_SHOVE_F);
 925
 926         mpa = (struct mpa_message *)(req + 1);
 927         memset(mpa, 0, sizeof(*mpa));
 928         memcpy(mpa->key, MPA_KEY_REP, sizeof(mpa->key));
 929         mpa->flags = MPA_REJECT;
 930         mpa->revision = ep->mpa_attr.version;
 931         mpa->private_data_size = htons(plen);
 932
 933         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
 934                 mpa->flags |= MPA_ENHANCED_RDMA_CONN;
 935                 mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
 936                                                sizeof (struct mpa_v2_conn_params));
 937                 mpa_v2_params.ird = htons(((u16)ep->ird) |
 938                                           (peer2peer ? MPA_V2_PEER2PEER_MODEL :
 939                                            0));
 940                 mpa_v2_params.ord = htons(((u16)ep->ord) | (peer2peer ?
 941                                           (p2p_type ==
 942                                            FW_RI_INIT_P2PTYPE_RDMA_WRITE ?
 943                                            MPA_V2_RDMA_WRITE_RTR : p2p_type ==
 944                                            FW_RI_INIT_P2PTYPE_READ_REQ ?
 945                                            MPA_V2_RDMA_READ_RTR : 0) : 0));
 946                 memcpy(mpa->private_data, &mpa_v2_params,
 947                        sizeof(struct mpa_v2_conn_params));
 948
 949                 if (ep->plen)
 950                         memcpy(mpa->private_data +
 951                                sizeof(struct mpa_v2_conn_params), pdata, plen);
 952         } else
 953                 if (plen)
 954                         memcpy(mpa->private_data, pdata, plen);
 955
 956         /*
 957          * Reference the mpa skb again.  This ensures the data area
 958          * will remain in memory until the hw acks the tx.
 959          * Function fw4_ack() will deref it.
 960          */
 961         skb_get(skb);
 962         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
 963         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
 964         BUG_ON(ep->mpa_skb);
 965         ep->mpa_skb = skb;
 966         ep->snd_seq += mpalen;
 967         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
 968 }
 969
 970 static int send_mpa_reply(struct c4iw_ep *ep, const void *pdata, u8 plen)
 971 {
 972         int mpalen, wrlen;
 973         struct fw_ofld_tx_data_wr *req;
 974         struct mpa_message *mpa;
 975         struct sk_buff *skb;
 976         struct mpa_v2_conn_params mpa_v2_params;
 977
 978         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
 979
 980         mpalen = sizeof(*mpa) + plen;
 981         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn)
 982                 mpalen += sizeof(struct mpa_v2_conn_params);
 983         wrlen = roundup(mpalen + sizeof *req, 16);
 984
 985         skb = get_skb(NULL, wrlen, GFP_KERNEL);
 986         if (!skb) {
 987                 printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
 988                 return -ENOMEM;
 989         }
 990         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
 991
 992         req = (struct fw_ofld_tx_data_wr *) skb_put(skb, wrlen);
 993         memset(req, 0, wrlen);
 994         req->op_to_immdlen = cpu_to_be32(
 995                 FW_WR_OP_V(FW_OFLD_TX_DATA_WR) |
 996                 FW_WR_COMPL_F |
 997                 FW_WR_IMMDLEN_V(mpalen));
 998         req->flowid_len16 = cpu_to_be32(
 999                 FW_WR_FLOWID_V(ep->hwtid) |
1000                 FW_WR_LEN16_V(wrlen >> 4));
1001         req->plen = cpu_to_be32(mpalen);
1002         req->tunnel_to_proxy = cpu_to_be32(
1003                 FW_OFLD_TX_DATA_WR_FLUSH_F |
1004                 FW_OFLD_TX_DATA_WR_SHOVE_F);
1005
1006         mpa = (struct mpa_message *)(req + 1);
1007         memset(mpa, 0, sizeof(*mpa));
1008         memcpy(mpa->key, MPA_KEY_REP, sizeof(mpa->key));
1009         mpa->flags = (ep->mpa_attr.crc_enabled ? MPA_CRC : 0) |
1010                      (markers_enabled ? MPA_MARKERS : 0);
1011         mpa->revision = ep->mpa_attr.version;
1012         mpa->private_data_size = htons(plen);
1013
1014         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
1015                 mpa->flags |= MPA_ENHANCED_RDMA_CONN;
1016                 mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
1017                                                sizeof (struct mpa_v2_conn_params));
1018                 mpa_v2_params.ird = htons((u16)ep->ird);
1019                 mpa_v2_params.ord = htons((u16)ep->ord);
1020                 if (peer2peer && (ep->mpa_attr.p2p_type !=
1021                                         FW_RI_INIT_P2PTYPE_DISABLED)) {
1022                         mpa_v2_params.ird |= htons(MPA_V2_PEER2PEER_MODEL);
1023
1024                         if (p2p_type == FW_RI_INIT_P2PTYPE_RDMA_WRITE)
1025                                 mpa_v2_params.ord |=
1026                                         htons(MPA_V2_RDMA_WRITE_RTR);
1027                         else if (p2p_type == FW_RI_INIT_P2PTYPE_READ_REQ)
1028                                 mpa_v2_params.ord |=
1029                                         htons(MPA_V2_RDMA_READ_RTR);
1030                 }
1031
1032                 memcpy(mpa->private_data, &mpa_v2_params,
1033                        sizeof(struct mpa_v2_conn_params));
1034
1035                 if (ep->plen)
1036                         memcpy(mpa->private_data +
1037                                sizeof(struct mpa_v2_conn_params), pdata, plen);
1038         } else
1039                 if (plen)
1040                         memcpy(mpa->private_data, pdata, plen);
1041
1042         /*
1043          * Reference the mpa skb.  This ensures the data area
1044          * will remain in memory until the hw acks the tx.
1045          * Function fw4_ack() will deref it.
1046          */
1047         skb_get(skb);
1048         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
1049         ep->mpa_skb = skb;
1050         __state_set(&ep->com, MPA_REP_SENT);
1051         ep->snd_seq += mpalen;
1052         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
1053 }
1054
1055 static int act_establish(struct c4iw_dev *dev, struct sk_buff *skb)
1056 {
1057         struct c4iw_ep *ep;
1058         struct cpl_act_establish *req = cplhdr(skb);
1059         unsigned int tid = GET_TID(req);
1060         unsigned int atid = TID_TID_G(ntohl(req->tos_atid));
1061         struct tid_info *t = dev->rdev.lldi.tids;
1062
1063         ep = lookup_atid(t, atid);
1064
1065         PDBG("%s ep %p tid %u snd_isn %u rcv_isn %u\n", __func__, ep, tid,
1066              be32_to_cpu(req->snd_isn), be32_to_cpu(req->rcv_isn));
1067
1068         mutex_lock(&ep->com.mutex);
1069         dst_confirm(ep->dst);
1070
1071         /* setup the hwtid for this connection */
1072         ep->hwtid = tid;
1073         cxgb4_insert_tid(t, ep, tid);
1074         insert_handle(dev, &dev->hwtid_idr, ep, ep->hwtid);
1075
1076         ep->snd_seq = be32_to_cpu(req->snd_isn);
1077         ep->rcv_seq = be32_to_cpu(req->rcv_isn);
1078
1079         set_emss(ep, ntohs(req->tcp_opt));
1080
1081         /* dealloc the atid */
1082         remove_handle(ep->com.dev, &ep->com.dev->atid_idr, atid);
1083         cxgb4_free_atid(t, atid);
1084         set_bit(ACT_ESTAB, &ep->com.history);
1085
1086         /* start MPA negotiation */
1087         send_flowc(ep, NULL);
1088         if (ep->retry_with_mpa_v1)
1089                 send_mpa_req(ep, skb, 1);
1090         else
1091                 send_mpa_req(ep, skb, mpa_rev);
1092         mutex_unlock(&ep->com.mutex);
1093         return 0;
1094 }
1095
1096 static void close_complete_upcall(struct c4iw_ep *ep, int status)
1097 {
1098         struct iw_cm_event event;
1099
1100         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1101         memset(&event, 0, sizeof(event));
1102         event.event = IW_CM_EVENT_CLOSE;
1103         event.status = status;
1104         if (ep->com.cm_id) {
1105                 PDBG("close complete delivered ep %p cm_id %p tid %u\n",
1106                      ep, ep->com.cm_id, ep->hwtid);
1107                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
1108                 ep->com.cm_id->rem_ref(ep->com.cm_id);
1109                 ep->com.cm_id = NULL;
1110                 set_bit(CLOSE_UPCALL, &ep->com.history);
1111         }
1112 }
1113
1114 static int abort_connection(struct c4iw_ep *ep, struct sk_buff *skb, gfp_t gfp)
1115 {
1116         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1117         __state_set(&ep->com, ABORTING);
1118         set_bit(ABORT_CONN, &ep->com.history);
1119         return send_abort(ep, skb, gfp);
1120 }
1121
1122 static void peer_close_upcall(struct c4iw_ep *ep)
1123 {
1124         struct iw_cm_event event;
1125
1126         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1127         memset(&event, 0, sizeof(event));
1128         event.event = IW_CM_EVENT_DISCONNECT;
1129         if (ep->com.cm_id) {
1130                 PDBG("peer close delivered ep %p cm_id %p tid %u\n",
1131                      ep, ep->com.cm_id, ep->hwtid);
1132                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
1133                 set_bit(DISCONN_UPCALL, &ep->com.history);
1134         }
1135 }
1136
1137 static void peer_abort_upcall(struct c4iw_ep *ep)
1138 {
1139         struct iw_cm_event event;
1140
1141         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1142         memset(&event, 0, sizeof(event));
1143         event.event = IW_CM_EVENT_CLOSE;
1144         event.status = -ECONNRESET;
1145         if (ep->com.cm_id) {
1146                 PDBG("abort delivered ep %p cm_id %p tid %u\n", ep,
1147                      ep->com.cm_id, ep->hwtid);
1148                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
1149                 ep->com.cm_id->rem_ref(ep->com.cm_id);
1150                 ep->com.cm_id = NULL;
1151                 set_bit(ABORT_UPCALL, &ep->com.history);
1152         }
1153 }
1154
1155 static void connect_reply_upcall(struct c4iw_ep *ep, int status)
1156 {
1157         struct iw_cm_event event;
1158
1159         PDBG("%s ep %p tid %u status %d\n", __func__, ep, ep->hwtid, status);
1160         memset(&event, 0, sizeof(event));
1161         event.event = IW_CM_EVENT_CONNECT_REPLY;
1162         event.status = status;
1163         memcpy(&event.local_addr, &ep->com.local_addr,
1164                sizeof(ep->com.local_addr));
1165         memcpy(&event.remote_addr, &ep->com.remote_addr,
1166                sizeof(ep->com.remote_addr));
1167
1168         if ((status == 0) || (status == -ECONNREFUSED)) {
1169                 if (!ep->tried_with_mpa_v1) {
1170                         /* this means MPA_v2 is used */
1171                         event.ord = ep->ird;
1172                         event.ird = ep->ord;
1173                         event.private_data_len = ep->plen -
1174                                 sizeof(struct mpa_v2_conn_params);
1175                         event.private_data = ep->mpa_pkt +
1176                                 sizeof(struct mpa_message) +
1177                                 sizeof(struct mpa_v2_conn_params);
1178                 } else {
1179                         /* this means MPA_v1 is used */
1180                         event.ord = cur_max_read_depth(ep->com.dev);
1181                         event.ird = cur_max_read_depth(ep->com.dev);
1182                         event.private_data_len = ep->plen;
1183                         event.private_data = ep->mpa_pkt +
1184                                 sizeof(struct mpa_message);
1185                 }
1186         }
1187
1188         PDBG("%s ep %p tid %u status %d\n", __func__, ep,
1189              ep->hwtid, status);
1190         set_bit(CONN_RPL_UPCALL, &ep->com.history);
1191         ep->com.cm_id->event_handler(ep->com.cm_id, &event);
1192
1193         if (status < 0) {
1194                 ep->com.cm_id->rem_ref(ep->com.cm_id);
1195                 ep->com.cm_id = NULL;
1196         }
1197 }
1198
1199 static int connect_request_upcall(struct c4iw_ep *ep)
1200 {
1201         struct iw_cm_event event;
1202         int ret;
1203
1204         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1205         memset(&event, 0, sizeof(event));
1206         event.event = IW_CM_EVENT_CONNECT_REQUEST;
1207         memcpy(&event.local_addr, &ep->com.local_addr,
1208                sizeof(ep->com.local_addr));
1209         memcpy(&event.remote_addr, &ep->com.remote_addr,
1210                sizeof(ep->com.remote_addr));
1211         event.provider_data = ep;
1212         if (!ep->tried_with_mpa_v1) {
1213                 /* this means MPA_v2 is used */
1214                 event.ord = ep->ord;
1215                 event.ird = ep->ird;
1216                 event.private_data_len = ep->plen -
1217                         sizeof(struct mpa_v2_conn_params);
1218                 event.private_data = ep->mpa_pkt + sizeof(struct mpa_message) +
1219                         sizeof(struct mpa_v2_conn_params);
1220         } else {
1221                 /* this means MPA_v1 is used. Send max supported */
1222                 event.ord = cur_max_read_depth(ep->com.dev);
1223                 event.ird = cur_max_read_depth(ep->com.dev);
1224                 event.private_data_len = ep->plen;
1225                 event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
1226         }
1227         c4iw_get_ep(&ep->com);
1228         ret = ep->parent_ep->com.cm_id->event_handler(ep->parent_ep->com.cm_id,
1229                                                       &event);
1230         if (ret)
1231                 c4iw_put_ep(&ep->com);
1232         set_bit(CONNREQ_UPCALL, &ep->com.history);
1233         c4iw_put_ep(&ep->parent_ep->com);
1234         return ret;
1235 }
1236
1237 static void established_upcall(struct c4iw_ep *ep)
1238 {
1239         struct iw_cm_event event;
1240
1241         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1242         memset(&event, 0, sizeof(event));
1243         event.event = IW_CM_EVENT_ESTABLISHED;
1244         event.ird = ep->ord;
1245         event.ord = ep->ird;
1246         if (ep->com.cm_id) {
1247                 PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1248                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
1249                 set_bit(ESTAB_UPCALL, &ep->com.history);
1250         }
1251 }
1252
1253 static int update_rx_credits(struct c4iw_ep *ep, u32 credits)
1254 {
1255         struct cpl_rx_data_ack *req;
1256         struct sk_buff *skb;
1257         int wrlen = roundup(sizeof *req, 16);
1258
1259         PDBG("%s ep %p tid %u credits %u\n", __func__, ep, ep->hwtid, credits);
1260         skb = get_skb(NULL, wrlen, GFP_KERNEL);
1261         if (!skb) {
1262                 printk(KERN_ERR MOD "update_rx_credits - cannot alloc skb!\n");
1263                 return 0;
1264         }
1265
1266         /*
1267          * If we couldn't specify the entire rcv window at connection setup
1268          * due to the limit in the number of bits in the RCV_BUFSIZ field,
1269          * then add the overage in to the credits returned.
1270          */
1271         if (ep->rcv_win > RCV_BUFSIZ_M * 1024)
1272                 credits += ep->rcv_win - RCV_BUFSIZ_M * 1024;
1273
1274         req = (struct cpl_rx_data_ack *) skb_put(skb, wrlen);
1275         memset(req, 0, wrlen);
1276         INIT_TP_WR(req, ep->hwtid);
1277         OPCODE_TID(req) = cpu_to_be32(MK_OPCODE_TID(CPL_RX_DATA_ACK,
1278                                                     ep->hwtid));
1279         req->credit_dack = cpu_to_be32(credits | RX_FORCE_ACK_F |
1280                                        RX_DACK_CHANGE_F |
1281                                        RX_DACK_MODE_V(dack_mode));
1282         set_wr_txq(skb, CPL_PRIORITY_ACK, ep->ctrlq_idx);
1283         c4iw_ofld_send(&ep->com.dev->rdev, skb);
1284         return credits;
1285 }
1286
1287 #define RELAXED_IRD_NEGOTIATION 1
1288
1289 static int process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
1290 {
1291         struct mpa_message *mpa;
1292         struct mpa_v2_conn_params *mpa_v2_params;
1293         u16 plen;
1294         u16 resp_ird, resp_ord;
1295         u8 rtr_mismatch = 0, insuff_ird = 0;
1296         struct c4iw_qp_attributes attrs;
1297         enum c4iw_qp_attr_mask mask;
1298         int err;
1299         int disconnect = 0;
1300
1301         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1302
1303         /*
1304          * Stop mpa timer.  If it expired, then
1305          * we ignore the MPA reply.  process_timeout()
1306          * will abort the connection.
1307          */
1308         if (stop_ep_timer(ep))
1309                 return 0;
1310
1311         /*
1312          * If we get more than the supported amount of private data
1313          * then we must fail this connection.
1314          */
1315         if (ep->mpa_pkt_len + skb->len > sizeof(ep->mpa_pkt)) {
1316                 err = -EINVAL;
1317                 goto err;
1318         }
1319
1320         /*
1321          * copy the new data into our accumulation buffer.
1322          */
1323         skb_copy_from_linear_data(skb, &(ep->mpa_pkt[ep->mpa_pkt_len]),
1324                                   skb->len);
1325         ep->mpa_pkt_len += skb->len;
1326
1327         /*
1328          * if we don't even have the mpa message, then bail.
1329          */
1330         if (ep->mpa_pkt_len < sizeof(*mpa))
1331                 return 0;
1332         mpa = (struct mpa_message *) ep->mpa_pkt;
1333
1334         /* Validate MPA header. */
1335         if (mpa->revision > mpa_rev) {
1336                 printk(KERN_ERR MOD "%s MPA version mismatch. Local = %d,"
1337                        " Received = %d\n", __func__, mpa_rev, mpa->revision);
1338                 err = -EPROTO;
1339                 goto err;
1340         }
1341         if (memcmp(mpa->key, MPA_KEY_REP, sizeof(mpa->key))) {
1342                 err = -EPROTO;
1343                 goto err;
1344         }
1345
1346         plen = ntohs(mpa->private_data_size);
1347
1348         /*
1349          * Fail if there's too much private data.
1350          */
1351         if (plen > MPA_MAX_PRIVATE_DATA) {
1352                 err = -EPROTO;
1353                 goto err;
1354         }
1355
1356         /*
1357          * If plen does not account for pkt size
1358          */
1359         if (ep->mpa_pkt_len > (sizeof(*mpa) + plen)) {
1360                 err = -EPROTO;
1361                 goto err;
1362         }
1363
1364         ep->plen = (u8) plen;
1365
1366         /*
1367          * If we don't have all the pdata yet, then bail.
1368          * We'll continue process when more data arrives.
1369          */
1370         if (ep->mpa_pkt_len < (sizeof(*mpa) + plen))
1371                 return 0;
1372
1373         if (mpa->flags & MPA_REJECT) {
1374                 err = -ECONNREFUSED;
1375                 goto err;
1376         }
1377
1378         /*
1379          * If we get here we have accumulated the entire mpa
1380          * start reply message including private data. And
1381          * the MPA header is valid.
1382          */
1383         __state_set(&ep->com, FPDU_MODE);
1384         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
1385         ep->mpa_attr.recv_marker_enabled = markers_enabled;
1386         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
1387         ep->mpa_attr.version = mpa->revision;
1388         ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
1389
1390         if (mpa->revision == 2) {
1391                 ep->mpa_attr.enhanced_rdma_conn =
1392                         mpa->flags & MPA_ENHANCED_RDMA_CONN ? 1 : 0;
1393                 if (ep->mpa_attr.enhanced_rdma_conn) {
1394                         mpa_v2_params = (struct mpa_v2_conn_params *)
1395                                 (ep->mpa_pkt + sizeof(*mpa));
1396                         resp_ird = ntohs(mpa_v2_params->ird) &
1397                                 MPA_V2_IRD_ORD_MASK;
1398                         resp_ord = ntohs(mpa_v2_params->ord) &
1399                                 MPA_V2_IRD_ORD_MASK;
1400                         PDBG("%s responder ird %u ord %u ep ird %u ord %u\n",
1401                              __func__, resp_ird, resp_ord, ep->ird, ep->ord);
1402
1403                         /*
1404                          * This is a double-check. Ideally, below checks are
1405                          * not required since ird/ord stuff has been taken
1406                          * care of in c4iw_accept_cr
1407                          */
1408                         if (ep->ird < resp_ord) {
1409                                 if (RELAXED_IRD_NEGOTIATION && resp_ord <=
1410                                     ep->com.dev->rdev.lldi.max_ordird_qp)
1411                                         ep->ird = resp_ord;
1412                                 else
1413                                         insuff_ird = 1;
1414                         } else if (ep->ird > resp_ord) {
1415                                 ep->ird = resp_ord;
1416                         }
1417                         if (ep->ord > resp_ird) {
1418                                 if (RELAXED_IRD_NEGOTIATION)
1419                                         ep->ord = resp_ird;
1420                                 else
1421                                         insuff_ird = 1;
1422                         }
1423                         if (insuff_ird) {
1424                                 err = -ENOMEM;
1425                                 ep->ird = resp_ord;
1426                                 ep->ord = resp_ird;
1427                         }
1428
1429                         if (ntohs(mpa_v2_params->ird) &
1430                                         MPA_V2_PEER2PEER_MODEL) {
1431                                 if (ntohs(mpa_v2_params->ord) &
1432                                                 MPA_V2_RDMA_WRITE_RTR)
1433                                         ep->mpa_attr.p2p_type =
1434                                                 FW_RI_INIT_P2PTYPE_RDMA_WRITE;
1435                                 else if (ntohs(mpa_v2_params->ord) &
1436                                                 MPA_V2_RDMA_READ_RTR)
1437                                         ep->mpa_attr.p2p_type =
1438                                                 FW_RI_INIT_P2PTYPE_READ_REQ;
1439                         }
1440                 }
1441         } else if (mpa->revision == 1)
1442                 if (peer2peer)
1443                         ep->mpa_attr.p2p_type = p2p_type;
1444
1445         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
1446              "xmit_marker_enabled=%d, version=%d p2p_type=%d local-p2p_type = "
1447              "%d\n", __func__, ep->mpa_attr.crc_enabled,
1448              ep->mpa_attr.recv_marker_enabled,
1449              ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version,
1450              ep->mpa_attr.p2p_type, p2p_type);
1451
1452         /*
1453          * If responder's RTR does not match with that of initiator, assign
1454          * FW_RI_INIT_P2PTYPE_DISABLED in mpa attributes so that RTR is not
1455          * generated when moving QP to RTS state.
1456          * A TERM message will be sent after QP has moved to RTS state
1457          */
1458         if ((ep->mpa_attr.version == 2) && peer2peer &&
1459                         (ep->mpa_attr.p2p_type != p2p_type)) {
1460                 ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
1461                 rtr_mismatch = 1;
1462         }
1463
1464         attrs.mpa_attr = ep->mpa_attr;
1465         attrs.max_ird = ep->ird;
1466         attrs.max_ord = ep->ord;
1467         attrs.llp_stream_handle = ep;
1468         attrs.next_state = C4IW_QP_STATE_RTS;
1469
1470         mask = C4IW_QP_ATTR_NEXT_STATE |
1471             C4IW_QP_ATTR_LLP_STREAM_HANDLE | C4IW_QP_ATTR_MPA_ATTR |
1472             C4IW_QP_ATTR_MAX_IRD | C4IW_QP_ATTR_MAX_ORD;
1473
1474         /* bind QP and TID with INIT_WR */
1475         err = c4iw_modify_qp(ep->com.qp->rhp,
1476                              ep->com.qp, mask, &attrs, 1);
1477         if (err)
1478                 goto err;
1479
1480         /*
1481          * If responder's RTR requirement did not match with what initiator
1482          * supports, generate TERM message
1483          */
1484         if (rtr_mismatch) {
1485                 printk(KERN_ERR "%s: RTR mismatch, sending TERM\n", __func__);
1486                 attrs.layer_etype = LAYER_MPA | DDP_LLP;
1487                 attrs.ecode = MPA_NOMATCH_RTR;
1488                 attrs.next_state = C4IW_QP_STATE_TERMINATE;
1489                 attrs.send_term = 1;
1490                 err = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
1491                                 C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
1492                 err = -ENOMEM;
1493                 disconnect = 1;
1494                 goto out;
1495         }
1496
1497         /*
1498          * Generate TERM if initiator IRD is not sufficient for responder
1499          * provided ORD. Currently, we do the same behaviour even when
1500          * responder provided IRD is also not sufficient as regards to
1501          * initiator ORD.
1502          */
1503         if (insuff_ird) {
1504                 printk(KERN_ERR "%s: Insufficient IRD, sending TERM\n",
1505                                 __func__);
1506                 attrs.layer_etype = LAYER_MPA | DDP_LLP;
1507                 attrs.ecode = MPA_INSUFF_IRD;
1508                 attrs.next_state = C4IW_QP_STATE_TERMINATE;
1509                 attrs.send_term = 1;
1510                 err = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
1511                                 C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
1512                 err = -ENOMEM;
1513                 disconnect = 1;
1514                 goto out;
1515         }
1516         goto out;
1517 err:
1518         __state_set(&ep->com, ABORTING);
1519         send_abort(ep, skb, GFP_KERNEL);
1520 out:
1521         connect_reply_upcall(ep, err);
1522         return disconnect;
1523 }
1524
1525 static void process_mpa_request(struct c4iw_ep *ep, struct sk_buff *skb)
1526 {
1527         struct mpa_message *mpa;
1528         struct mpa_v2_conn_params *mpa_v2_params;
1529         u16 plen;
1530
1531         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1532
1533         /*
1534          * If we get more than the supported amount of private data
1535          * then we must fail this connection.
1536          */
1537         if (ep->mpa_pkt_len + skb->len > sizeof(ep->mpa_pkt)) {
1538                 (void)stop_ep_timer(ep);
1539                 abort_connection(ep, skb, GFP_KERNEL);
1540                 return;
1541         }
1542
1543         PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
1544
1545         /*
1546          * Copy the new data into our accumulation buffer.
1547          */
1548         skb_copy_from_linear_data(skb, &(ep->mpa_pkt[ep->mpa_pkt_len]),
1549                                   skb->len);
1550         ep->mpa_pkt_len += skb->len;
1551
1552         /*
1553          * If we don't even have the mpa message, then bail.
1554          * We'll continue process when more data arrives.
1555          */
1556         if (ep->mpa_pkt_len < sizeof(*mpa))
1557                 return;
1558
1559         PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
1560         mpa = (struct mpa_message *) ep->mpa_pkt;
1561
1562         /*
1563          * Validate MPA Header.
1564          */
1565         if (mpa->revision > mpa_rev) {
1566                 printk(KERN_ERR MOD "%s MPA version mismatch. Local = %d,"
1567                        " Received = %d\n", __func__, mpa_rev, mpa->revision);
1568                 (void)stop_ep_timer(ep);
1569                 abort_connection(ep, skb, GFP_KERNEL);
1570                 return;
1571         }
1572
1573         if (memcmp(mpa->key, MPA_KEY_REQ, sizeof(mpa->key))) {
1574                 (void)stop_ep_timer(ep);
1575                 abort_connection(ep, skb, GFP_KERNEL);
1576                 return;
1577         }
1578
1579         plen = ntohs(mpa->private_data_size);
1580
1581         /*
1582          * Fail if there's too much private data.
1583          */
1584         if (plen > MPA_MAX_PRIVATE_DATA) {
1585                 (void)stop_ep_timer(ep);
1586                 abort_connection(ep, skb, GFP_KERNEL);
1587                 return;
1588         }
1589
1590         /*
1591          * If plen does not account for pkt size
1592          */
1593         if (ep->mpa_pkt_len > (sizeof(*mpa) + plen)) {
1594                 (void)stop_ep_timer(ep);
1595                 abort_connection(ep, skb, GFP_KERNEL);
1596                 return;
1597         }
1598         ep->plen = (u8) plen;
1599
1600         /*
1601          * If we don't have all the pdata yet, then bail.
1602          */
1603         if (ep->mpa_pkt_len < (sizeof(*mpa) + plen))
1604                 return;
1605
1606         /*
1607          * If we get here we have accumulated the entire mpa
1608          * start reply message including private data.
1609          */
1610         ep->mpa_attr.initiator = 0;
1611         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
1612         ep->mpa_attr.recv_marker_enabled = markers_enabled;
1613         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
1614         ep->mpa_attr.version = mpa->revision;
1615         if (mpa->revision == 1)
1616                 ep->tried_with_mpa_v1 = 1;
1617         ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
1618
1619         if (mpa->revision == 2) {
1620                 ep->mpa_attr.enhanced_rdma_conn =
1621                         mpa->flags & MPA_ENHANCED_RDMA_CONN ? 1 : 0;
1622                 if (ep->mpa_attr.enhanced_rdma_conn) {
1623                         mpa_v2_params = (struct mpa_v2_conn_params *)
1624                                 (ep->mpa_pkt + sizeof(*mpa));
1625                         ep->ird = ntohs(mpa_v2_params->ird) &
1626                                 MPA_V2_IRD_ORD_MASK;
1627                         ep->ord = ntohs(mpa_v2_params->ord) &
1628                                 MPA_V2_IRD_ORD_MASK;
1629                         PDBG("%s initiator ird %u ord %u\n", __func__, ep->ird,
1630                              ep->ord);
1631                         if (ntohs(mpa_v2_params->ird) & MPA_V2_PEER2PEER_MODEL)
1632                                 if (peer2peer) {
1633                                         if (ntohs(mpa_v2_params->ord) &
1634                                                         MPA_V2_RDMA_WRITE_RTR)
1635                                                 ep->mpa_attr.p2p_type =
1636                                                 FW_RI_INIT_P2PTYPE_RDMA_WRITE;
1637                                         else if (ntohs(mpa_v2_params->ord) &
1638                                                         MPA_V2_RDMA_READ_RTR)
1639                                                 ep->mpa_attr.p2p_type =
1640                                                 FW_RI_INIT_P2PTYPE_READ_REQ;
1641                                 }
1642                 }
1643         } else if (mpa->revision == 1)
1644                 if (peer2peer)
1645                         ep->mpa_attr.p2p_type = p2p_type;
1646
1647         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
1648              "xmit_marker_enabled=%d, version=%d p2p_type=%d\n", __func__,
1649              ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
1650              ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version,
1651              ep->mpa_attr.p2p_type);
1652
1653         /*
1654          * If the endpoint timer already expired, then we ignore
1655          * the start request.  process_timeout() will abort
1656          * the connection.
1657          */
1658         if (!stop_ep_timer(ep)) {
1659                 __state_set(&ep->com, MPA_REQ_RCVD);
1660
1661                 /* drive upcall */
1662                 mutex_lock_nested(&ep->parent_ep->com.mutex,
1663                                   SINGLE_DEPTH_NESTING);
1664                 if (ep->parent_ep->com.state != DEAD) {
1665                         if (connect_request_upcall(ep))
1666                                 abort_connection(ep, skb, GFP_KERNEL);
1667                 } else {
1668                         abort_connection(ep, skb, GFP_KERNEL);
1669                 }
1670                 mutex_unlock(&ep->parent_ep->com.mutex);
1671         }
1672         return;
1673 }
1674
1675 static int rx_data(struct c4iw_dev *dev, struct sk_buff *skb)
1676 {
1677         struct c4iw_ep *ep;
1678         struct cpl_rx_data *hdr = cplhdr(skb);
1679         unsigned int dlen = ntohs(hdr->len);
1680         unsigned int tid = GET_TID(hdr);
1681         struct tid_info *t = dev->rdev.lldi.tids;
1682         __u8 status = hdr->status;
1683         int disconnect = 0;
1684
1685         ep = lookup_tid(t, tid);
1686         if (!ep)
1687                 return 0;
1688         PDBG("%s ep %p tid %u dlen %u\n", __func__, ep, ep->hwtid, dlen);
1689         skb_pull(skb, sizeof(*hdr));
1690         skb_trim(skb, dlen);
1691         mutex_lock(&ep->com.mutex);
1692
1693         /* update RX credits */
1694         update_rx_credits(ep, dlen);
1695
1696         switch (ep->com.state) {
1697         case MPA_REQ_SENT:
1698                 ep->rcv_seq += dlen;
1699                 disconnect = process_mpa_reply(ep, skb);
1700                 break;
1701         case MPA_REQ_WAIT:
1702                 ep->rcv_seq += dlen;
1703                 process_mpa_request(ep, skb);
1704                 break;
1705         case FPDU_MODE: {
1706                 struct c4iw_qp_attributes attrs;
1707                 BUG_ON(!ep->com.qp);
1708                 if (status)
1709                         pr_err("%s Unexpected streaming data." \
1710                                " qpid %u ep %p state %d tid %u status %d\n",
1711                                __func__, ep->com.qp->wq.sq.qid, ep,
1712                                ep->com.state, ep->hwtid, status);
1713                 attrs.next_state = C4IW_QP_STATE_TERMINATE;
1714                 c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
1715                                C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
1716                 disconnect = 1;
1717                 break;
1718         }
1719         default:
1720                 break;
1721         }
1722         mutex_unlock(&ep->com.mutex);
1723         if (disconnect)
1724                 c4iw_ep_disconnect(ep, 0, GFP_KERNEL);
1725         return 0;
1726 }
1727
1728 static int abort_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
1729 {
1730         struct c4iw_ep *ep;
1731         struct cpl_abort_rpl_rss *rpl = cplhdr(skb);
1732         int release = 0;
1733         unsigned int tid = GET_TID(rpl);
1734         struct tid_info *t = dev->rdev.lldi.tids;
1735
1736         ep = lookup_tid(t, tid);
1737         if (!ep) {
1738                 printk(KERN_WARNING MOD "Abort rpl to freed endpoint\n");
1739                 return 0;
1740         }
1741         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
1742         mutex_lock(&ep->com.mutex);
1743         switch (ep->com.state) {
1744         case ABORTING:
1745                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
1746                 __state_set(&ep->com, DEAD);
1747                 release = 1;
1748                 break;
1749         default:
1750                 printk(KERN_ERR "%s ep %p state %d\n",
1751                      __func__, ep, ep->com.state);
1752                 break;
1753         }
1754         mutex_unlock(&ep->com.mutex);
1755
1756         if (release)
1757                 release_ep_resources(ep);
1758         return 0;
1759 }
1760
1761 static void send_fw_act_open_req(struct c4iw_ep *ep, unsigned int atid)
1762 {
1763         struct sk_buff *skb;
1764         struct fw_ofld_connection_wr *req;
1765         unsigned int mtu_idx;
1766         int wscale;
1767         struct sockaddr_in *sin;
1768         int win;
1769
1770         skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
1771         req = (struct fw_ofld_connection_wr *)__skb_put(skb, sizeof(*req));
1772         memset(req, 0, sizeof(*req));
1773         req->op_compl = htonl(WR_OP_V(FW_OFLD_CONNECTION_WR));
1774         req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));
1775         req->le.filter = cpu_to_be32(cxgb4_select_ntuple(
1776                                      ep->com.dev->rdev.lldi.ports[0],
1777                                      ep->l2t));
1778         sin = (struct sockaddr_in *)&ep->com.local_addr;
1779         req->le.lport = sin->sin_port;
1780         req->le.u.ipv4.lip = sin->sin_addr.s_addr;
1781         sin = (struct sockaddr_in *)&ep->com.remote_addr;
1782         req->le.pport = sin->sin_port;
1783         req->le.u.ipv4.pip = sin->sin_addr.s_addr;
1784         req->tcb.t_state_to_astid =
1785                         htonl(FW_OFLD_CONNECTION_WR_T_STATE_V(TCP_SYN_SENT) |
1786                         FW_OFLD_CONNECTION_WR_ASTID_V(atid));
1787         req->tcb.cplrxdataack_cplpassacceptrpl =
1788                         htons(FW_OFLD_CONNECTION_WR_CPLRXDATAACK_F);
1789         req->tcb.tx_max = (__force __be32) jiffies;
1790         req->tcb.rcv_adv = htons(1);
1791         best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx,
1792                  enable_tcp_timestamps,
1793                  (AF_INET == ep->com.remote_addr.ss_family) ? 0 : 1);
1794         wscale = compute_wscale(rcv_win);
1795
1796         /*
1797          * Specify the largest window that will fit in opt0. The
1798          * remainder will be specified in the rx_data_ack.
1799          */
1800         win = ep->rcv_win >> 10;
1801         if (win > RCV_BUFSIZ_M)
1802                 win = RCV_BUFSIZ_M;
1803
1804         req->tcb.opt0 = (__force __be64) (TCAM_BYPASS_F |
1805                 (nocong ? NO_CONG_F : 0) |
1806                 KEEP_ALIVE_F |
1807                 DELACK_F |
1808                 WND_SCALE_V(wscale) |
1809                 MSS_IDX_V(mtu_idx) |
1810                 L2T_IDX_V(ep->l2t->idx) |
1811                 TX_CHAN_V(ep->tx_chan) |
1812                 SMAC_SEL_V(ep->smac_idx) |
1813                 DSCP_V(ep->tos) |
1814                 ULP_MODE_V(ULP_MODE_TCPDDP) |
1815                 RCV_BUFSIZ_V(win));
1816         req->tcb.opt2 = (__force __be32) (PACE_V(1) |
1817                 TX_QUEUE_V(ep->com.dev->rdev.lldi.tx_modq[ep->tx_chan]) |
1818                 RX_CHANNEL_V(0) |
1819                 CCTRL_ECN_V(enable_ecn) |
1820                 RSS_QUEUE_VALID_F | RSS_QUEUE_V(ep->rss_qid));
1821         if (enable_tcp_timestamps)
1822                 req->tcb.opt2 |= (__force __be32)TSTAMPS_EN_F;
1823         if (enable_tcp_sack)
1824                 req->tcb.opt2 |= (__force __be32)SACK_EN_F;
1825         if (wscale && enable_tcp_window_scaling)
1826                 req->tcb.opt2 |= (__force __be32)WND_SCALE_EN_F;
1827         req->tcb.opt0 = cpu_to_be64((__force u64)req->tcb.opt0);
1828         req->tcb.opt2 = cpu_to_be32((__force u32)req->tcb.opt2);
1829         set_wr_txq(skb, CPL_PRIORITY_CONTROL, ep->ctrlq_idx);
1830         set_bit(ACT_OFLD_CONN, &ep->com.history);
1831         c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
1832 }
1833
1834 /*
1835  * Return whether a failed active open has allocated a TID
1836  */
1837 static inline int act_open_has_tid(int status)
1838 {
1839         return status != CPL_ERR_TCAM_FULL && status != CPL_ERR_CONN_EXIST &&
1840                status != CPL_ERR_ARP_MISS;
1841 }
1842
1843 /* Returns whether a CPL status conveys negative advice.
1844  */
1845 static int is_neg_adv(unsigned int status)
1846 {
1847         return status == CPL_ERR_RTX_NEG_ADVICE ||
1848                status == CPL_ERR_PERSIST_NEG_ADVICE ||
1849                status == CPL_ERR_KEEPALV_NEG_ADVICE;
1850 }
1851
1852 static char *neg_adv_str(unsigned int status)
1853 {
1854         switch (status) {
1855         case CPL_ERR_RTX_NEG_ADVICE:
1856                 return "Retransmit timeout";
1857         case CPL_ERR_PERSIST_NEG_ADVICE:
1858                 return "Persist timeout";
1859         case CPL_ERR_KEEPALV_NEG_ADVICE:
1860                 return "Keepalive timeout";
1861         default:
1862                 return "Unknown";
1863         }
1864 }
1865
1866 static void set_tcp_window(struct c4iw_ep *ep, struct port_info *pi)
1867 {
1868         ep->snd_win = snd_win;
1869         ep->rcv_win = rcv_win;
1870         PDBG("%s snd_win %d rcv_win %d\n", __func__, ep->snd_win, ep->rcv_win);
1871 }
1872
1873 #define ACT_OPEN_RETRY_COUNT 2
1874
1875 static int import_ep(struct c4iw_ep *ep, int iptype, __u8 *peer_ip,
1876                      struct dst_entry *dst, struct c4iw_dev *cdev,
1877                      bool clear_mpa_v1, enum chip_type adapter_type)
1878 {
1879         struct neighbour *n;
1880         int err, step;
1881         struct net_device *pdev;
1882
1883         n = dst_neigh_lookup(dst, peer_ip);
1884         if (!n)
1885                 return -ENODEV;
1886
1887         rcu_read_lock();
1888         err = -ENOMEM;
1889         if (n->dev->flags & IFF_LOOPBACK) {
1890                 if (iptype == 4)
1891                         pdev = ip_dev_find(&init_net, *(__be32 *)peer_ip);
1892                 else if (IS_ENABLED(CONFIG_IPV6))
1893                         for_each_netdev(&init_net, pdev) {
1894                                 if (ipv6_chk_addr(&init_net,
1895                                                   (struct in6_addr *)peer_ip,
1896                                                   pdev, 1))
1897                                         break;
1898                         }
1899                 else
1900                         pdev = NULL;
1901
1902                 if (!pdev) {
1903                         err = -ENODEV;
1904                         goto out;
1905                 }
1906                 ep->l2t = cxgb4_l2t_get(cdev->rdev.lldi.l2t,
1907                                         n, pdev, 0);
1908                 if (!ep->l2t)
1909                         goto out;
1910                 ep->mtu = pdev->mtu;
1911                 ep->tx_chan = cxgb4_port_chan(pdev);
1912                 ep->smac_idx = cxgb4_tp_smt_idx(adapter_type,
1913                                                 cxgb4_port_viid(pdev));
1914                 step = cdev->rdev.lldi.ntxq /
1915                         cdev->rdev.lldi.nchan;
1916                 ep->txq_idx = cxgb4_port_idx(pdev) * step;
1917                 step = cdev->rdev.lldi.nrxq /
1918                         cdev->rdev.lldi.nchan;
1919                 ep->ctrlq_idx = cxgb4_port_idx(pdev);
1920                 ep->rss_qid = cdev->rdev.lldi.rxq_ids[
1921                         cxgb4_port_idx(pdev) * step];
1922                 set_tcp_window(ep, (struct port_info *)netdev_priv(pdev));
1923                 dev_put(pdev);
1924         } else {
1925                 pdev = get_real_dev(n->dev);
1926                 ep->l2t = cxgb4_l2t_get(cdev->rdev.lldi.l2t,
1927                                         n, pdev, 0);
1928                 if (!ep->l2t)
1929                         goto out;
1930                 ep->mtu = dst_mtu(dst);
1931                 ep->tx_chan = cxgb4_port_chan(pdev);
1932                 ep->smac_idx = cxgb4_tp_smt_idx(adapter_type,
1933                                                 cxgb4_port_viid(pdev));
1934                 step = cdev->rdev.lldi.ntxq /
1935                         cdev->rdev.lldi.nchan;
1936                 ep->txq_idx = cxgb4_port_idx(pdev) * step;
1937                 ep->ctrlq_idx = cxgb4_port_idx(pdev);
1938                 step = cdev->rdev.lldi.nrxq /
1939                         cdev->rdev.lldi.nchan;
1940                 ep->rss_qid = cdev->rdev.lldi.rxq_ids[
1941                         cxgb4_port_idx(pdev) * step];
1942                 set_tcp_window(ep, (struct port_info *)netdev_priv(pdev));
1943
1944                 if (clear_mpa_v1) {
1945                         ep->retry_with_mpa_v1 = 0;
1946                         ep->tried_with_mpa_v1 = 0;
1947                 }
1948         }
1949         err = 0;
1950 out:
1951         rcu_read_unlock();
1952
1953         neigh_release(n);
1954
1955         return err;
1956 }
1957
1958 static int c4iw_reconnect(struct c4iw_ep *ep)
1959 {
1960         int err = 0;
1961         struct sockaddr_in *laddr = (struct sockaddr_in *)
1962                                     &ep->com.cm_id->m_local_addr;
1963         struct sockaddr_in *raddr = (struct sockaddr_in *)
1964                                     &ep->com.cm_id->m_remote_addr;
1965         struct sockaddr_in6 *laddr6 = (struct sockaddr_in6 *)
1966                                       &ep->com.cm_id->m_local_addr;
1967         struct sockaddr_in6 *raddr6 = (struct sockaddr_in6 *)
1968                                       &ep->com.cm_id->m_remote_addr;
1969         int iptype;
1970         __u8 *ra;
1971
1972         PDBG("%s qp %p cm_id %p\n", __func__, ep->com.qp, ep->com.cm_id);
1973         init_timer(&ep->timer);
1974
1975         /*
1976          * Allocate an active TID to initiate a TCP connection.
1977          */
1978         ep->atid = cxgb4_alloc_atid(ep->com.dev->rdev.lldi.tids, ep);
1979         if (ep->atid == -1) {
1980                 pr_err("%s - cannot alloc atid.\n", __func__);
1981                 err = -ENOMEM;
1982                 goto fail2;
1983         }
1984         insert_handle(ep->com.dev, &ep->com.dev->atid_idr, ep, ep->atid);
1985
1986         /* find a route */
1987         if (ep->com.cm_id->m_local_addr.ss_family == AF_INET) {
1988                 ep->dst = find_route(ep->com.dev, laddr->sin_addr.s_addr,
1989                                      raddr->sin_addr.s_addr, laddr->sin_port,
1990                                      raddr->sin_port, 0);
1991                 iptype = 4;
1992                 ra = (__u8 *)&raddr->sin_addr;
1993         } else {
1994                 ep->dst = find_route6(ep->com.dev, laddr6->sin6_addr.s6_addr,
1995                                       raddr6->sin6_addr.s6_addr,
1996                                       laddr6->sin6_port, raddr6->sin6_port, 0,
1997                                       raddr6->sin6_scope_id);
1998                 iptype = 6;
1999                 ra = (__u8 *)&raddr6->sin6_addr;
2000         }
2001         if (!ep->dst) {
2002                 pr_err("%s - cannot find route.\n", __func__);
2003                 err = -EHOSTUNREACH;
2004                 goto fail3;
2005         }
2006         err = import_ep(ep, iptype, ra, ep->dst, ep->com.dev, false,
2007                         ep->com.dev->rdev.lldi.adapter_type);
2008         if (err) {
2009                 pr_err("%s - cannot alloc l2e.\n", __func__);
2010                 goto fail4;
2011         }
2012
2013         PDBG("%s txq_idx %u tx_chan %u smac_idx %u rss_qid %u l2t_idx %u\n",
2014              __func__, ep->txq_idx, ep->tx_chan, ep->smac_idx, ep->rss_qid,
2015              ep->l2t->idx);
2016
2017         state_set(&ep->com, CONNECTING);
2018         ep->tos = 0;
2019
2020         /* send connect request to rnic */
2021         err = send_connect(ep);
2022         if (!err)
2023                 goto out;
2024
2025         cxgb4_l2t_release(ep->l2t);
2026 fail4:
2027         dst_release(ep->dst);
2028 fail3:
2029         remove_handle(ep->com.dev, &ep->com.dev->atid_idr, ep->atid);
2030         cxgb4_free_atid(ep->com.dev->rdev.lldi.tids, ep->atid);
2031 fail2:
2032         /*
2033          * remember to send notification to upper layer.
2034          * We are in here so the upper layer is not aware that this is
2035          * re-connect attempt and so, upper layer is still waiting for
2036          * response of 1st connect request.
2037          */
2038         connect_reply_upcall(ep, -ECONNRESET);
2039         c4iw_put_ep(&ep->com);
2040 out:
2041         return err;
2042 }
2043
2044 static int act_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
2045 {
2046         struct c4iw_ep *ep;
2047         struct cpl_act_open_rpl *rpl = cplhdr(skb);
2048         unsigned int atid = TID_TID_G(AOPEN_ATID_G(
2049                                       ntohl(rpl->atid_status)));
2050         struct tid_info *t = dev->rdev.lldi.tids;
2051         int status = AOPEN_STATUS_G(ntohl(rpl->atid_status));
2052         struct sockaddr_in *la;
2053         struct sockaddr_in *ra;
2054         struct sockaddr_in6 *la6;
2055         struct sockaddr_in6 *ra6;
2056
2057         ep = lookup_atid(t, atid);
2058         la = (struct sockaddr_in *)&ep->com.local_addr;
2059         ra = (struct sockaddr_in *)&ep->com.remote_addr;
2060         la6 = (struct sockaddr_in6 *)&ep->com.local_addr;
2061         ra6 = (struct sockaddr_in6 *)&ep->com.remote_addr;
2062
2063         PDBG("%s ep %p atid %u status %u errno %d\n", __func__, ep, atid,
2064              status, status2errno(status));
2065
2066         if (is_neg_adv(status)) {
2067                 PDBG("%s Connection problems for atid %u status %u (%s)\n",
2068                      __func__, atid, status, neg_adv_str(status));
2069                 ep->stats.connect_neg_adv++;
2070                 mutex_lock(&dev->rdev.stats.lock);
2071                 dev->rdev.stats.neg_adv++;
2072                 mutex_unlock(&dev->rdev.stats.lock);
2073                 return 0;
2074         }
2075
2076         set_bit(ACT_OPEN_RPL, &ep->com.history);
2077
2078         /*
2079          * Log interesting failures.
2080          */
2081         switch (status) {
2082         case CPL_ERR_CONN_RESET:
2083         case CPL_ERR_CONN_TIMEDOUT:
2084                 break;
2085         case CPL_ERR_TCAM_FULL:
2086                 mutex_lock(&dev->rdev.stats.lock);
2087                 dev->rdev.stats.tcam_full++;
2088                 mutex_unlock(&dev->rdev.stats.lock);
2089                 if (ep->com.local_addr.ss_family == AF_INET &&
2090                     dev->rdev.lldi.enable_fw_ofld_conn) {
2091                         send_fw_act_open_req(ep,
2092                                              TID_TID_G(AOPEN_ATID_G(
2093                                              ntohl(rpl->atid_status))));
2094                         return 0;
2095                 }
2096                 break;
2097         case CPL_ERR_CONN_EXIST:
2098                 if (ep->retry_count++ < ACT_OPEN_RETRY_COUNT) {
2099                         set_bit(ACT_RETRY_INUSE, &ep->com.history);
2100                         if (ep->com.remote_addr.ss_family == AF_INET6) {
2101                                 struct sockaddr_in6 *sin6 =
2102                                                 (struct sockaddr_in6 *)
2103                                                 &ep->com.local_addr;
2104                                 cxgb4_clip_release(
2105                                                 ep->com.dev->rdev.lldi.ports[0],
2106                                                 (const u32 *)
2107                                                 &sin6->sin6_addr.s6_addr, 1);
2108                         }
2109                         remove_handle(ep->com.dev, &ep->com.dev->atid_idr,
2110                                         atid);
2111                         cxgb4_free_atid(t, atid);
2112                         dst_release(ep->dst);
2113                         cxgb4_l2t_release(ep->l2t);
2114                         c4iw_reconnect(ep);
2115                         return 0;
2116                 }
2117                 break;
2118         default:
2119                 if (ep->com.local_addr.ss_family == AF_INET) {
2120                         pr_info("Active open failure - atid %u status %u errno %d %pI4:%u->%pI4:%u\n",
2121                                 atid, status, status2errno(status),
2122                                 &la->sin_addr.s_addr, ntohs(la->sin_port),
2123                                 &ra->sin_addr.s_addr, ntohs(ra->sin_port));
2124                 } else {
2125                         pr_info("Active open failure - atid %u status %u errno %d %pI6:%u->%pI6:%u\n",
2126                                 atid, status, status2errno(status),
2127                                 la6->sin6_addr.s6_addr, ntohs(la6->sin6_port),
2128                                 ra6->sin6_addr.s6_addr, ntohs(ra6->sin6_port));
2129                 }
2130                 break;
2131         }
2132
2133         connect_reply_upcall(ep, status2errno(status));
2134         state_set(&ep->com, DEAD);
2135
2136         if (ep->com.remote_addr.ss_family == AF_INET6) {
2137                 struct sockaddr_in6 *sin6 =
2138                         (struct sockaddr_in6 *)&ep->com.local_addr;
2139                 cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
2140                                    (const u32 *)&sin6->sin6_addr.s6_addr, 1);
2141         }
2142         if (status && act_open_has_tid(status))
2143                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, GET_TID(rpl));
2144
2145         remove_handle(ep->com.dev, &ep->com.dev->atid_idr, atid);
2146         cxgb4_free_atid(t, atid);
2147         dst_release(ep->dst);
2148         cxgb4_l2t_release(ep->l2t);
2149         c4iw_put_ep(&ep->com);
2150
2151         return 0;
2152 }
2153
2154 static int pass_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
2155 {
2156         struct cpl_pass_open_rpl *rpl = cplhdr(skb);
2157         struct tid_info *t = dev->rdev.lldi.tids;
2158         unsigned int stid = GET_TID(rpl);
2159         struct c4iw_listen_ep *ep = lookup_stid(t, stid);
2160
2161         if (!ep) {
2162                 PDBG("%s stid %d lookup failure!\n", __func__, stid);
2163                 goto out;
2164         }
2165         PDBG("%s ep %p status %d error %d\n", __func__, ep,
2166              rpl->status, status2errno(rpl->status));
2167         c4iw_wake_up(&ep->com.wr_wait, status2errno(rpl->status));
2168
2169 out:
2170         return 0;
2171 }
2172
2173 static int close_listsrv_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
2174 {
2175         struct cpl_close_listsvr_rpl *rpl = cplhdr(skb);
2176         struct tid_info *t = dev->rdev.lldi.tids;
2177         unsigned int stid = GET_TID(rpl);
2178         struct c4iw_listen_ep *ep = lookup_stid(t, stid);
2179
2180         PDBG("%s ep %p\n", __func__, ep);
2181         c4iw_wake_up(&ep->com.wr_wait, status2errno(rpl->status));
2182         return 0;
2183 }
2184
2185 static void accept_cr(struct c4iw_ep *ep, struct sk_buff *skb,
2186                       struct cpl_pass_accept_req *req)
2187 {
2188         struct cpl_pass_accept_rpl *rpl;
2189         unsigned int mtu_idx;
2190         u64 opt0;
2191         u32 opt2;
2192         int wscale;
2193         struct cpl_t5_pass_accept_rpl *rpl5 = NULL;
2194         int win;
2195         enum chip_type adapter_type = ep->com.dev->rdev.lldi.adapter_type;
2196
2197         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2198         BUG_ON(skb_cloned(skb));
2199
2200         skb_get(skb);
2201         rpl = cplhdr(skb);
2202         if (!is_t4(adapter_type)) {
2203                 skb_trim(skb, roundup(sizeof(*rpl5), 16));
2204                 rpl5 = (void *)rpl;
2205                 INIT_TP_WR(rpl5, ep->hwtid);
2206         } else {
2207                 skb_trim(skb, sizeof(*rpl));
2208                 INIT_TP_WR(rpl, ep->hwtid);
2209         }
2210         OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_PASS_ACCEPT_RPL,
2211                                                     ep->hwtid));
2212
2213         best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx,
2214                  enable_tcp_timestamps && req->tcpopt.tstamp,
2215                  (AF_INET == ep->com.remote_addr.ss_family) ? 0 : 1);
2216         wscale = compute_wscale(rcv_win);
2217
2218         /*
2219          * Specify the largest window that will fit in opt0. The
2220          * remainder will be specified in the rx_data_ack.
2221          */
2222         win = ep->rcv_win >> 10;
2223         if (win > RCV_BUFSIZ_M)
2224                 win = RCV_BUFSIZ_M;
2225         opt0 = (nocong ? NO_CONG_F : 0) |
2226                KEEP_ALIVE_F |
2227                DELACK_F |
2228                WND_SCALE_V(wscale) |
2229                MSS_IDX_V(mtu_idx) |
2230                L2T_IDX_V(ep->l2t->idx) |
2231                TX_CHAN_V(ep->tx_chan) |
2232                SMAC_SEL_V(ep->smac_idx) |
2233                DSCP_V(ep->tos >> 2) |
2234                ULP_MODE_V(ULP_MODE_TCPDDP) |
2235                RCV_BUFSIZ_V(win);
2236         opt2 = RX_CHANNEL_V(0) |
2237                RSS_QUEUE_VALID_F | RSS_QUEUE_V(ep->rss_qid);
2238
2239         if (enable_tcp_timestamps && req->tcpopt.tstamp)
2240                 opt2 |= TSTAMPS_EN_F;
2241         if (enable_tcp_sack && req->tcpopt.sack)
2242                 opt2 |= SACK_EN_F;
2243         if (wscale && enable_tcp_window_scaling)
2244                 opt2 |= WND_SCALE_EN_F;
2245         if (enable_ecn) {
2246                 const struct tcphdr *tcph;
2247                 u32 hlen = ntohl(req->hdr_len);
2248
2249                 if (CHELSIO_CHIP_VERSION(adapter_type) <= CHELSIO_T5)
2250                         tcph = (const void *)(req + 1) + ETH_HDR_LEN_G(hlen) +
2251                                 IP_HDR_LEN_G(hlen);
2252                 else
2253                         tcph = (const void *)(req + 1) +
2254                                 T6_ETH_HDR_LEN_G(hlen) + T6_IP_HDR_LEN_G(hlen);
2255                 if (tcph->ece && tcph->cwr)
2256                         opt2 |= CCTRL_ECN_V(1);
2257         }
2258         if (CHELSIO_CHIP_VERSION(adapter_type) > CHELSIO_T4) {
2259                 u32 isn = (prandom_u32() & ~7UL) - 1;
2260                 opt2 |= T5_OPT_2_VALID_F;
2261                 opt2 |= CONG_CNTRL_V(CONG_ALG_TAHOE);
2262                 opt2 |= T5_ISS_F;
2263                 rpl5 = (void *)rpl;
2264                 memset(&rpl5->iss, 0, roundup(sizeof(*rpl5)-sizeof(*rpl), 16));
2265                 if (peer2peer)
2266                         isn += 4;
2267                 rpl5->iss = cpu_to_be32(isn);
2268                 PDBG("%s iss %u\n", __func__, be32_to_cpu(rpl5->iss));
2269         }
2270
2271         rpl->opt0 = cpu_to_be64(opt0);
2272         rpl->opt2 = cpu_to_be32(opt2);
2273         set_wr_txq(skb, CPL_PRIORITY_SETUP, ep->ctrlq_idx);
2274         t4_set_arp_err_handler(skb, NULL, arp_failure_discard);
2275         c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
2276
2277         return;
2278 }
2279
2280 static void reject_cr(struct c4iw_dev *dev, u32 hwtid, struct sk_buff *skb)
2281 {
2282         PDBG("%s c4iw_dev %p tid %u\n", __func__, dev, hwtid);
2283         BUG_ON(skb_cloned(skb));
2284         skb_trim(skb, sizeof(struct cpl_tid_release));
2285         release_tid(&dev->rdev, hwtid, skb);
2286         return;
2287 }
2288
2289 static void get_4tuple(struct cpl_pass_accept_req *req, enum chip_type type,
2290                        int *iptype, __u8 *local_ip, __u8 *peer_ip,
2291                        __be16 *local_port, __be16 *peer_port)
2292 {
2293         int eth_len = (CHELSIO_CHIP_VERSION(type) <= CHELSIO_T5) ?
2294                       ETH_HDR_LEN_G(be32_to_cpu(req->hdr_len)) :
2295                       T6_ETH_HDR_LEN_G(be32_to_cpu(req->hdr_len));
2296         int ip_len = (CHELSIO_CHIP_VERSION(type) <= CHELSIO_T5) ?
2297                      IP_HDR_LEN_G(be32_to_cpu(req->hdr_len)) :
2298                      T6_IP_HDR_LEN_G(be32_to_cpu(req->hdr_len));
2299         struct iphdr *ip = (struct iphdr *)((u8 *)(req + 1) + eth_len);
2300         struct ipv6hdr *ip6 = (struct ipv6hdr *)((u8 *)(req + 1) + eth_len);
2301         struct tcphdr *tcp = (struct tcphdr *)
2302                              ((u8 *)(req + 1) + eth_len + ip_len);
2303
2304         if (ip->version == 4) {
2305                 PDBG("%s saddr 0x%x daddr 0x%x sport %u dport %u\n", __func__,
2306                      ntohl(ip->saddr), ntohl(ip->daddr), ntohs(tcp->source),
2307                      ntohs(tcp->dest));
2308                 *iptype = 4;
2309                 memcpy(peer_ip, &ip->saddr, 4);
2310                 memcpy(local_ip, &ip->daddr, 4);
2311         } else {
2312                 PDBG("%s saddr %pI6 daddr %pI6 sport %u dport %u\n", __func__,
2313                      ip6->saddr.s6_addr, ip6->daddr.s6_addr, ntohs(tcp->source),
2314                      ntohs(tcp->dest));
2315                 *iptype = 6;
2316                 memcpy(peer_ip, ip6->saddr.s6_addr, 16);
2317                 memcpy(local_ip, ip6->daddr.s6_addr, 16);
2318         }
2319         *peer_port = tcp->source;
2320         *local_port = tcp->dest;
2321
2322         return;
2323 }
2324
2325 static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb)
2326 {
2327         struct c4iw_ep *child_ep = NULL, *parent_ep;
2328         struct cpl_pass_accept_req *req = cplhdr(skb);
2329         unsigned int stid = PASS_OPEN_TID_G(ntohl(req->tos_stid));
2330         struct tid_info *t = dev->rdev.lldi.tids;
2331         unsigned int hwtid = GET_TID(req);
2332         struct dst_entry *dst;
2333         __u8 local_ip[16], peer_ip[16];
2334         __be16 local_port, peer_port;
2335         struct sockaddr_in6 *sin6;
2336         int err;
2337         u16 peer_mss = ntohs(req->tcpopt.mss);
2338         int iptype;
2339         unsigned short hdrs;
2340
2341         parent_ep = lookup_stid(t, stid);
2342         if (!parent_ep) {
2343                 PDBG("%s connect request on invalid stid %d\n", __func__, stid);
2344                 goto reject;
2345         }
2346
2347         if (state_read(&parent_ep->com) != LISTEN) {
2348                 printk(KERN_ERR "%s - listening ep not in LISTEN\n",
2349                        __func__);
2350                 goto reject;
2351         }
2352
2353         get_4tuple(req, parent_ep->com.dev->rdev.lldi.adapter_type, &iptype,
2354                    local_ip, peer_ip, &local_port, &peer_port);
2355
2356         /* Find output route */
2357         if (iptype == 4)  {
2358                 PDBG("%s parent ep %p hwtid %u laddr %pI4 raddr %pI4 lport %d rport %d peer_mss %d\n"
2359                      , __func__, parent_ep, hwtid,
2360                      local_ip, peer_ip, ntohs(local_port),
2361                      ntohs(peer_port), peer_mss);
2362                 dst = find_route(dev, *(__be32 *)local_ip, *(__be32 *)peer_ip,
2363                                  local_port, peer_port,
2364                                  PASS_OPEN_TOS_G(ntohl(req->tos_stid)));
2365         } else {
2366                 PDBG("%s parent ep %p hwtid %u laddr %pI6 raddr %pI6 lport %d rport %d peer_mss %d\n"
2367                      , __func__, parent_ep, hwtid,
2368                      local_ip, peer_ip, ntohs(local_port),
2369                      ntohs(peer_port), peer_mss);
2370                 dst = find_route6(dev, local_ip, peer_ip, local_port, peer_port,
2371                                   PASS_OPEN_TOS_G(ntohl(req->tos_stid)),
2372                                   ((struct sockaddr_in6 *)
2373                                   &parent_ep->com.local_addr)->sin6_scope_id);
2374         }
2375         if (!dst) {
2376                 printk(KERN_ERR MOD "%s - failed to find dst entry!\n",
2377                        __func__);
2378                 goto reject;
2379         }
2380
2381         child_ep = alloc_ep(sizeof(*child_ep), GFP_KERNEL);
2382         if (!child_ep) {
2383                 printk(KERN_ERR MOD "%s - failed to allocate ep entry!\n",
2384                        __func__);
2385                 dst_release(dst);
2386                 goto reject;
2387         }
2388
2389         err = import_ep(child_ep, iptype, peer_ip, dst, dev, false,
2390                         parent_ep->com.dev->rdev.lldi.adapter_type);
2391         if (err) {
2392                 printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
2393                        __func__);
2394                 dst_release(dst);
2395                 kfree(child_ep);
2396                 goto reject;
2397         }
2398
2399         hdrs = sizeof(struct iphdr) + sizeof(struct tcphdr) +
2400                ((enable_tcp_timestamps && req->tcpopt.tstamp) ? 12 : 0);
2401         if (peer_mss && child_ep->mtu > (peer_mss + hdrs))
2402                 child_ep->mtu = peer_mss + hdrs;
2403
2404         state_set(&child_ep->com, CONNECTING);
2405         child_ep->com.dev = dev;
2406         child_ep->com.cm_id = NULL;
2407
2408         if (iptype == 4) {
2409                 struct sockaddr_in *sin = (struct sockaddr_in *)
2410                         &child_ep->com.local_addr;
2411
2412                 sin->sin_family = PF_INET;
2413                 sin->sin_port = local_port;
2414                 sin->sin_addr.s_addr = *(__be32 *)local_ip;
2415
2416                 sin = (struct sockaddr_in *)&child_ep->com.local_addr;
2417                 sin->sin_family = PF_INET;
2418                 sin->sin_port = ((struct sockaddr_in *)
2419                                  &parent_ep->com.local_addr)->sin_port;
2420                 sin->sin_addr.s_addr = *(__be32 *)local_ip;
2421
2422                 sin = (struct sockaddr_in *)&child_ep->com.remote_addr;
2423                 sin->sin_family = PF_INET;
2424                 sin->sin_port = peer_port;
2425                 sin->sin_addr.s_addr = *(__be32 *)peer_ip;
2426         } else {
2427                 sin6 = (struct sockaddr_in6 *)&child_ep->com.local_addr;
2428                 sin6->sin6_family = PF_INET6;
2429                 sin6->sin6_port = local_port;
2430                 memcpy(sin6->sin6_addr.s6_addr, local_ip, 16);
2431
2432                 sin6 = (struct sockaddr_in6 *)&child_ep->com.local_addr;
2433                 sin6->sin6_family = PF_INET6;
2434                 sin6->sin6_port = ((struct sockaddr_in6 *)
2435                                    &parent_ep->com.local_addr)->sin6_port;
2436                 memcpy(sin6->sin6_addr.s6_addr, local_ip, 16);
2437
2438                 sin6 = (struct sockaddr_in6 *)&child_ep->com.remote_addr;
2439                 sin6->sin6_family = PF_INET6;
2440                 sin6->sin6_port = peer_port;
2441                 memcpy(sin6->sin6_addr.s6_addr, peer_ip, 16);
2442         }
2443
2444         c4iw_get_ep(&parent_ep->com);
2445         child_ep->parent_ep = parent_ep;
2446         child_ep->tos = PASS_OPEN_TOS_G(ntohl(req->tos_stid));
2447         child_ep->dst = dst;
2448         child_ep->hwtid = hwtid;
2449
2450         PDBG("%s tx_chan %u smac_idx %u rss_qid %u\n", __func__,
2451              child_ep->tx_chan, child_ep->smac_idx, child_ep->rss_qid);
2452
2453         init_timer(&child_ep->timer);
2454         cxgb4_insert_tid(t, child_ep, hwtid);
2455         insert_handle(dev, &dev->hwtid_idr, child_ep, child_ep->hwtid);
2456         accept_cr(child_ep, skb, req);
2457         set_bit(PASS_ACCEPT_REQ, &child_ep->com.history);
2458         if (iptype == 6) {
2459                 sin6 = (struct sockaddr_in6 *)&child_ep->com.local_addr;
2460                 cxgb4_clip_get(child_ep->com.dev->rdev.lldi.ports[0],
2461                                (const u32 *)&sin6->sin6_addr.s6_addr, 1);
2462         }
2463         goto out;
2464 reject:
2465         reject_cr(dev, hwtid, skb);
2466 out:
2467         return 0;
2468 }
2469
2470 static int pass_establish(struct c4iw_dev *dev, struct sk_buff *skb)
2471 {
2472         struct c4iw_ep *ep;
2473         struct cpl_pass_establish *req = cplhdr(skb);
2474         struct tid_info *t = dev->rdev.lldi.tids;
2475         unsigned int tid = GET_TID(req);
2476
2477         ep = lookup_tid(t, tid);
2478         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2479         ep->snd_seq = be32_to_cpu(req->snd_isn);
2480         ep->rcv_seq = be32_to_cpu(req->rcv_isn);
2481
2482         PDBG("%s ep %p hwtid %u tcp_opt 0x%02x\n", __func__, ep, tid,
2483              ntohs(req->tcp_opt));
2484
2485         set_emss(ep, ntohs(req->tcp_opt));
2486
2487         dst_confirm(ep->dst);
2488         state_set(&ep->com, MPA_REQ_WAIT);
2489         start_ep_timer(ep);
2490         send_flowc(ep, skb);
2491         set_bit(PASS_ESTAB, &ep->com.history);
2492
2493         return 0;
2494 }
2495
2496 static int peer_close(struct c4iw_dev *dev, struct sk_buff *skb)
2497 {
2498         struct cpl_peer_close *hdr = cplhdr(skb);
2499         struct c4iw_ep *ep;
2500         struct c4iw_qp_attributes attrs;
2501         int disconnect = 1;
2502         int release = 0;
2503         struct tid_info *t = dev->rdev.lldi.tids;
2504         unsigned int tid = GET_TID(hdr);
2505         int ret;
2506
2507         ep = lookup_tid(t, tid);
2508         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2509         dst_confirm(ep->dst);
2510
2511         set_bit(PEER_CLOSE, &ep->com.history);
2512         mutex_lock(&ep->com.mutex);
2513         switch (ep->com.state) {
2514         case MPA_REQ_WAIT:
2515                 __state_set(&ep->com, CLOSING);
2516                 break;
2517         case MPA_REQ_SENT:
2518                 __state_set(&ep->com, CLOSING);
2519                 connect_reply_upcall(ep, -ECONNRESET);
2520                 break;
2521         case MPA_REQ_RCVD:
2522
2523                 /*
2524                  * We're gonna mark this puppy DEAD, but keep
2525                  * the reference on it until the ULP accepts or
2526                  * rejects the CR. Also wake up anyone waiting
2527                  * in rdma connection migration (see c4iw_accept_cr()).
2528                  */
2529                 __state_set(&ep->com, CLOSING);
2530                 PDBG("waking up ep %p tid %u\n", ep, ep->hwtid);
2531                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
2532                 break;
2533         case MPA_REP_SENT:
2534                 __state_set(&ep->com, CLOSING);
2535                 PDBG("waking up ep %p tid %u\n", ep, ep->hwtid);
2536                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
2537                 break;
2538         case FPDU_MODE:
2539                 start_ep_timer(ep);
2540                 __state_set(&ep->com, CLOSING);
2541                 attrs.next_state = C4IW_QP_STATE_CLOSING;
2542                 ret = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
2543                                        C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
2544                 if (ret != -ECONNRESET) {
2545                         peer_close_upcall(ep);
2546                         disconnect = 1;
2547                 }
2548                 break;
2549         case ABORTING:
2550                 disconnect = 0;
2551                 break;
2552         case CLOSING:
2553                 __state_set(&ep->com, MORIBUND);
2554                 disconnect = 0;
2555                 break;
2556         case MORIBUND:
2557                 (void)stop_ep_timer(ep);
2558                 if (ep->com.cm_id && ep->com.qp) {
2559                         attrs.next_state = C4IW_QP_STATE_IDLE;
2560                         c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
2561                                        C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
2562                 }
2563                 close_complete_upcall(ep, 0);
2564                 __state_set(&ep->com, DEAD);
2565                 release = 1;
2566                 disconnect = 0;
2567                 break;
2568         case DEAD:
2569                 disconnect = 0;
2570                 break;
2571         default:
2572                 BUG_ON(1);
2573         }
2574         mutex_unlock(&ep->com.mutex);
2575         if (disconnect)
2576                 c4iw_ep_disconnect(ep, 0, GFP_KERNEL);
2577         if (release)
2578                 release_ep_resources(ep);
2579         return 0;
2580 }
2581
2582 static int peer_abort(struct c4iw_dev *dev, struct sk_buff *skb)
2583 {
2584         struct cpl_abort_req_rss *req = cplhdr(skb);
2585         struct c4iw_ep *ep;
2586         struct cpl_abort_rpl *rpl;
2587         struct sk_buff *rpl_skb;
2588         struct c4iw_qp_attributes attrs;
2589         int ret;
2590         int release = 0;
2591         struct tid_info *t = dev->rdev.lldi.tids;
2592         unsigned int tid = GET_TID(req);
2593
2594         ep = lookup_tid(t, tid);
2595         if (is_neg_adv(req->status)) {
2596                 PDBG("%s Negative advice on abort- tid %u status %d (%s)\n",
2597                      __func__, ep->hwtid, req->status,
2598                      neg_adv_str(req->status));
2599                 ep->stats.abort_neg_adv++;
2600                 mutex_lock(&dev->rdev.stats.lock);
2601                 dev->rdev.stats.neg_adv++;
2602                 mutex_unlock(&dev->rdev.stats.lock);
2603                 return 0;
2604         }
2605         PDBG("%s ep %p tid %u state %u\n", __func__, ep, ep->hwtid,
2606              ep->com.state);
2607         set_bit(PEER_ABORT, &ep->com.history);
2608
2609         /*
2610          * Wake up any threads in rdma_init() or rdma_fini().
2611          * However, this is not needed if com state is just
2612          * MPA_REQ_SENT
2613          */
2614         if (ep->com.state != MPA_REQ_SENT)
2615                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
2616
2617         mutex_lock(&ep->com.mutex);
2618         switch (ep->com.state) {
2619         case CONNECTING:
2620                 break;
2621         case MPA_REQ_WAIT:
2622                 (void)stop_ep_timer(ep);
2623                 break;
2624         case MPA_REQ_SENT:
2625                 (void)stop_ep_timer(ep);
2626                 if (mpa_rev == 1 || (mpa_rev == 2 && ep->tried_with_mpa_v1))
2627                         connect_reply_upcall(ep, -ECONNRESET);
2628                 else {
2629                         /*
2630                          * we just don't send notification upwards because we
2631                          * want to retry with mpa_v1 without upper layers even
2632                          * knowing it.
2633                          *
2634                          * do some housekeeping so as to re-initiate the
2635                          * connection
2636                          */
2637                         PDBG("%s: mpa_rev=%d. Retrying with mpav1\n", __func__,
2638                              mpa_rev);
2639                         ep->retry_with_mpa_v1 = 1;
2640                 }
2641                 break;
2642         case MPA_REP_SENT:
2643                 break;
2644         case MPA_REQ_RCVD:
2645                 break;
2646         case MORIBUND:
2647         case CLOSING:
2648                 stop_ep_timer(ep);
2649                 /*FALLTHROUGH*/
2650         case FPDU_MODE:
2651                 if (ep->com.cm_id && ep->com.qp) {
2652                         attrs.next_state = C4IW_QP_STATE_ERROR;
2653                         ret = c4iw_modify_qp(ep->com.qp->rhp,
2654                                      ep->com.qp, C4IW_QP_ATTR_NEXT_STATE,
2655                                      &attrs, 1);
2656                         if (ret)
2657                                 printk(KERN_ERR MOD
2658                                        "%s - qp <- error failed!\n",
2659                                        __func__);
2660                 }
2661                 peer_abort_upcall(ep);
2662                 break;
2663         case ABORTING:
2664                 break;
2665         case DEAD:
2666                 PDBG("%s PEER_ABORT IN DEAD STATE!!!!\n", __func__);
2667                 mutex_unlock(&ep->com.mutex);
2668                 return 0;
2669         default:
2670                 BUG_ON(1);
2671                 break;
2672         }
2673         dst_confirm(ep->dst);
2674         if (ep->com.state != ABORTING) {
2675                 __state_set(&ep->com, DEAD);
2676                 /* we don't release if we want to retry with mpa_v1 */
2677                 if (!ep->retry_with_mpa_v1)
2678                         release = 1;
2679         }
2680         mutex_unlock(&ep->com.mutex);
2681
2682         rpl_skb = get_skb(skb, sizeof(*rpl), GFP_KERNEL);
2683         if (!rpl_skb) {
2684                 printk(KERN_ERR MOD "%s - cannot allocate skb!\n",
2685                        __func__);
2686                 release = 1;
2687                 goto out;
2688         }
2689         set_wr_txq(skb, CPL_PRIORITY_DATA, ep->txq_idx);
2690         rpl = (struct cpl_abort_rpl *) skb_put(rpl_skb, sizeof(*rpl));
2691         INIT_TP_WR(rpl, ep->hwtid);
2692         OPCODE_TID(rpl) = cpu_to_be32(MK_OPCODE_TID(CPL_ABORT_RPL, ep->hwtid));
2693         rpl->cmd = CPL_ABORT_NO_RST;
2694         c4iw_ofld_send(&ep->com.dev->rdev, rpl_skb);
2695 out:
2696         if (release)
2697                 release_ep_resources(ep);
2698         else if (ep->retry_with_mpa_v1) {
2699                 if (ep->com.remote_addr.ss_family == AF_INET6) {
2700                         struct sockaddr_in6 *sin6 =
2701                                         (struct sockaddr_in6 *)
2702                                         &ep->com.local_addr;
2703                         cxgb4_clip_release(
2704                                         ep->com.dev->rdev.lldi.ports[0],
2705                                         (const u32 *)&sin6->sin6_addr.s6_addr,
2706                                         1);
2707                 }
2708                 remove_handle(ep->com.dev, &ep->com.dev->hwtid_idr, ep->hwtid);
2709                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, ep->hwtid);
2710                 dst_release(ep->dst);
2711                 cxgb4_l2t_release(ep->l2t);
2712                 c4iw_reconnect(ep);
2713         }
2714
2715         return 0;
2716 }
2717
2718 static int close_con_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
2719 {
2720         struct c4iw_ep *ep;
2721         struct c4iw_qp_attributes attrs;
2722         struct cpl_close_con_rpl *rpl = cplhdr(skb);
2723         int release = 0;
2724         struct tid_info *t = dev->rdev.lldi.tids;
2725         unsigned int tid = GET_TID(rpl);
2726
2727         ep = lookup_tid(t, tid);
2728
2729         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2730         BUG_ON(!ep);
2731
2732         /* The cm_id may be null if we failed to connect */
2733         mutex_lock(&ep->com.mutex);
2734         switch (ep->com.state) {
2735         case CLOSING:
2736                 __state_set(&ep->com, MORIBUND);
2737                 break;
2738         case MORIBUND:
2739                 (void)stop_ep_timer(ep);
2740                 if ((ep->com.cm_id) && (ep->com.qp)) {
2741                         attrs.next_state = C4IW_QP_STATE_IDLE;
2742                         c4iw_modify_qp(ep->com.qp->rhp,
2743                                              ep->com.qp,
2744                                              C4IW_QP_ATTR_NEXT_STATE,
2745                                              &attrs, 1);
2746                 }
2747                 close_complete_upcall(ep, 0);
2748                 __state_set(&ep->com, DEAD);
2749                 release = 1;
2750                 break;
2751         case ABORTING:
2752         case DEAD:
2753                 break;
2754         default:
2755                 BUG_ON(1);
2756                 break;
2757         }
2758         mutex_unlock(&ep->com.mutex);
2759         if (release)
2760                 release_ep_resources(ep);
2761         return 0;
2762 }
2763
2764 static int terminate(struct c4iw_dev *dev, struct sk_buff *skb)
2765 {
2766         struct cpl_rdma_terminate *rpl = cplhdr(skb);
2767         struct tid_info *t = dev->rdev.lldi.tids;
2768         unsigned int tid = GET_TID(rpl);
2769         struct c4iw_ep *ep;
2770         struct c4iw_qp_attributes attrs;
2771
2772         ep = lookup_tid(t, tid);
2773         BUG_ON(!ep);
2774
2775         if (ep && ep->com.qp) {
2776                 printk(KERN_WARNING MOD "TERM received tid %u qpid %u\n", tid,
2777                        ep->com.qp->wq.sq.qid);
2778                 attrs.next_state = C4IW_QP_STATE_TERMINATE;
2779                 c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
2780                                C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
2781         } else
2782                 printk(KERN_WARNING MOD "TERM received tid %u no ep/qp\n", tid);
2783
2784         return 0;
2785 }
2786
2787 /*
2788  * Upcall from the adapter indicating data has been transmitted.
2789  * For us its just the single MPA request or reply.  We can now free
2790  * the skb holding the mpa message.
2791  */
2792 static int fw4_ack(struct c4iw_dev *dev, struct sk_buff *skb)
2793 {
2794         struct c4iw_ep *ep;
2795         struct cpl_fw4_ack *hdr = cplhdr(skb);
2796         u8 credits = hdr->credits;
2797         unsigned int tid = GET_TID(hdr);
2798         struct tid_info *t = dev->rdev.lldi.tids;
2799
2800
2801         ep = lookup_tid(t, tid);
2802         PDBG("%s ep %p tid %u credits %u\n", __func__, ep, ep->hwtid, credits);
2803         if (credits == 0) {
2804                 PDBG("%s 0 credit ack ep %p tid %u state %u\n",
2805                      __func__, ep, ep->hwtid, state_read(&ep->com));
2806                 return 0;
2807         }
2808
2809         dst_confirm(ep->dst);
2810         if (ep->mpa_skb) {
2811                 PDBG("%s last streaming msg ack ep %p tid %u state %u "
2812                      "initiator %u freeing skb\n", __func__, ep, ep->hwtid,
2813                      state_read(&ep->com), ep->mpa_attr.initiator ? 1 : 0);
2814                 kfree_skb(ep->mpa_skb);
2815                 ep->mpa_skb = NULL;
2816         }
2817         return 0;
2818 }
2819
2820 int c4iw_reject_cr(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
2821 {
2822         int err = 0;
2823         int disconnect = 0;
2824         struct c4iw_ep *ep = to_ep(cm_id);
2825         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2826
2827         mutex_lock(&ep->com.mutex);
2828         if (ep->com.state == DEAD) {
2829                 mutex_unlock(&ep->com.mutex);
2830                 c4iw_put_ep(&ep->com);
2831                 return -ECONNRESET;
2832         }
2833         set_bit(ULP_REJECT, &ep->com.history);
2834         BUG_ON(ep->com.state != MPA_REQ_RCVD);
2835         if (mpa_rev == 0)
2836                 abort_connection(ep, NULL, GFP_KERNEL);
2837         else {
2838                 err = send_mpa_reject(ep, pdata, pdata_len);
2839                 disconnect = 1;
2840         }
2841         mutex_unlock(&ep->com.mutex);
2842         if (disconnect)
2843                 err = c4iw_ep_disconnect(ep, 0, GFP_KERNEL);
2844         c4iw_put_ep(&ep->com);
2845         return 0;
2846 }
2847
2848 int c4iw_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
2849 {
2850         int err;
2851         struct c4iw_qp_attributes attrs;
2852         enum c4iw_qp_attr_mask mask;
2853         struct c4iw_ep *ep = to_ep(cm_id);
2854         struct c4iw_dev *h = to_c4iw_dev(cm_id->device);
2855         struct c4iw_qp *qp = get_qhp(h, conn_param->qpn);
2856
2857         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
2858
2859         mutex_lock(&ep->com.mutex);
2860         if (ep->com.state == DEAD) {
2861                 err = -ECONNRESET;
2862                 goto err;
2863         }
2864
2865         BUG_ON(ep->com.state != MPA_REQ_RCVD);
2866         BUG_ON(!qp);
2867
2868         set_bit(ULP_ACCEPT, &ep->com.history);
2869         if ((conn_param->ord > cur_max_read_depth(ep->com.dev)) ||
2870             (conn_param->ird > cur_max_read_depth(ep->com.dev))) {
2871                 abort_connection(ep, NULL, GFP_KERNEL);
2872                 err = -EINVAL;
2873                 goto err;
2874         }
2875
2876         if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
2877                 if (conn_param->ord > ep->ird) {
2878                         if (RELAXED_IRD_NEGOTIATION) {
2879                                 ep->ord = ep->ird;
2880                         } else {
2881                                 ep->ird = conn_param->ird;
2882                                 ep->ord = conn_param->ord;
2883                                 send_mpa_reject(ep, conn_param->private_data,
2884                                                 conn_param->private_data_len);
2885                                 abort_connection(ep, NULL, GFP_KERNEL);
2886                                 err = -ENOMEM;
2887                                 goto err;
2888                         }
2889                 }
2890                 if (conn_param->ird < ep->ord) {
2891                         if (RELAXED_IRD_NEGOTIATION &&
2892                             ep->ord <= h->rdev.lldi.max_ordird_qp) {
2893                                 conn_param->ird = ep->ord;
2894                         } else {
2895                                 abort_connection(ep, NULL, GFP_KERNEL);
2896                                 err = -ENOMEM;
2897                                 goto err;
2898                         }
2899                 }
2900         }
2901         ep->ird = conn_param->ird;
2902         ep->ord = conn_param->ord;
2903
2904         if (ep->mpa_attr.version == 1) {
2905                 if (peer2peer && ep->ird == 0)
2906                         ep->ird = 1;
2907         } else {
2908                 if (peer2peer &&
2909                     (ep->mpa_attr.p2p_type != FW_RI_INIT_P2PTYPE_DISABLED) &&
2910                     (p2p_type == FW_RI_INIT_P2PTYPE_READ_REQ) && ep->ird == 0)
2911                         ep->ird = 1;
2912         }
2913
2914         PDBG("%s %d ird %d ord %d\n", __func__, __LINE__, ep->ird, ep->ord);
2915
2916         cm_id->add_ref(cm_id);
2917         ep->com.cm_id = cm_id;
2918         ep->com.qp = qp;
2919         ref_qp(ep);
2920
2921         /* bind QP to EP and move to RTS */
2922         attrs.mpa_attr = ep->mpa_attr;
2923         attrs.max_ird = ep->ird;
2924         attrs.max_ord = ep->ord;
2925         attrs.llp_stream_handle = ep;
2926         attrs.next_state = C4IW_QP_STATE_RTS;
2927
2928         /* bind QP and TID with INIT_WR */
2929         mask = C4IW_QP_ATTR_NEXT_STATE |
2930                              C4IW_QP_ATTR_LLP_STREAM_HANDLE |
2931                              C4IW_QP_ATTR_MPA_ATTR |
2932                              C4IW_QP_ATTR_MAX_IRD |
2933                              C4IW_QP_ATTR_MAX_ORD;
2934
2935         err = c4iw_modify_qp(ep->com.qp->rhp,
2936                              ep->com.qp, mask, &attrs, 1);
2937         if (err)
2938                 goto err1;
2939         err = send_mpa_reply(ep, conn_param->private_data,
2940                              conn_param->private_data_len);
2941         if (err)
2942                 goto err1;
2943
2944         __state_set(&ep->com, FPDU_MODE);
2945         established_upcall(ep);
2946         mutex_unlock(&ep->com.mutex);
2947         c4iw_put_ep(&ep->com);
2948         return 0;
2949 err1:
2950         ep->com.cm_id = NULL;
2951         abort_connection(ep, NULL, GFP_KERNEL);
2952         cm_id->rem_ref(cm_id);
2953 err:
2954         mutex_unlock(&ep->com.mutex);
2955         c4iw_put_ep(&ep->com);
2956         return err;
2957 }
2958
2959 static int pick_local_ipaddrs(struct c4iw_dev *dev, struct iw_cm_id *cm_id)
2960 {
2961         struct in_device *ind;
2962         int found = 0;
2963         struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
2964         struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->m_remote_addr;
2965
2966         ind = in_dev_get(dev->rdev.lldi.ports[0]);
2967         if (!ind)
2968                 return -EADDRNOTAVAIL;
2969         for_primary_ifa(ind) {
2970                 laddr->sin_addr.s_addr = ifa->ifa_address;
2971                 raddr->sin_addr.s_addr = ifa->ifa_address;
2972                 found = 1;
2973                 break;
2974         }
2975         endfor_ifa(ind);
2976         in_dev_put(ind);
2977         return found ? 0 : -EADDRNOTAVAIL;
2978 }
2979
2980 static int get_lladdr(struct net_device *dev, struct in6_addr *addr,
2981                       unsigned char banned_flags)
2982 {
2983         struct inet6_dev *idev;
2984         int err = -EADDRNOTAVAIL;
2985
2986         rcu_read_lock();
2987         idev = __in6_dev_get(dev);
2988         if (idev != NULL) {
2989                 struct inet6_ifaddr *ifp;
2990
2991                 read_lock_bh(&idev->lock);
2992                 list_for_each_entry(ifp, &idev->addr_list, if_list) {
2993                         if (ifp->scope == IFA_LINK &&
2994                             !(ifp->flags & banned_flags)) {
2995                                 memcpy(addr, &ifp->addr, 16);
2996                                 err = 0;
2997                                 break;
2998                         }
2999                 }
3000                 read_unlock_bh(&idev->lock);
3001         }
3002         rcu_read_unlock();
3003         return err;
3004 }
3005
3006 static int pick_local_ip6addrs(struct c4iw_dev *dev, struct iw_cm_id *cm_id)
3007 {
3008         struct in6_addr uninitialized_var(addr);
3009         struct sockaddr_in6 *la6 = (struct sockaddr_in6 *)&cm_id->m_local_addr;
3010         struct sockaddr_in6 *ra6 = (struct sockaddr_in6 *)&cm_id->m_remote_addr;
3011
3012         if (!get_lladdr(dev->rdev.lldi.ports[0], &addr, IFA_F_TENTATIVE)) {
3013                 memcpy(la6->sin6_addr.s6_addr, &addr, 16);
3014                 memcpy(ra6->sin6_addr.s6_addr, &addr, 16);
3015                 return 0;
3016         }
3017         return -EADDRNOTAVAIL;
3018 }
3019
3020 int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
3021 {
3022         struct c4iw_dev *dev = to_c4iw_dev(cm_id->device);
3023         struct c4iw_ep *ep;
3024         int err = 0;
3025         struct sockaddr_in *laddr;
3026         struct sockaddr_in *raddr;
3027         struct sockaddr_in6 *laddr6;
3028         struct sockaddr_in6 *raddr6;
3029         __u8 *ra;
3030         int iptype;
3031
3032         if ((conn_param->ord > cur_max_read_depth(dev)) ||
3033             (conn_param->ird > cur_max_read_depth(dev))) {
3034                 err = -EINVAL;
3035                 goto out;
3036         }
3037         ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
3038         if (!ep) {
3039                 printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
3040                 err = -ENOMEM;
3041                 goto out;
3042         }
3043         init_timer(&ep->timer);
3044         ep->plen = conn_param->private_data_len;
3045         if (ep->plen)
3046                 memcpy(ep->mpa_pkt + sizeof(struct mpa_message),
3047                        conn_param->private_data, ep->plen);
3048         ep->ird = conn_param->ird;
3049         ep->ord = conn_param->ord;
3050
3051         if (peer2peer && ep->ord == 0)
3052                 ep->ord = 1;
3053
3054         cm_id->add_ref(cm_id);
3055         ep->com.dev = dev;
3056         ep->com.cm_id = cm_id;
3057         ep->com.qp = get_qhp(dev, conn_param->qpn);
3058         if (!ep->com.qp) {
3059                 PDBG("%s qpn 0x%x not found!\n", __func__, conn_param->qpn);
3060                 err = -EINVAL;
3061                 goto fail1;
3062         }
3063         ref_qp(ep);
3064         PDBG("%s qpn 0x%x qp %p cm_id %p\n", __func__, conn_param->qpn,
3065              ep->com.qp, cm_id);
3066
3067         /*
3068          * Allocate an active TID to initiate a TCP connection.
3069          */
3070         ep->atid = cxgb4_alloc_atid(dev->rdev.lldi.tids, ep);
3071         if (ep->atid == -1) {
3072                 printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __func__);
3073                 err = -ENOMEM;
3074                 goto fail1;
3075         }
3076         insert_handle(dev, &dev->atid_idr, ep, ep->atid);
3077
3078         memcpy(&ep->com.local_addr, &cm_id->m_local_addr,
3079                sizeof(ep->com.local_addr));
3080         memcpy(&ep->com.remote_addr, &cm_id->m_remote_addr,
3081                sizeof(ep->com.remote_addr));
3082
3083         laddr = (struct sockaddr_in *)&ep->com.local_addr;
3084         raddr = (struct sockaddr_in *)&ep->com.remote_addr;
3085         laddr6 = (struct sockaddr_in6 *)&ep->com.local_addr;
3086         raddr6 = (struct sockaddr_in6 *) &ep->com.remote_addr;
3087
3088         if (cm_id->m_remote_addr.ss_family == AF_INET) {
3089                 iptype = 4;
3090                 ra = (__u8 *)&raddr->sin_addr;
3091
3092                 /*
3093                  * Handle loopback requests to INADDR_ANY.
3094                  */
3095                 if ((__force int)raddr->sin_addr.s_addr == INADDR_ANY) {
3096                         err = pick_local_ipaddrs(dev, cm_id);
3097                         if (err)
3098                                 goto fail1;
3099                 }
3100
3101                 /* find a route */
3102                 PDBG("%s saddr %pI4 sport 0x%x raddr %pI4 rport 0x%x\n",
3103                      __func__, &laddr->sin_addr, ntohs(laddr->sin_port),
3104                      ra, ntohs(raddr->sin_port));
3105                 ep->dst = find_route(dev, laddr->sin_addr.s_addr,
3106                                      raddr->sin_addr.s_addr, laddr->sin_port,
3107                                      raddr->sin_port, 0);
3108         } else {
3109                 iptype = 6;
3110                 ra = (__u8 *)&raddr6->sin6_addr;
3111
3112                 /*
3113                  * Handle loopback requests to INADDR_ANY.
3114                  */
3115                 if (ipv6_addr_type(&raddr6->sin6_addr) == IPV6_ADDR_ANY) {
3116                         err = pick_local_ip6addrs(dev, cm_id);
3117                         if (err)
3118                                 goto fail1;
3119                 }
3120
3121                 /* find a route */
3122                 PDBG("%s saddr %pI6 sport 0x%x raddr %pI6 rport 0x%x\n",
3123                      __func__, laddr6->sin6_addr.s6_addr,
3124                      ntohs(laddr6->sin6_port),
3125                      raddr6->sin6_addr.s6_addr, ntohs(raddr6->sin6_port));
3126                 ep->dst = find_route6(dev, laddr6->sin6_addr.s6_addr,
3127                                       raddr6->sin6_addr.s6_addr,
3128                                       laddr6->sin6_port, raddr6->sin6_port, 0,
3129                                       raddr6->sin6_scope_id);
3130         }
3131         if (!ep->dst) {
3132                 printk(KERN_ERR MOD "%s - cannot find route.\n", __func__);
3133                 err = -EHOSTUNREACH;
3134                 goto fail2;
3135         }
3136
3137         err = import_ep(ep, iptype, ra, ep->dst, ep->com.dev, true,
3138                         ep->com.dev->rdev.lldi.adapter_type);
3139         if (err) {
3140                 printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
3141                 goto fail3;
3142         }
3143
3144         PDBG("%s txq_idx %u tx_chan %u smac_idx %u rss_qid %u l2t_idx %u\n",
3145                 __func__, ep->txq_idx, ep->tx_chan, ep->smac_idx, ep->rss_qid,
3146                 ep->l2t->idx);
3147
3148         state_set(&ep->com, CONNECTING);
3149         ep->tos = 0;
3150
3151         /* send connect request to rnic */
3152         err = send_connect(ep);
3153         if (!err)
3154                 goto out;
3155
3156         cxgb4_l2t_release(ep->l2t);
3157 fail3:
3158         dst_release(ep->dst);
3159 fail2:
3160         remove_handle(ep->com.dev, &ep->com.dev->atid_idr, ep->atid);
3161         cxgb4_free_atid(ep->com.dev->rdev.lldi.tids, ep->atid);
3162 fail1:
3163         cm_id->rem_ref(cm_id);
3164         c4iw_put_ep(&ep->com);
3165 out:
3166         return err;
3167 }
3168
3169 static int create_server6(struct c4iw_dev *dev, struct c4iw_listen_ep *ep)
3170 {
3171         int err;
3172         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)
3173                                     &ep->com.local_addr;
3174
3175         if (ipv6_addr_type(&sin6->sin6_addr) != IPV6_ADDR_ANY) {
3176                 err = cxgb4_clip_get(ep->com.dev->rdev.lldi.ports[0],
3177                                      (const u32 *)&sin6->sin6_addr.s6_addr, 1);
3178                 if (err)
3179                         return err;
3180         }
3181         c4iw_init_wr_wait(&ep->com.wr_wait);
3182         err = cxgb4_create_server6(ep->com.dev->rdev.lldi.ports[0],
3183                                    ep->stid, &sin6->sin6_addr,
3184                                    sin6->sin6_port,
3185                                    ep->com.dev->rdev.lldi.rxq_ids[0]);
3186         if (!err)
3187                 err = c4iw_wait_for_reply(&ep->com.dev->rdev,
3188                                           &ep->com.wr_wait,
3189                                           0, 0, __func__);
3190         else if (err > 0)
3191                 err = net_xmit_errno(err);
3192         if (err) {
3193                 cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
3194                                    (const u32 *)&sin6->sin6_addr.s6_addr, 1);
3195                 pr_err("cxgb4_create_server6/filter failed err %d stid %d laddr %pI6 lport %d\n",
3196                        err, ep->stid,
3197                        sin6->sin6_addr.s6_addr, ntohs(sin6->sin6_port));
3198         }
3199         return err;
3200 }
3201
3202 static int create_server4(struct c4iw_dev *dev, struct c4iw_listen_ep *ep)
3203 {
3204         int err;
3205         struct sockaddr_in *sin = (struct sockaddr_in *)
3206                                   &ep->com.local_addr;
3207
3208         if (dev->rdev.lldi.enable_fw_ofld_conn) {
3209                 do {
3210                         err = cxgb4_create_server_filter(
3211                                 ep->com.dev->rdev.lldi.ports[0], ep->stid,
3212                                 sin->sin_addr.s_addr, sin->sin_port, 0,
3213                                 ep->com.dev->rdev.lldi.rxq_ids[0], 0, 0);
3214                         if (err == -EBUSY) {
3215                                 if (c4iw_fatal_error(&ep->com.dev->rdev)) {
3216                                         err = -EIO;
3217                                         break;
3218                                 }
3219                                 set_current_state(TASK_UNINTERRUPTIBLE);
3220                                 schedule_timeout(usecs_to_jiffies(100));
3221                         }
3222                 } while (err == -EBUSY);
3223         } else {
3224                 c4iw_init_wr_wait(&ep->com.wr_wait);
3225                 err = cxgb4_create_server(ep->com.dev->rdev.lldi.ports[0],
3226                                 ep->stid, sin->sin_addr.s_addr, sin->sin_port,
3227                                 0, ep->com.dev->rdev.lldi.rxq_ids[0]);
3228                 if (!err)
3229                         err = c4iw_wait_for_reply(&ep->com.dev->rdev,
3230                                                   &ep->com.wr_wait,
3231                                                   0, 0, __func__);
3232                 else if (err > 0)
3233                         err = net_xmit_errno(err);
3234         }
3235         if (err)
3236                 pr_err("cxgb4_create_server/filter failed err %d stid %d laddr %pI4 lport %d\n"
3237                        , err, ep->stid,
3238                        &sin->sin_addr, ntohs(sin->sin_port));
3239         return err;
3240 }
3241
3242 int c4iw_create_listen(struct iw_cm_id *cm_id, int backlog)
3243 {
3244         int err = 0;
3245         struct c4iw_dev *dev = to_c4iw_dev(cm_id->device);
3246         struct c4iw_listen_ep *ep;
3247
3248         might_sleep();
3249
3250         ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
3251         if (!ep) {
3252                 printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
3253                 err = -ENOMEM;
3254                 goto fail1;
3255         }
3256         PDBG("%s ep %p\n", __func__, ep);
3257         cm_id->add_ref(cm_id);
3258         ep->com.cm_id = cm_id;
3259         ep->com.dev = dev;
3260         ep->backlog = backlog;
3261         memcpy(&ep->com.local_addr, &cm_id->m_local_addr,
3262                sizeof(ep->com.local_addr));
3263
3264         /*
3265          * Allocate a server TID.
3266          */
3267         if (dev->rdev.lldi.enable_fw_ofld_conn &&
3268             ep->com.local_addr.ss_family == AF_INET)
3269                 ep->stid = cxgb4_alloc_sftid(dev->rdev.lldi.tids,
3270                                              cm_id->m_local_addr.ss_family, ep);
3271         else
3272                 ep->stid = cxgb4_alloc_stid(dev->rdev.lldi.tids,
3273                                             cm_id->m_local_addr.ss_family, ep);
3274
3275         if (ep->stid == -1) {
3276                 printk(KERN_ERR MOD "%s - cannot alloc stid.\n", __func__);
3277                 err = -ENOMEM;
3278                 goto fail2;
3279         }
3280         insert_handle(dev, &dev->stid_idr, ep, ep->stid);
3281
3282         memcpy(&ep->com.local_addr, &cm_id->m_local_addr,
3283                sizeof(ep->com.local_addr));
3284
3285         state_set(&ep->com, LISTEN);
3286         if (ep->com.local_addr.ss_family == AF_INET)
3287                 err = create_server4(dev, ep);
3288         else
3289                 err = create_server6(dev, ep);
3290         if (!err) {
3291                 cm_id->provider_data = ep;
3292                 goto out;
3293         }
3294
3295         cxgb4_free_stid(ep->com.dev->rdev.lldi.tids, ep->stid,
3296                         ep->com.local_addr.ss_family);
3297 fail2:
3298         cm_id->rem_ref(cm_id);
3299         c4iw_put_ep(&ep->com);
3300 fail1:
3301 out:
3302         return err;
3303 }
3304
3305 int c4iw_destroy_listen(struct iw_cm_id *cm_id)
3306 {
3307         int err;
3308         struct c4iw_listen_ep *ep = to_listen_ep(cm_id);
3309
3310         PDBG("%s ep %p\n", __func__, ep);
3311
3312         might_sleep();
3313         state_set(&ep->com, DEAD);
3314         if (ep->com.dev->rdev.lldi.enable_fw_ofld_conn &&
3315             ep->com.local_addr.ss_family == AF_INET) {
3316                 err = cxgb4_remove_server_filter(
3317                         ep->com.dev->rdev.lldi.ports[0], ep->stid,
3318                         ep->com.dev->rdev.lldi.rxq_ids[0], 0);
3319         } else {
3320                 struct sockaddr_in6 *sin6;
3321                 c4iw_init_wr_wait(&ep->com.wr_wait);
3322                 err = cxgb4_remove_server(
3323                                 ep->com.dev->rdev.lldi.ports[0], ep->stid,
3324                                 ep->com.dev->rdev.lldi.rxq_ids[0], 0);
3325                 if (err)
3326                         goto done;
3327                 err = c4iw_wait_for_reply(&ep->com.dev->rdev, &ep->com.wr_wait,
3328                                           0, 0, __func__);
3329                 sin6 = (struct sockaddr_in6 *)&ep->com.local_addr;
3330                 cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
3331                                    (const u32 *)&sin6->sin6_addr.s6_addr, 1);
3332         }
3333         remove_handle(ep->com.dev, &ep->com.dev->stid_idr, ep->stid);
3334         cxgb4_free_stid(ep->com.dev->rdev.lldi.tids, ep->stid,
3335                         ep->com.local_addr.ss_family);
3336 done:
3337         cm_id->rem_ref(cm_id);
3338         c4iw_put_ep(&ep->com);
3339         return err;
3340 }
3341
3342 int c4iw_ep_disconnect(struct c4iw_ep *ep, int abrupt, gfp_t gfp)
3343 {
3344         int ret = 0;
3345         int close = 0;
3346         int fatal = 0;
3347         struct c4iw_rdev *rdev;
3348
3349         mutex_lock(&ep->com.mutex);
3350
3351         PDBG("%s ep %p state %s, abrupt %d\n", __func__, ep,
3352              states[ep->com.state], abrupt);
3353
3354         rdev = &ep->com.dev->rdev;
3355         if (c4iw_fatal_error(rdev)) {
3356                 fatal = 1;
3357                 close_complete_upcall(ep, -EIO);
3358                 ep->com.state = DEAD;
3359         }
3360         switch (ep->com.state) {
3361         case MPA_REQ_WAIT:
3362         case MPA_REQ_SENT:
3363         case MPA_REQ_RCVD:
3364         case MPA_REP_SENT:
3365         case FPDU_MODE:
3366                 close = 1;
3367                 if (abrupt)
3368                         ep->com.state = ABORTING;
3369                 else {
3370                         ep->com.state = CLOSING;
3371                         start_ep_timer(ep);
3372                 }
3373                 set_bit(CLOSE_SENT, &ep->com.flags);
3374                 break;
3375         case CLOSING:
3376                 if (!test_and_set_bit(CLOSE_SENT, &ep->com.flags)) {
3377                         close = 1;
3378                         if (abrupt) {
3379                                 (void)stop_ep_timer(ep);
3380                                 ep->com.state = ABORTING;
3381                         } else
3382                                 ep->com.state = MORIBUND;
3383                 }
3384                 break;
3385         case MORIBUND:
3386         case ABORTING:
3387         case DEAD:
3388                 PDBG("%s ignoring disconnect ep %p state %u\n",
3389                      __func__, ep, ep->com.state);
3390                 break;
3391         default:
3392                 BUG();
3393                 break;
3394         }
3395
3396         if (close) {
3397                 if (abrupt) {
3398                         set_bit(EP_DISC_ABORT, &ep->com.history);
3399                         close_complete_upcall(ep, -ECONNRESET);
3400                         ret = send_abort(ep, NULL, gfp);
3401                 } else {
3402                         set_bit(EP_DISC_CLOSE, &ep->com.history);
3403                         ret = send_halfclose(ep, gfp);
3404                 }
3405                 if (ret)
3406                         fatal = 1;
3407         }
3408         mutex_unlock(&ep->com.mutex);
3409         if (fatal)
3410                 release_ep_resources(ep);
3411         return ret;
3412 }
3413
3414 static void active_ofld_conn_reply(struct c4iw_dev *dev, struct sk_buff *skb,
3415                         struct cpl_fw6_msg_ofld_connection_wr_rpl *req)
3416 {
3417         struct c4iw_ep *ep;
3418         int atid = be32_to_cpu(req->tid);
3419
3420         ep = (struct c4iw_ep *)lookup_atid(dev->rdev.lldi.tids,
3421                                            (__force u32) req->tid);
3422         if (!ep)
3423                 return;
3424
3425         switch (req->retval) {
3426         case FW_ENOMEM:
3427                 set_bit(ACT_RETRY_NOMEM, &ep->com.history);
3428                 if (ep->retry_count++ < ACT_OPEN_RETRY_COUNT) {
3429                         send_fw_act_open_req(ep, atid);
3430                         return;
3431                 }
3432         case FW_EADDRINUSE:
3433                 set_bit(ACT_RETRY_INUSE, &ep->com.history);
3434                 if (ep->retry_count++ < ACT_OPEN_RETRY_COUNT) {
3435                         send_fw_act_open_req(ep, atid);
3436                         return;
3437                 }
3438                 break;
3439         default:
3440                 pr_info("%s unexpected ofld conn wr retval %d\n",
3441                        __func__, req->retval);
3442                 break;
3443         }
3444         pr_err("active ofld_connect_wr failure %d atid %d\n",
3445                req->retval, atid);
3446         mutex_lock(&dev->rdev.stats.lock);
3447         dev->rdev.stats.act_ofld_conn_fails++;
3448         mutex_unlock(&dev->rdev.stats.lock);
3449         connect_reply_upcall(ep, status2errno(req->retval));
3450         state_set(&ep->com, DEAD);
3451         if (ep->com.remote_addr.ss_family == AF_INET6) {
3452                 struct sockaddr_in6 *sin6 =
3453                         (struct sockaddr_in6 *)&ep->com.local_addr;
3454                 cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
3455                                    (const u32 *)&sin6->sin6_addr.s6_addr, 1);
3456         }
3457         remove_handle(dev, &dev->atid_idr, atid);
3458         cxgb4_free_atid(dev->rdev.lldi.tids, atid);
3459         dst_release(ep->dst);
3460         cxgb4_l2t_release(ep->l2t);
3461         c4iw_put_ep(&ep->com);
3462 }
3463
3464 static void passive_ofld_conn_reply(struct c4iw_dev *dev, struct sk_buff *skb,
3465                         struct cpl_fw6_msg_ofld_connection_wr_rpl *req)
3466 {
3467         struct sk_buff *rpl_skb;
3468         struct cpl_pass_accept_req *cpl;
3469         int ret;
3470
3471         rpl_skb = (struct sk_buff *)(unsigned long)req->cookie;
3472         BUG_ON(!rpl_skb);
3473         if (req->retval) {
3474                 PDBG("%s passive open failure %d\n", __func__, req->retval);
3475                 mutex_lock(&dev->rdev.stats.lock);
3476                 dev->rdev.stats.pas_ofld_conn_fails++;
3477                 mutex_unlock(&dev->rdev.stats.lock);
3478                 kfree_skb(rpl_skb);
3479         } else {
3480                 cpl = (struct cpl_pass_accept_req *)cplhdr(rpl_skb);
3481                 OPCODE_TID(cpl) = htonl(MK_OPCODE_TID(CPL_PASS_ACCEPT_REQ,
3482                                         (__force u32) htonl(
3483                                         (__force u32) req->tid)));
3484                 ret = pass_accept_req(dev, rpl_skb);
3485                 if (!ret)
3486                         kfree_skb(rpl_skb);
3487         }
3488         return;
3489 }
3490
3491 static int deferred_fw6_msg(struct c4iw_dev *dev, struct sk_buff *skb)
3492 {
3493         struct cpl_fw6_msg *rpl = cplhdr(skb);
3494         struct cpl_fw6_msg_ofld_connection_wr_rpl *req;
3495
3496         switch (rpl->type) {
3497         case FW6_TYPE_CQE:
3498                 c4iw_ev_dispatch(dev, (struct t4_cqe *)&rpl->data[0]);
3499                 break;
3500         case FW6_TYPE_OFLD_CONNECTION_WR_RPL:
3501                 req = (struct cpl_fw6_msg_ofld_connection_wr_rpl *)rpl->data;
3502                 switch (req->t_state) {
3503                 case TCP_SYN_SENT:
3504                         active_ofld_conn_reply(dev, skb, req);
3505                         break;
3506                 case TCP_SYN_RECV:
3507                         passive_ofld_conn_reply(dev, skb, req);
3508                         break;
3509                 default:
3510                         pr_err("%s unexpected ofld conn wr state %d\n",
3511                                __func__, req->t_state);
3512                         break;
3513                 }
3514                 break;
3515         }
3516         return 0;
3517 }
3518
3519 static void build_cpl_pass_accept_req(struct sk_buff *skb, int stid , u8 tos)
3520 {
3521         __be32 l2info;
3522         __be16 hdr_len, vlantag, len;
3523         u16 eth_hdr_len;
3524         int tcp_hdr_len, ip_hdr_len;
3525         u8 intf;
3526         struct cpl_rx_pkt *cpl = cplhdr(skb);
3527         struct cpl_pass_accept_req *req;
3528         struct tcp_options_received tmp_opt;
3529         struct c4iw_dev *dev;
3530         enum chip_type type;
3531
3532         dev = *((struct c4iw_dev **) (skb->cb + sizeof(void *)));
3533         /* Store values from cpl_rx_pkt in temporary location. */
3534         vlantag = cpl->vlan;
3535         len = cpl->len;
3536         l2info  = cpl->l2info;
3537         hdr_len = cpl->hdr_len;
3538         intf = cpl->iff;
3539
3540         __skb_pull(skb, sizeof(*req) + sizeof(struct rss_header));
3541
3542         /*
3543          * We need to parse the TCP options from SYN packet.
3544          * to generate cpl_pass_accept_req.
3545          */
3546         memset(&tmp_opt, 0, sizeof(tmp_opt));
3547         tcp_clear_options(&tmp_opt);
3548         tcp_parse_options(skb, &tmp_opt, 0, NULL);
3549
3550         req = (struct cpl_pass_accept_req *)__skb_push(skb, sizeof(*req));
3551         memset(req, 0, sizeof(*req));
3552         req->l2info = cpu_to_be16(SYN_INTF_V(intf) |
3553                          SYN_MAC_IDX_V(RX_MACIDX_G(
3554                          be32_to_cpu(l2info))) |
3555                          SYN_XACT_MATCH_F);
3556         type = dev->rdev.lldi.adapter_type;
3557         tcp_hdr_len = RX_TCPHDR_LEN_G(be16_to_cpu(hdr_len));
3558         ip_hdr_len = RX_IPHDR_LEN_G(be16_to_cpu(hdr_len));
3559         req->hdr_len =
3560                 cpu_to_be32(SYN_RX_CHAN_V(RX_CHAN_G(be32_to_cpu(l2info))));
3561         if (CHELSIO_CHIP_VERSION(type) <= CHELSIO_T5) {
3562                 eth_hdr_len = is_t4(type) ?
3563                                 RX_ETHHDR_LEN_G(be32_to_cpu(l2info)) :
3564                                 RX_T5_ETHHDR_LEN_G(be32_to_cpu(l2info));
3565                 req->hdr_len |= cpu_to_be32(TCP_HDR_LEN_V(tcp_hdr_len) |
3566                                             IP_HDR_LEN_V(ip_hdr_len) |
3567                                             ETH_HDR_LEN_V(eth_hdr_len));
3568         } else { /* T6 and later */
3569                 eth_hdr_len = RX_T6_ETHHDR_LEN_G(be32_to_cpu(l2info));
3570                 req->hdr_len |= cpu_to_be32(T6_TCP_HDR_LEN_V(tcp_hdr_len) |
3571                                             T6_IP_HDR_LEN_V(ip_hdr_len) |
3572                                             T6_ETH_HDR_LEN_V(eth_hdr_len));
3573         }
3574         req->vlan = vlantag;
3575         req->len = len;
3576         req->tos_stid = cpu_to_be32(PASS_OPEN_TID_V(stid) |
3577                                     PASS_OPEN_TOS_V(tos));
3578         req->tcpopt.mss = htons(tmp_opt.mss_clamp);
3579         if (tmp_opt.wscale_ok)
3580                 req->tcpopt.wsf = tmp_opt.snd_wscale;
3581         req->tcpopt.tstamp = tmp_opt.saw_tstamp;
3582         if (tmp_opt.sack_ok)
3583                 req->tcpopt.sack = 1;
3584         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_PASS_ACCEPT_REQ, 0));
3585         return;
3586 }
3587
3588 static void send_fw_pass_open_req(struct c4iw_dev *dev, struct sk_buff *skb,
3589                                   __be32 laddr, __be16 lport,
3590                                   __be32 raddr, __be16 rport,
3591                                   u32 rcv_isn, u32 filter, u16 window,
3592                                   u32 rss_qid, u8 port_id)
3593 {
3594         struct sk_buff *req_skb;
3595         struct fw_ofld_connection_wr *req;
3596         struct cpl_pass_accept_req *cpl = cplhdr(skb);
3597         int ret;
3598
3599         req_skb = alloc_skb(sizeof(struct fw_ofld_connection_wr), GFP_KERNEL);
3600         req = (struct fw_ofld_connection_wr *)__skb_put(req_skb, sizeof(*req));
3601         memset(req, 0, sizeof(*req));
3602         req->op_compl = htonl(WR_OP_V(FW_OFLD_CONNECTION_WR) | FW_WR_COMPL_F);
3603         req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));
3604         req->le.version_cpl = htonl(FW_OFLD_CONNECTION_WR_CPL_F);
3605         req->le.filter = (__force __be32) filter;
3606         req->le.lport = lport;
3607         req->le.pport = rport;
3608         req->le.u.ipv4.lip = laddr;
3609         req->le.u.ipv4.pip = raddr;
3610         req->tcb.rcv_nxt = htonl(rcv_isn + 1);
3611         req->tcb.rcv_adv = htons(window);
3612         req->tcb.t_state_to_astid =
3613                  htonl(FW_OFLD_CONNECTION_WR_T_STATE_V(TCP_SYN_RECV) |
3614                         FW_OFLD_CONNECTION_WR_RCV_SCALE_V(cpl->tcpopt.wsf) |
3615                         FW_OFLD_CONNECTION_WR_ASTID_V(
3616                         PASS_OPEN_TID_G(ntohl(cpl->tos_stid))));
3617
3618         /*
3619          * We store the qid in opt2 which will be used by the firmware
3620          * to send us the wr response.
3621          */
3622         req->tcb.opt2 = htonl(RSS_QUEUE_V(rss_qid));
3623
3624         /*
3625          * We initialize the MSS index in TCB to 0xF.
3626          * So that when driver sends cpl_pass_accept_rpl
3627          * TCB picks up the correct value. If this was 0
3628          * TP will ignore any value > 0 for MSS index.
3629          */
3630         req->tcb.opt0 = cpu_to_be64(MSS_IDX_V(0xF));
3631         req->cookie = (uintptr_t)skb;
3632
3633         set_wr_txq(req_skb, CPL_PRIORITY_CONTROL, port_id);
3634         ret = cxgb4_ofld_send(dev->rdev.lldi.ports[0], req_skb);
3635         if (ret < 0) {
3636                 pr_err("%s - cxgb4_ofld_send error %d - dropping\n", __func__,
3637                        ret);
3638                 kfree_skb(skb);
3639                 kfree_skb(req_skb);
3640         }
3641 }
3642
3643 /*
3644  * Handler for CPL_RX_PKT message. Need to handle cpl_rx_pkt
3645  * messages when a filter is being used instead of server to
3646  * redirect a syn packet. When packets hit filter they are redirected
3647  * to the offload queue and driver tries to establish the connection
3648  * using firmware work request.
3649  */
3650 static int rx_pkt(struct c4iw_dev *dev, struct sk_buff *skb)
3651 {
3652         int stid;
3653         unsigned int filter;
3654         struct ethhdr *eh = NULL;
3655         struct vlan_ethhdr *vlan_eh = NULL;
3656         struct iphdr *iph;
3657         struct tcphdr *tcph;
3658         struct rss_header *rss = (void *)skb->data;
3659         struct cpl_rx_pkt *cpl = (void *)skb->data;
3660         struct cpl_pass_accept_req *req = (void *)(rss + 1);
3661         struct l2t_entry *e;
3662         struct dst_entry *dst;
3663         struct c4iw_ep *lep;
3664         u16 window;
3665         struct port_info *pi;
3666         struct net_device *pdev;
3667         u16 rss_qid, eth_hdr_len;
3668         int step;
3669         u32 tx_chan;
3670         struct neighbour *neigh;
3671
3672         /* Drop all non-SYN packets */
3673         if (!(cpl->l2info & cpu_to_be32(RXF_SYN_F)))
3674                 goto reject;
3675
3676         /*
3677          * Drop all packets which did not hit the filter.
3678          * Unlikely to happen.
3679          */
3680         if (!(rss->filter_hit && rss->filter_tid))
3681                 goto reject;
3682
3683         /*
3684          * Calculate the server tid from filter hit index from cpl_rx_pkt.
3685          */
3686         stid = (__force int) cpu_to_be32((__force u32) rss->hash_val);
3687
3688         lep = (struct c4iw_ep *)lookup_stid(dev->rdev.lldi.tids, stid);
3689         if (!lep) {
3690                 PDBG("%s connect request on invalid stid %d\n", __func__, stid);
3691                 goto reject;
3692         }
3693
3694         switch (CHELSIO_CHIP_VERSION(dev->rdev.lldi.adapter_type)) {
3695         case CHELSIO_T4:
3696                 eth_hdr_len = RX_ETHHDR_LEN_G(be32_to_cpu(cpl->l2info));
3697                 break;
3698         case CHELSIO_T5:
3699                 eth_hdr_len = RX_T5_ETHHDR_LEN_G(be32_to_cpu(cpl->l2info));
3700                 break;
3701         case CHELSIO_T6:
3702                 eth_hdr_len = RX_T6_ETHHDR_LEN_G(be32_to_cpu(cpl->l2info));
3703                 break;
3704         default:
3705                 pr_err("T%d Chip is not supported\n",
3706                        CHELSIO_CHIP_VERSION(dev->rdev.lldi.adapter_type));
3707                 goto reject;
3708         }
3709
3710         if (eth_hdr_len == ETH_HLEN) {
3711                 eh = (struct ethhdr *)(req + 1);
3712                 iph = (struct iphdr *)(eh + 1);
3713         } else {
3714                 vlan_eh = (struct vlan_ethhdr *)(req + 1);
3715                 iph = (struct iphdr *)(vlan_eh + 1);
3716                 skb->vlan_tci = ntohs(cpl->vlan);
3717         }
3718
3719         if (iph->version != 0x4)
3720                 goto reject;
3721
3722         tcph = (struct tcphdr *)(iph + 1);
3723         skb_set_network_header(skb, (void *)iph - (void *)rss);
3724         skb_set_transport_header(skb, (void *)tcph - (void *)rss);
3725         skb_get(skb);
3726
3727         PDBG("%s lip 0x%x lport %u pip 0x%x pport %u tos %d\n", __func__,
3728              ntohl(iph->daddr), ntohs(tcph->dest), ntohl(iph->saddr),
3729              ntohs(tcph->source), iph->tos);
3730
3731         dst = find_route(dev, iph->daddr, iph->saddr, tcph->dest, tcph->source,
3732                          iph->tos);
3733         if (!dst) {
3734                 pr_err("%s - failed to find dst entry!\n",
3735                        __func__);
3736                 goto reject;
3737         }
3738         neigh = dst_neigh_lookup_skb(dst, skb);
3739
3740         if (!neigh) {
3741                 pr_err("%s - failed to allocate neigh!\n",
3742                        __func__);
3743                 goto free_dst;
3744         }
3745
3746         if (neigh->dev->flags & IFF_LOOPBACK) {
3747                 pdev = ip_dev_find(&init_net, iph->daddr);
3748                 e = cxgb4_l2t_get(dev->rdev.lldi.l2t, neigh,
3749                                     pdev, 0);
3750                 pi = (struct port_info *)netdev_priv(pdev);
3751                 tx_chan = cxgb4_port_chan(pdev);
3752                 dev_put(pdev);
3753         } else {
3754                 pdev = get_real_dev(neigh->dev);
3755                 e = cxgb4_l2t_get(dev->rdev.lldi.l2t, neigh,
3756                                         pdev, 0);
3757                 pi = (struct port_info *)netdev_priv(pdev);
3758                 tx_chan = cxgb4_port_chan(pdev);
3759         }
3760         neigh_release(neigh);
3761         if (!e) {
3762                 pr_err("%s - failed to allocate l2t entry!\n",
3763                        __func__);
3764                 goto free_dst;
3765         }
3766
3767         step = dev->rdev.lldi.nrxq / dev->rdev.lldi.nchan;
3768         rss_qid = dev->rdev.lldi.rxq_ids[pi->port_id * step];
3769         window = (__force u16) htons((__force u16)tcph->window);
3770
3771         /* Calcuate filter portion for LE region. */
3772         filter = (__force unsigned int) cpu_to_be32(cxgb4_select_ntuple(
3773                                                     dev->rdev.lldi.ports[0],
3774                                                     e));
3775
3776         /*
3777          * Synthesize the cpl_pass_accept_req. We have everything except the
3778          * TID. Once firmware sends a reply with TID we update the TID field
3779          * in cpl and pass it through the regular cpl_pass_accept_req path.
3780          */
3781         build_cpl_pass_accept_req(skb, stid, iph->tos);
3782         send_fw_pass_open_req(dev, skb, iph->daddr, tcph->dest, iph->saddr,
3783                               tcph->source, ntohl(tcph->seq), filter, window,
3784                               rss_qid, pi->port_id);
3785         cxgb4_l2t_release(e);
3786 free_dst:
3787         dst_release(dst);
3788 reject:
3789         return 0;
3790 }
3791
3792 /*
3793  * These are the real handlers that are called from a
3794  * work queue.
3795  */
3796 static c4iw_handler_func work_handlers[NUM_CPL_CMDS] = {
3797         [CPL_ACT_ESTABLISH] = act_establish,
3798         [CPL_ACT_OPEN_RPL] = act_open_rpl,
3799         [CPL_RX_DATA] = rx_data,
3800         [CPL_ABORT_RPL_RSS] = abort_rpl,
3801         [CPL_ABORT_RPL] = abort_rpl,
3802         [CPL_PASS_OPEN_RPL] = pass_open_rpl,
3803         [CPL_CLOSE_LISTSRV_RPL] = close_listsrv_rpl,
3804         [CPL_PASS_ACCEPT_REQ] = pass_accept_req,
3805         [CPL_PASS_ESTABLISH] = pass_establish,
3806         [CPL_PEER_CLOSE] = peer_close,
3807         [CPL_ABORT_REQ_RSS] = peer_abort,
3808         [CPL_CLOSE_CON_RPL] = close_con_rpl,
3809         [CPL_RDMA_TERMINATE] = terminate,
3810         [CPL_FW4_ACK] = fw4_ack,
3811         [CPL_FW6_MSG] = deferred_fw6_msg,
3812         [CPL_RX_PKT] = rx_pkt
3813 };
3814
3815 static void process_timeout(struct c4iw_ep *ep)
3816 {
3817         struct c4iw_qp_attributes attrs;
3818         int abort = 1;
3819
3820         mutex_lock(&ep->com.mutex);
3821         PDBG("%s ep %p tid %u state %d\n", __func__, ep, ep->hwtid,
3822              ep->com.state);
3823         set_bit(TIMEDOUT, &ep->com.history);
3824         switch (ep->com.state) {
3825         case MPA_REQ_SENT:
3826                 __state_set(&ep->com, ABORTING);
3827                 connect_reply_upcall(ep, -ETIMEDOUT);
3828                 break;
3829         case MPA_REQ_WAIT:
3830                 __state_set(&ep->com, ABORTING);
3831                 break;
3832         case CLOSING:
3833         case MORIBUND:
3834                 if (ep->com.cm_id && ep->com.qp) {
3835                         attrs.next_state = C4IW_QP_STATE_ERROR;
3836                         c4iw_modify_qp(ep->com.qp->rhp,
3837                                      ep->com.qp, C4IW_QP_ATTR_NEXT_STATE,
3838                                      &attrs, 1);
3839                 }
3840                 __state_set(&ep->com, ABORTING);
3841                 close_complete_upcall(ep, -ETIMEDOUT);
3842                 break;
3843         case ABORTING:
3844         case DEAD:
3845
3846                 /*
3847                  * These states are expected if the ep timed out at the same
3848                  * time as another thread was calling stop_ep_timer().
3849                  * So we silently do nothing for these states.
3850                  */
3851                 abort = 0;
3852                 break;
3853         default:
3854                 WARN(1, "%s unexpected state ep %p tid %u state %u\n",
3855                         __func__, ep, ep->hwtid, ep->com.state);
3856                 abort = 0;
3857         }
3858         if (abort)
3859                 abort_connection(ep, NULL, GFP_KERNEL);
3860         mutex_unlock(&ep->com.mutex);
3861         c4iw_put_ep(&ep->com);
3862 }
3863
3864 static void process_timedout_eps(void)
3865 {
3866         struct c4iw_ep *ep;
3867
3868         spin_lock_irq(&timeout_lock);
3869         while (!list_empty(&timeout_list)) {
3870                 struct list_head *tmp;
3871
3872                 tmp = timeout_list.next;
3873                 list_del(tmp);
3874                 tmp->next = NULL;
3875                 tmp->prev = NULL;
3876                 spin_unlock_irq(&timeout_lock);
3877                 ep = list_entry(tmp, struct c4iw_ep, entry);
3878                 process_timeout(ep);
3879                 spin_lock_irq(&timeout_lock);
3880         }
3881         spin_unlock_irq(&timeout_lock);
3882 }
3883
3884 static void process_work(struct work_struct *work)
3885 {
3886         struct sk_buff *skb = NULL;
3887         struct c4iw_dev *dev;
3888         struct cpl_act_establish *rpl;
3889         unsigned int opcode;
3890         int ret;
3891
3892         process_timedout_eps();
3893         while ((skb = skb_dequeue(&rxq))) {
3894                 rpl = cplhdr(skb);
3895                 dev = *((struct c4iw_dev **) (skb->cb + sizeof(void *)));
3896                 opcode = rpl->ot.opcode;
3897
3898                 BUG_ON(!work_handlers[opcode]);
3899                 ret = work_handlers[opcode](dev, skb);
3900                 if (!ret)
3901                         kfree_skb(skb);
3902                 process_timedout_eps();
3903         }
3904 }
3905
3906 static DECLARE_WORK(skb_work, process_work);
3907
3908 static void ep_timeout(unsigned long arg)
3909 {
3910         struct c4iw_ep *ep = (struct c4iw_ep *)arg;
3911         int kickit = 0;
3912
3913         spin_lock(&timeout_lock);
3914         if (!test_and_set_bit(TIMEOUT, &ep->com.flags)) {
3915                 /*
3916                  * Only insert if it is not already on the list.
3917                  */
3918                 if (!ep->entry.next) {
3919                         list_add_tail(&ep->entry, &timeout_list);
3920                         kickit = 1;
3921                 }
3922         }
3923         spin_unlock(&timeout_lock);
3924         if (kickit)
3925                 queue_work(workq, &skb_work);
3926 }
3927
3928 /*
3929  * All the CM events are handled on a work queue to have a safe context.
3930  */
3931 static int sched(struct c4iw_dev *dev, struct sk_buff *skb)
3932 {
3933
3934         /*
3935          * Save dev in the skb->cb area.
3936          */
3937         *((struct c4iw_dev **) (skb->cb + sizeof(void *))) = dev;
3938
3939         /*
3940          * Queue the skb and schedule the worker thread.
3941          */
3942         skb_queue_tail(&rxq, skb);
3943         queue_work(workq, &skb_work);
3944         return 0;
3945 }
3946
3947 static int set_tcb_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
3948 {
3949         struct cpl_set_tcb_rpl *rpl = cplhdr(skb);
3950
3951         if (rpl->status != CPL_ERR_NONE) {
3952                 printk(KERN_ERR MOD "Unexpected SET_TCB_RPL status %u "
3953                        "for tid %u\n", rpl->status, GET_TID(rpl));
3954         }
3955         kfree_skb(skb);
3956         return 0;
3957 }
3958
3959 static int fw6_msg(struct c4iw_dev *dev, struct sk_buff *skb)
3960 {
3961         struct cpl_fw6_msg *rpl = cplhdr(skb);
3962         struct c4iw_wr_wait *wr_waitp;
3963         int ret;
3964
3965         PDBG("%s type %u\n", __func__, rpl->type);
3966
3967         switch (rpl->type) {
3968         case FW6_TYPE_WR_RPL:
3969                 ret = (int)((be64_to_cpu(rpl->data[0]) >> 8) & 0xff);
3970                 wr_waitp = (struct c4iw_wr_wait *)(__force unsigned long) rpl->data[1];
3971                 PDBG("%s wr_waitp %p ret %u\n", __func__, wr_waitp, ret);
3972                 if (wr_waitp)
3973                         c4iw_wake_up(wr_waitp, ret ? -ret : 0);
3974                 kfree_skb(skb);
3975                 break;
3976         case FW6_TYPE_CQE:
3977         case FW6_TYPE_OFLD_CONNECTION_WR_RPL:
3978                 sched(dev, skb);
3979                 break;
3980         default:
3981                 printk(KERN_ERR MOD "%s unexpected fw6 msg type %u\n", __func__,
3982                        rpl->type);
3983                 kfree_skb(skb);
3984                 break;
3985         }
3986         return 0;
3987 }
3988
3989 static int peer_abort_intr(struct c4iw_dev *dev, struct sk_buff *skb)
3990 {
3991         struct cpl_abort_req_rss *req = cplhdr(skb);
3992         struct c4iw_ep *ep;
3993         struct tid_info *t = dev->rdev.lldi.tids;
3994         unsigned int tid = GET_TID(req);
3995
3996         ep = lookup_tid(t, tid);
3997         if (!ep) {
3998                 printk(KERN_WARNING MOD
3999                        "Abort on non-existent endpoint, tid %d\n", tid);
4000                 kfree_skb(skb);
4001                 return 0;
4002         }
4003         if (is_neg_adv(req->status)) {
4004                 PDBG("%s Negative advice on abort- tid %u status %d (%s)\n",
4005                      __func__, ep->hwtid, req->status,
4006                      neg_adv_str(req->status));
4007                 ep->stats.abort_neg_adv++;
4008                 dev->rdev.stats.neg_adv++;
4009                 kfree_skb(skb);
4010                 return 0;
4011         }
4012         PDBG("%s ep %p tid %u state %u\n", __func__, ep, ep->hwtid,
4013              ep->com.state);
4014
4015         /*
4016          * Wake up any threads in rdma_init() or rdma_fini().
4017          * However, if we are on MPAv2 and want to retry with MPAv1
4018          * then, don't wake up yet.
4019          */
4020         if (mpa_rev == 2 && !ep->tried_with_mpa_v1) {
4021                 if (ep->com.state != MPA_REQ_SENT)
4022                         c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
4023         } else
4024                 c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
4025         sched(dev, skb);
4026         return 0;
4027 }
4028
4029 /*
4030  * Most upcalls from the T4 Core go to sched() to
4031  * schedule the processing on a work queue.
4032  */
4033 c4iw_handler_func c4iw_handlers[NUM_CPL_CMDS] = {
4034         [CPL_ACT_ESTABLISH] = sched,
4035         [CPL_ACT_OPEN_RPL] = sched,
4036         [CPL_RX_DATA] = sched,
4037         [CPL_ABORT_RPL_RSS] = sched,
4038         [CPL_ABORT_RPL] = sched,
4039         [CPL_PASS_OPEN_RPL] = sched,
4040         [CPL_CLOSE_LISTSRV_RPL] = sched,
4041         [CPL_PASS_ACCEPT_REQ] = sched,
4042         [CPL_PASS_ESTABLISH] = sched,
4043         [CPL_PEER_CLOSE] = sched,
4044         [CPL_CLOSE_CON_RPL] = sched,
4045         [CPL_ABORT_REQ_RSS] = peer_abort_intr,
4046         [CPL_RDMA_TERMINATE] = sched,
4047         [CPL_FW4_ACK] = sched,
4048         [CPL_SET_TCB_RPL] = set_tcb_rpl,
4049         [CPL_FW6_MSG] = fw6_msg,
4050         [CPL_RX_PKT] = sched
4051 };
4052
4053 int __init c4iw_cm_init(void)
4054 {
4055         spin_lock_init(&timeout_lock);
4056         skb_queue_head_init(&rxq);
4057
4058         workq = create_singlethread_workqueue("iw_cxgb4");
4059         if (!workq)
4060                 return -ENOMEM;
4061
4062         return 0;
4063 }
4064
4065 void c4iw_cm_term(void)
4066 {
4067         WARN_ON(!list_empty(&timeout_list));
4068         flush_workqueue(workq);
4069         destroy_workqueue(workq);
4070 }