drivers/infiniband/hw/qedr/qedr_iw_cm.c

   1 /* QLogic qedr NIC Driver
   2  * Copyright (c) 2015-2017  QLogic Corporation
   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 <net/ip.h>
  33 #include <net/ipv6.h>
  34 #include <net/udp.h>
  35 #include <net/addrconf.h>
  36 #include <net/route.h>
  37 #include <net/ip6_route.h>
  38 #include <net/flow.h>
  39 #include "qedr.h"
  40 #include "qedr_iw_cm.h"
  41
  42 static inline void
  43 qedr_fill_sockaddr4(const struct qed_iwarp_cm_info *cm_info,
  44                     struct iw_cm_event *event)
  45 {
  46         struct sockaddr_in *laddr = (struct sockaddr_in *)&event->local_addr;
  47         struct sockaddr_in *raddr = (struct sockaddr_in *)&event->remote_addr;
  48
  49         laddr->sin_family = AF_INET;
  50         raddr->sin_family = AF_INET;
  51
  52         laddr->sin_port = htons(cm_info->local_port);
  53         raddr->sin_port = htons(cm_info->remote_port);
  54
  55         laddr->sin_addr.s_addr = htonl(cm_info->local_ip[0]);
  56         raddr->sin_addr.s_addr = htonl(cm_info->remote_ip[0]);
  57 }
  58
  59 static inline void
  60 qedr_fill_sockaddr6(const struct qed_iwarp_cm_info *cm_info,
  61                     struct iw_cm_event *event)
  62 {
  63         struct sockaddr_in6 *laddr6 = (struct sockaddr_in6 *)&event->local_addr;
  64         struct sockaddr_in6 *raddr6 =
  65             (struct sockaddr_in6 *)&event->remote_addr;
  66         int i;
  67
  68         laddr6->sin6_family = AF_INET6;
  69         raddr6->sin6_family = AF_INET6;
  70
  71         laddr6->sin6_port = htons(cm_info->local_port);
  72         raddr6->sin6_port = htons(cm_info->remote_port);
  73
  74         for (i = 0; i < 4; i++) {
  75                 laddr6->sin6_addr.in6_u.u6_addr32[i] =
  76                     htonl(cm_info->local_ip[i]);
  77                 raddr6->sin6_addr.in6_u.u6_addr32[i] =
  78                     htonl(cm_info->remote_ip[i]);
  79         }
  80 }
  81
  82 static void
  83 qedr_iw_mpa_request(void *context, struct qed_iwarp_cm_event_params *params)
  84 {
  85         struct qedr_iw_listener *listener = (struct qedr_iw_listener *)context;
  86         struct qedr_dev *dev = listener->dev;
  87         struct iw_cm_event event;
  88         struct qedr_iw_ep *ep;
  89
  90         ep = kzalloc(sizeof(*ep), GFP_ATOMIC);
  91         if (!ep)
  92                 return;
  93
  94         ep->dev = dev;
  95         ep->qed_context = params->ep_context;
  96
  97         memset(&event, 0, sizeof(event));
  98         event.event = IW_CM_EVENT_CONNECT_REQUEST;
  99         event.status = params->status;
 100
 101         if (!IS_ENABLED(CONFIG_IPV6) ||
 102             params->cm_info->ip_version == QED_TCP_IPV4)
 103                 qedr_fill_sockaddr4(params->cm_info, &event);
 104         else
 105                 qedr_fill_sockaddr6(params->cm_info, &event);
 106
 107         event.provider_data = (void *)ep;
 108         event.private_data = (void *)params->cm_info->private_data;
 109         event.private_data_len = (u8)params->cm_info->private_data_len;
 110         event.ord = params->cm_info->ord;
 111         event.ird = params->cm_info->ird;
 112
 113         listener->cm_id->event_handler(listener->cm_id, &event);
 114 }
 115
 116 static void
 117 qedr_iw_issue_event(void *context,
 118                     struct qed_iwarp_cm_event_params *params,
 119                     enum iw_cm_event_type event_type)
 120 {
 121         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 122         struct iw_cm_event event;
 123
 124         memset(&event, 0, sizeof(event));
 125         event.status = params->status;
 126         event.event = event_type;
 127
 128         if (params->cm_info) {
 129                 event.ird = params->cm_info->ird;
 130                 event.ord = params->cm_info->ord;
 131                 /* Only connect_request and reply have valid private data
 132                  * the rest of the events this may be left overs from
 133                  * connection establishment. CONNECT_REQUEST is issued via
 134                  * qedr_iw_mpa_request
 135                  */
 136                 if (event_type == IW_CM_EVENT_CONNECT_REPLY) {
 137                         event.private_data_len =
 138                                 params->cm_info->private_data_len;
 139                         event.private_data =
 140                                 (void *)params->cm_info->private_data;
 141                 }
 142         }
 143
 144         if (ep->cm_id)
 145                 ep->cm_id->event_handler(ep->cm_id, &event);
 146 }
 147
 148 static void
 149 qedr_iw_close_event(void *context, struct qed_iwarp_cm_event_params *params)
 150 {
 151         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 152
 153         if (ep->cm_id) {
 154                 qedr_iw_issue_event(context, params, IW_CM_EVENT_CLOSE);
 155
 156                 ep->cm_id->rem_ref(ep->cm_id);
 157                 ep->cm_id = NULL;
 158         }
 159 }
 160
 161 static void
 162 qedr_iw_qp_event(void *context,
 163                  struct qed_iwarp_cm_event_params *params,
 164                  enum ib_event_type ib_event, char *str)
 165 {
 166         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 167         struct qedr_dev *dev = ep->dev;
 168         struct ib_qp *ibqp = &ep->qp->ibqp;
 169         struct ib_event event;
 170
 171         DP_NOTICE(dev, "QP error received: %s\n", str);
 172
 173         if (ibqp->event_handler) {
 174                 event.event = ib_event;
 175                 event.device = ibqp->device;
 176                 event.element.qp = ibqp;
 177                 ibqp->event_handler(&event, ibqp->qp_context);
 178         }
 179 }
 180
 181 struct qedr_discon_work {
 182         struct work_struct              work;
 183         struct qedr_iw_ep               *ep;
 184         enum qed_iwarp_event_type       event;
 185         int                             status;
 186 };
 187
 188 static void qedr_iw_disconnect_worker(struct work_struct *work)
 189 {
 190         struct qedr_discon_work *dwork =
 191             container_of(work, struct qedr_discon_work, work);
 192         struct qed_rdma_modify_qp_in_params qp_params = { 0 };
 193         struct qedr_iw_ep *ep = dwork->ep;
 194         struct qedr_dev *dev = ep->dev;
 195         struct qedr_qp *qp = ep->qp;
 196         struct iw_cm_event event;
 197
 198         if (qp->destroyed) {
 199                 kfree(dwork);
 200                 qedr_iw_qp_rem_ref(&qp->ibqp);
 201                 return;
 202         }
 203
 204         memset(&event, 0, sizeof(event));
 205         event.status = dwork->status;
 206         event.event = IW_CM_EVENT_DISCONNECT;
 207
 208         /* Success means graceful disconnect was requested. modifying
 209          * to SQD is translated to graceful disconnect. O/w reset is sent
 210          */
 211         if (dwork->status)
 212                 qp_params.new_state = QED_ROCE_QP_STATE_ERR;
 213         else
 214                 qp_params.new_state = QED_ROCE_QP_STATE_SQD;
 215
 216         kfree(dwork);
 217
 218         if (ep->cm_id)
 219                 ep->cm_id->event_handler(ep->cm_id, &event);
 220
 221         SET_FIELD(qp_params.modify_flags,
 222                   QED_RDMA_MODIFY_QP_VALID_NEW_STATE, 1);
 223
 224         dev->ops->rdma_modify_qp(dev->rdma_ctx, qp->qed_qp, &qp_params);
 225
 226         qedr_iw_qp_rem_ref(&qp->ibqp);
 227 }
 228
 229 static void
 230 qedr_iw_disconnect_event(void *context,
 231                          struct qed_iwarp_cm_event_params *params)
 232 {
 233         struct qedr_discon_work *work;
 234         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 235         struct qedr_dev *dev = ep->dev;
 236         struct qedr_qp *qp = ep->qp;
 237
 238         work = kzalloc(sizeof(*work), GFP_ATOMIC);
 239         if (!work)
 240                 return;
 241
 242         qedr_iw_qp_add_ref(&qp->ibqp);
 243         work->ep = ep;
 244         work->event = params->event;
 245         work->status = params->status;
 246
 247         INIT_WORK(&work->work, qedr_iw_disconnect_worker);
 248         queue_work(dev->iwarp_wq, &work->work);
 249 }
 250
 251 static void
 252 qedr_iw_passive_complete(void *context,
 253                          struct qed_iwarp_cm_event_params *params)
 254 {
 255         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 256         struct qedr_dev *dev = ep->dev;
 257
 258         /* We will only reach the following state if MPA_REJECT was called on
 259          * passive. In this case there will be no associated QP.
 260          */
 261         if ((params->status == -ECONNREFUSED) && (!ep->qp)) {
 262                 DP_DEBUG(dev, QEDR_MSG_IWARP,
 263                          "PASSIVE connection refused releasing ep...\n");
 264                 kfree(ep);
 265                 return;
 266         }
 267
 268         qedr_iw_issue_event(context, params, IW_CM_EVENT_ESTABLISHED);
 269
 270         if (params->status < 0)
 271                 qedr_iw_close_event(context, params);
 272 }
 273
 274 static int
 275 qedr_iw_mpa_reply(void *context, struct qed_iwarp_cm_event_params *params)
 276 {
 277         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 278         struct qedr_dev *dev = ep->dev;
 279         struct qed_iwarp_send_rtr_in rtr_in;
 280
 281         rtr_in.ep_context = params->ep_context;
 282
 283         return dev->ops->iwarp_send_rtr(dev->rdma_ctx, &rtr_in);
 284 }
 285
 286 static int
 287 qedr_iw_event_handler(void *context, struct qed_iwarp_cm_event_params *params)
 288 {
 289         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 290         struct qedr_dev *dev = ep->dev;
 291
 292         switch (params->event) {
 293         case QED_IWARP_EVENT_MPA_REQUEST:
 294                 qedr_iw_mpa_request(context, params);
 295                 break;
 296         case QED_IWARP_EVENT_ACTIVE_MPA_REPLY:
 297                 qedr_iw_mpa_reply(context, params);
 298                 break;
 299         case QED_IWARP_EVENT_PASSIVE_COMPLETE:
 300                 ep->during_connect = 0;
 301                 qedr_iw_passive_complete(context, params);
 302                 break;
 303
 304         case QED_IWARP_EVENT_ACTIVE_COMPLETE:
 305                 ep->during_connect = 0;
 306                 qedr_iw_issue_event(context,
 307                                     params,
 308                                     IW_CM_EVENT_CONNECT_REPLY);
 309                 if (params->status < 0) {
 310                         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context;
 311
 312                         ep->cm_id->rem_ref(ep->cm_id);
 313                         ep->cm_id = NULL;
 314                 }
 315                 break;
 316         case QED_IWARP_EVENT_DISCONNECT:
 317                 qedr_iw_disconnect_event(context, params);
 318                 break;
 319         case QED_IWARP_EVENT_CLOSE:
 320                 ep->during_connect = 0;
 321                 qedr_iw_close_event(context, params);
 322                 break;
 323         case QED_IWARP_EVENT_RQ_EMPTY:
 324                 qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL,
 325                                  "QED_IWARP_EVENT_RQ_EMPTY");
 326                 break;
 327         case QED_IWARP_EVENT_IRQ_FULL:
 328                 qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL,
 329                                  "QED_IWARP_EVENT_IRQ_FULL");
 330                 break;
 331         case QED_IWARP_EVENT_LLP_TIMEOUT:
 332                 qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL,
 333                                  "QED_IWARP_EVENT_LLP_TIMEOUT");
 334                 break;
 335         case QED_IWARP_EVENT_REMOTE_PROTECTION_ERROR:
 336                 qedr_iw_qp_event(context, params, IB_EVENT_QP_ACCESS_ERR,
 337                                  "QED_IWARP_EVENT_REMOTE_PROTECTION_ERROR");
 338                 break;
 339         case QED_IWARP_EVENT_CQ_OVERFLOW:
 340                 qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL,
 341                                  "QED_IWARP_EVENT_CQ_OVERFLOW");
 342                 break;
 343         case QED_IWARP_EVENT_QP_CATASTROPHIC:
 344                 qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL,
 345                                  "QED_IWARP_EVENT_QP_CATASTROPHIC");
 346                 break;
 347         case QED_IWARP_EVENT_LOCAL_ACCESS_ERROR:
 348                 qedr_iw_qp_event(context, params, IB_EVENT_QP_ACCESS_ERR,
 349                                  "QED_IWARP_EVENT_LOCAL_ACCESS_ERROR");
 350                 break;
 351         case QED_IWARP_EVENT_REMOTE_OPERATION_ERROR:
 352                 qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL,
 353                                  "QED_IWARP_EVENT_REMOTE_OPERATION_ERROR");
 354                 break;
 355         case QED_IWARP_EVENT_TERMINATE_RECEIVED:
 356                 DP_NOTICE(dev, "Got terminate message\n");
 357                 break;
 358         default:
 359                 DP_NOTICE(dev, "Unknown event received %d\n", params->event);
 360                 break;
 361         };
 362         return 0;
 363 }
 364
 365 static u16 qedr_iw_get_vlan_ipv4(struct qedr_dev *dev, u32 *addr)
 366 {
 367         struct net_device *ndev;
 368         u16 vlan_id = 0;
 369
 370         ndev = ip_dev_find(&init_net, htonl(addr[0]));
 371
 372         if (ndev) {
 373                 vlan_id = rdma_vlan_dev_vlan_id(ndev);
 374                 dev_put(ndev);
 375         }
 376         if (vlan_id == 0xffff)
 377                 vlan_id = 0;
 378         return vlan_id;
 379 }
 380
 381 static u16 qedr_iw_get_vlan_ipv6(u32 *addr)
 382 {
 383         struct net_device *ndev = NULL;
 384         struct in6_addr laddr6;
 385         u16 vlan_id = 0;
 386         int i;
 387
 388         if (!IS_ENABLED(CONFIG_IPV6))
 389                 return vlan_id;
 390
 391         for (i = 0; i < 4; i++)
 392                 laddr6.in6_u.u6_addr32[i] = htonl(addr[i]);
 393
 394         rcu_read_lock();
 395         for_each_netdev_rcu(&init_net, ndev) {
 396                 if (ipv6_chk_addr(&init_net, &laddr6, ndev, 1)) {
 397                         vlan_id = rdma_vlan_dev_vlan_id(ndev);
 398                         break;
 399                 }
 400         }
 401
 402         rcu_read_unlock();
 403         if (vlan_id == 0xffff)
 404                 vlan_id = 0;
 405
 406         return vlan_id;
 407 }
 408
 409 static int
 410 qedr_addr4_resolve(struct qedr_dev *dev,
 411                    struct sockaddr_in *src_in,
 412                    struct sockaddr_in *dst_in, u8 *dst_mac)
 413 {
 414         __be32 src_ip = src_in->sin_addr.s_addr;
 415         __be32 dst_ip = dst_in->sin_addr.s_addr;
 416         struct neighbour *neigh = NULL;
 417         struct rtable *rt = NULL;
 418         int rc = 0;
 419
 420         rt = ip_route_output(&init_net, dst_ip, src_ip, 0, 0);
 421         if (IS_ERR(rt)) {
 422                 DP_ERR(dev, "ip_route_output returned error\n");
 423                 return -EINVAL;
 424         }
 425
 426         neigh = dst_neigh_lookup(&rt->dst, &dst_ip);
 427
 428         if (neigh) {
 429                 rcu_read_lock();
 430                 if (neigh->nud_state & NUD_VALID) {
 431                         ether_addr_copy(dst_mac, neigh->ha);
 432                         DP_DEBUG(dev, QEDR_MSG_QP, "mac_addr=[%pM]\n", dst_mac);
 433                 } else {
 434                         neigh_event_send(neigh, NULL);
 435                 }
 436                 rcu_read_unlock();
 437                 neigh_release(neigh);
 438         }
 439
 440         ip_rt_put(rt);
 441
 442         return rc;
 443 }
 444
 445 static int
 446 qedr_addr6_resolve(struct qedr_dev *dev,
 447                    struct sockaddr_in6 *src_in,
 448                    struct sockaddr_in6 *dst_in, u8 *dst_mac)
 449 {
 450         struct neighbour *neigh = NULL;
 451         struct dst_entry *dst;
 452         struct flowi6 fl6;
 453         int rc = 0;
 454
 455         memset(&fl6, 0, sizeof(fl6));
 456         fl6.daddr = dst_in->sin6_addr;
 457         fl6.saddr = src_in->sin6_addr;
 458
 459         dst = ip6_route_output(&init_net, NULL, &fl6);
 460
 461         if ((!dst) || dst->error) {
 462                 if (dst) {
 463                         DP_ERR(dev,
 464                                "ip6_route_output returned dst->error = %d\n",
 465                                dst->error);
 466                         dst_release(dst);
 467                 }
 468                 return -EINVAL;
 469         }
 470         neigh = dst_neigh_lookup(dst, &fl6.daddr);
 471         if (neigh) {
 472                 rcu_read_lock();
 473                 if (neigh->nud_state & NUD_VALID) {
 474                         ether_addr_copy(dst_mac, neigh->ha);
 475                         DP_DEBUG(dev, QEDR_MSG_QP, "mac_addr=[%pM]\n", dst_mac);
 476                 } else {
 477                         neigh_event_send(neigh, NULL);
 478                 }
 479                 rcu_read_unlock();
 480                 neigh_release(neigh);
 481         }
 482
 483         dst_release(dst);
 484
 485         return rc;
 486 }
 487
 488 int qedr_iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 489 {
 490         struct qedr_dev *dev = get_qedr_dev(cm_id->device);
 491         struct qed_iwarp_connect_out out_params;
 492         struct qed_iwarp_connect_in in_params;
 493         struct qed_iwarp_cm_info *cm_info;
 494         struct sockaddr_in6 *laddr6;
 495         struct sockaddr_in6 *raddr6;
 496         struct sockaddr_in *laddr;
 497         struct sockaddr_in *raddr;
 498         struct qedr_iw_ep *ep;
 499         struct qedr_qp *qp;
 500         int rc = 0;
 501         int i;
 502
 503         qp = idr_find(&dev->qpidr.idr, conn_param->qpn);
 504         if (unlikely(!qp))
 505                 return -EINVAL;
 506
 507         laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
 508         raddr = (struct sockaddr_in *)&cm_id->m_remote_addr;
 509         laddr6 = (struct sockaddr_in6 *)&cm_id->m_local_addr;
 510         raddr6 = (struct sockaddr_in6 *)&cm_id->m_remote_addr;
 511
 512         DP_DEBUG(dev, QEDR_MSG_IWARP, "MAPPED %d %d\n",
 513                  ntohs(((struct sockaddr_in *)&cm_id->remote_addr)->sin_port),
 514                  ntohs(raddr->sin_port));
 515
 516         DP_DEBUG(dev, QEDR_MSG_IWARP,
 517                  "Connect source address: %pISpc, remote address: %pISpc\n",
 518                  &cm_id->local_addr, &cm_id->remote_addr);
 519
 520         if (!laddr->sin_port || !raddr->sin_port)
 521                 return -EINVAL;
 522
 523         ep = kzalloc(sizeof(*ep), GFP_KERNEL);
 524         if (!ep)
 525                 return -ENOMEM;
 526
 527         ep->dev = dev;
 528         ep->qp = qp;
 529         qp->ep = ep;
 530         cm_id->add_ref(cm_id);
 531         ep->cm_id = cm_id;
 532
 533         in_params.event_cb = qedr_iw_event_handler;
 534         in_params.cb_context = ep;
 535
 536         cm_info = &in_params.cm_info;
 537         memset(cm_info->local_ip, 0, sizeof(cm_info->local_ip));
 538         memset(cm_info->remote_ip, 0, sizeof(cm_info->remote_ip));
 539
 540         if (!IS_ENABLED(CONFIG_IPV6) ||
 541             cm_id->remote_addr.ss_family == AF_INET) {
 542                 cm_info->ip_version = QED_TCP_IPV4;
 543
 544                 cm_info->remote_ip[0] = ntohl(raddr->sin_addr.s_addr);
 545                 cm_info->local_ip[0] = ntohl(laddr->sin_addr.s_addr);
 546                 cm_info->remote_port = ntohs(raddr->sin_port);
 547                 cm_info->local_port = ntohs(laddr->sin_port);
 548                 cm_info->vlan = qedr_iw_get_vlan_ipv4(dev, cm_info->local_ip);
 549
 550                 rc = qedr_addr4_resolve(dev, laddr, raddr,
 551                                         (u8 *)in_params.remote_mac_addr);
 552
 553                 in_params.mss = dev->iwarp_max_mtu -
 554                     (sizeof(struct iphdr) + sizeof(struct tcphdr));
 555
 556         } else {
 557                 in_params.cm_info.ip_version = QED_TCP_IPV6;
 558
 559                 for (i = 0; i < 4; i++) {
 560                         cm_info->remote_ip[i] =
 561                             ntohl(raddr6->sin6_addr.in6_u.u6_addr32[i]);
 562                         cm_info->local_ip[i] =
 563                             ntohl(laddr6->sin6_addr.in6_u.u6_addr32[i]);
 564                 }
 565
 566                 cm_info->local_port = ntohs(laddr6->sin6_port);
 567                 cm_info->remote_port = ntohs(raddr6->sin6_port);
 568
 569                 in_params.mss = dev->iwarp_max_mtu -
 570                     (sizeof(struct ipv6hdr) + sizeof(struct tcphdr));
 571
 572                 cm_info->vlan = qedr_iw_get_vlan_ipv6(cm_info->local_ip);
 573
 574                 rc = qedr_addr6_resolve(dev, laddr6, raddr6,
 575                                         (u8 *)in_params.remote_mac_addr);
 576         }
 577         if (rc)
 578                 goto err;
 579
 580         DP_DEBUG(dev, QEDR_MSG_IWARP,
 581                  "ord = %d ird=%d private_data=%p private_data_len=%d rq_psn=%d\n",
 582                  conn_param->ord, conn_param->ird, conn_param->private_data,
 583                  conn_param->private_data_len, qp->rq_psn);
 584
 585         cm_info->ord = conn_param->ord;
 586         cm_info->ird = conn_param->ird;
 587         cm_info->private_data = conn_param->private_data;
 588         cm_info->private_data_len = conn_param->private_data_len;
 589         in_params.qp = qp->qed_qp;
 590         memcpy(in_params.local_mac_addr, dev->ndev->dev_addr, ETH_ALEN);
 591
 592         ep->during_connect = 1;
 593         rc = dev->ops->iwarp_connect(dev->rdma_ctx, &in_params, &out_params);
 594         if (rc)
 595                 goto err;
 596
 597         return rc;
 598
 599 err:
 600         cm_id->rem_ref(cm_id);
 601         kfree(ep);
 602         return rc;
 603 }
 604
 605 int qedr_iw_create_listen(struct iw_cm_id *cm_id, int backlog)
 606 {
 607         struct qedr_dev *dev = get_qedr_dev(cm_id->device);
 608         struct qedr_iw_listener *listener;
 609         struct qed_iwarp_listen_in iparams;
 610         struct qed_iwarp_listen_out oparams;
 611         struct sockaddr_in *laddr;
 612         struct sockaddr_in6 *laddr6;
 613         int rc;
 614         int i;
 615
 616         laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
 617         laddr6 = (struct sockaddr_in6 *)&cm_id->m_local_addr;
 618
 619         DP_DEBUG(dev, QEDR_MSG_IWARP,
 620                  "Create Listener address: %pISpc\n", &cm_id->local_addr);
 621
 622         listener = kzalloc(sizeof(*listener), GFP_KERNEL);
 623         if (!listener)
 624                 return -ENOMEM;
 625
 626         listener->dev = dev;
 627         cm_id->add_ref(cm_id);
 628         listener->cm_id = cm_id;
 629         listener->backlog = backlog;
 630
 631         iparams.cb_context = listener;
 632         iparams.event_cb = qedr_iw_event_handler;
 633         iparams.max_backlog = backlog;
 634
 635         if (!IS_ENABLED(CONFIG_IPV6) ||
 636             cm_id->local_addr.ss_family == AF_INET) {
 637                 iparams.ip_version = QED_TCP_IPV4;
 638                 memset(iparams.ip_addr, 0, sizeof(iparams.ip_addr));
 639
 640                 iparams.ip_addr[0] = ntohl(laddr->sin_addr.s_addr);
 641                 iparams.port = ntohs(laddr->sin_port);
 642                 iparams.vlan = qedr_iw_get_vlan_ipv4(dev, iparams.ip_addr);
 643         } else {
 644                 iparams.ip_version = QED_TCP_IPV6;
 645
 646                 for (i = 0; i < 4; i++) {
 647                         iparams.ip_addr[i] =
 648                             ntohl(laddr6->sin6_addr.in6_u.u6_addr32[i]);
 649                 }
 650
 651                 iparams.port = ntohs(laddr6->sin6_port);
 652
 653                 iparams.vlan = qedr_iw_get_vlan_ipv6(iparams.ip_addr);
 654         }
 655         rc = dev->ops->iwarp_create_listen(dev->rdma_ctx, &iparams, &oparams);
 656         if (rc)
 657                 goto err;
 658
 659         listener->qed_handle = oparams.handle;
 660         cm_id->provider_data = listener;
 661         return rc;
 662
 663 err:
 664         cm_id->rem_ref(cm_id);
 665         kfree(listener);
 666         return rc;
 667 }
 668
 669 int qedr_iw_destroy_listen(struct iw_cm_id *cm_id)
 670 {
 671         struct qedr_iw_listener *listener = cm_id->provider_data;
 672         struct qedr_dev *dev = get_qedr_dev(cm_id->device);
 673         int rc = 0;
 674
 675         if (listener->qed_handle)
 676                 rc = dev->ops->iwarp_destroy_listen(dev->rdma_ctx,
 677                                                     listener->qed_handle);
 678
 679         cm_id->rem_ref(cm_id);
 680         kfree(listener);
 681         return rc;
 682 }
 683
 684 int qedr_iw_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 685 {
 686         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)cm_id->provider_data;
 687         struct qedr_dev *dev = ep->dev;
 688         struct qedr_qp *qp;
 689         struct qed_iwarp_accept_in params;
 690         int rc;
 691
 692         DP_DEBUG(dev, QEDR_MSG_IWARP, "Accept on qpid=%d\n", conn_param->qpn);
 693
 694         qp = idr_find(&dev->qpidr.idr, conn_param->qpn);
 695         if (!qp) {
 696                 DP_ERR(dev, "Invalid QP number %d\n", conn_param->qpn);
 697                 return -EINVAL;
 698         }
 699
 700         ep->qp = qp;
 701         qp->ep = ep;
 702         cm_id->add_ref(cm_id);
 703         ep->cm_id = cm_id;
 704
 705         params.ep_context = ep->qed_context;
 706         params.cb_context = ep;
 707         params.qp = ep->qp->qed_qp;
 708         params.private_data = conn_param->private_data;
 709         params.private_data_len = conn_param->private_data_len;
 710         params.ird = conn_param->ird;
 711         params.ord = conn_param->ord;
 712
 713         ep->during_connect = 1;
 714         rc = dev->ops->iwarp_accept(dev->rdma_ctx, &params);
 715         if (rc)
 716                 goto err;
 717
 718         return rc;
 719 err:
 720         ep->during_connect = 0;
 721         cm_id->rem_ref(cm_id);
 722         return rc;
 723 }
 724
 725 int qedr_iw_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
 726 {
 727         struct qedr_iw_ep *ep = (struct qedr_iw_ep *)cm_id->provider_data;
 728         struct qedr_dev *dev = ep->dev;
 729         struct qed_iwarp_reject_in params;
 730
 731         params.ep_context = ep->qed_context;
 732         params.cb_context = ep;
 733         params.private_data = pdata;
 734         params.private_data_len = pdata_len;
 735         ep->qp = NULL;
 736
 737         return dev->ops->iwarp_reject(dev->rdma_ctx, &params);
 738 }
 739
 740 void qedr_iw_qp_add_ref(struct ib_qp *ibqp)
 741 {
 742         struct qedr_qp *qp = get_qedr_qp(ibqp);
 743
 744         atomic_inc(&qp->refcnt);
 745 }
 746
 747 void qedr_iw_qp_rem_ref(struct ib_qp *ibqp)
 748 {
 749         struct qedr_qp *qp = get_qedr_qp(ibqp);
 750
 751         if (atomic_dec_and_test(&qp->refcnt)) {
 752                 spin_lock_irq(&qp->dev->qpidr.idr_lock);
 753                 idr_remove(&qp->dev->qpidr.idr, qp->qp_id);
 754                 spin_unlock_irq(&qp->dev->qpidr.idr_lock);
 755                 kfree(qp);
 756         }
 757 }
 758
 759 struct ib_qp *qedr_iw_get_qp(struct ib_device *ibdev, int qpn)
 760 {
 761         struct qedr_dev *dev = get_qedr_dev(ibdev);
 762
 763         return idr_find(&dev->qpidr.idr, qpn);
 764 }