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