| /* QLogic qedr NIC Driver |
| * Copyright (c) 2015-2017 QLogic Corporation |
| * |
| * This software is available to you under a choice of one of two |
| * licenses. You may choose to be licensed under the terms of the GNU |
| * General Public License (GPL) Version 2, available from the file |
| * COPYING in the main directory of this source tree, or the |
| * OpenIB.org BSD license below: |
| * |
| * Redistribution and use in source and binary forms, with or |
| * without modification, are permitted provided that the following |
| * conditions are met: |
| * |
| * - Redistributions of source code must retain the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and /or other materials |
| * provided with the distribution. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| */ |
| #include <net/ip.h> |
| #include <net/ipv6.h> |
| #include <net/udp.h> |
| #include <net/addrconf.h> |
| #include <net/route.h> |
| #include <net/ip6_route.h> |
| #include <net/flow.h> |
| #include "qedr.h" |
| #include "qedr_iw_cm.h" |
| |
| static inline void |
| qedr_fill_sockaddr4(const struct qed_iwarp_cm_info *cm_info, |
| struct iw_cm_event *event) |
| { |
| struct sockaddr_in *laddr = (struct sockaddr_in *)&event->local_addr; |
| struct sockaddr_in *raddr = (struct sockaddr_in *)&event->remote_addr; |
| |
| laddr->sin_family = AF_INET; |
| raddr->sin_family = AF_INET; |
| |
| laddr->sin_port = htons(cm_info->local_port); |
| raddr->sin_port = htons(cm_info->remote_port); |
| |
| laddr->sin_addr.s_addr = htonl(cm_info->local_ip[0]); |
| raddr->sin_addr.s_addr = htonl(cm_info->remote_ip[0]); |
| } |
| |
| static inline void |
| qedr_fill_sockaddr6(const struct qed_iwarp_cm_info *cm_info, |
| struct iw_cm_event *event) |
| { |
| struct sockaddr_in6 *laddr6 = (struct sockaddr_in6 *)&event->local_addr; |
| struct sockaddr_in6 *raddr6 = |
| (struct sockaddr_in6 *)&event->remote_addr; |
| int i; |
| |
| laddr6->sin6_family = AF_INET6; |
| raddr6->sin6_family = AF_INET6; |
| |
| laddr6->sin6_port = htons(cm_info->local_port); |
| raddr6->sin6_port = htons(cm_info->remote_port); |
| |
| for (i = 0; i < 4; i++) { |
| laddr6->sin6_addr.in6_u.u6_addr32[i] = |
| htonl(cm_info->local_ip[i]); |
| raddr6->sin6_addr.in6_u.u6_addr32[i] = |
| htonl(cm_info->remote_ip[i]); |
| } |
| } |
| |
| static void |
| qedr_iw_mpa_request(void *context, struct qed_iwarp_cm_event_params *params) |
| { |
| struct qedr_iw_listener *listener = (struct qedr_iw_listener *)context; |
| struct qedr_dev *dev = listener->dev; |
| struct iw_cm_event event; |
| struct qedr_iw_ep *ep; |
| |
| ep = kzalloc(sizeof(*ep), GFP_ATOMIC); |
| if (!ep) |
| return; |
| |
| ep->dev = dev; |
| ep->qed_context = params->ep_context; |
| |
| memset(&event, 0, sizeof(event)); |
| event.event = IW_CM_EVENT_CONNECT_REQUEST; |
| event.status = params->status; |
| |
| if (!IS_ENABLED(CONFIG_IPV6) || |
| params->cm_info->ip_version == QED_TCP_IPV4) |
| qedr_fill_sockaddr4(params->cm_info, &event); |
| else |
| qedr_fill_sockaddr6(params->cm_info, &event); |
| |
| event.provider_data = (void *)ep; |
| event.private_data = (void *)params->cm_info->private_data; |
| event.private_data_len = (u8)params->cm_info->private_data_len; |
| event.ord = params->cm_info->ord; |
| event.ird = params->cm_info->ird; |
| |
| listener->cm_id->event_handler(listener->cm_id, &event); |
| } |
| |
| static void |
| qedr_iw_issue_event(void *context, |
| struct qed_iwarp_cm_event_params *params, |
| enum iw_cm_event_type event_type) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| struct iw_cm_event event; |
| |
| memset(&event, 0, sizeof(event)); |
| event.status = params->status; |
| event.event = event_type; |
| |
| if (params->cm_info) { |
| event.ird = params->cm_info->ird; |
| event.ord = params->cm_info->ord; |
| event.private_data_len = params->cm_info->private_data_len; |
| event.private_data = (void *)params->cm_info->private_data; |
| } |
| |
| if (ep->cm_id) |
| ep->cm_id->event_handler(ep->cm_id, &event); |
| } |
| |
| static void |
| qedr_iw_close_event(void *context, struct qed_iwarp_cm_event_params *params) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| |
| if (ep->cm_id) { |
| qedr_iw_issue_event(context, params, IW_CM_EVENT_CLOSE); |
| |
| ep->cm_id->rem_ref(ep->cm_id); |
| ep->cm_id = NULL; |
| } |
| } |
| |
| static void |
| qedr_iw_qp_event(void *context, |
| struct qed_iwarp_cm_event_params *params, |
| enum ib_event_type ib_event, char *str) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| struct qedr_dev *dev = ep->dev; |
| struct ib_qp *ibqp = &ep->qp->ibqp; |
| struct ib_event event; |
| |
| DP_NOTICE(dev, "QP error received: %s\n", str); |
| |
| if (ibqp->event_handler) { |
| event.event = ib_event; |
| event.device = ibqp->device; |
| event.element.qp = ibqp; |
| ibqp->event_handler(&event, ibqp->qp_context); |
| } |
| } |
| |
| struct qedr_discon_work { |
| struct work_struct work; |
| struct qedr_iw_ep *ep; |
| enum qed_iwarp_event_type event; |
| int status; |
| }; |
| |
| static void qedr_iw_disconnect_worker(struct work_struct *work) |
| { |
| struct qedr_discon_work *dwork = |
| container_of(work, struct qedr_discon_work, work); |
| struct qed_rdma_modify_qp_in_params qp_params = { 0 }; |
| struct qedr_iw_ep *ep = dwork->ep; |
| struct qedr_dev *dev = ep->dev; |
| struct qedr_qp *qp = ep->qp; |
| struct iw_cm_event event; |
| |
| if (qp->destroyed) { |
| kfree(dwork); |
| qedr_iw_qp_rem_ref(&qp->ibqp); |
| return; |
| } |
| |
| memset(&event, 0, sizeof(event)); |
| event.status = dwork->status; |
| event.event = IW_CM_EVENT_DISCONNECT; |
| |
| /* Success means graceful disconnect was requested. modifying |
| * to SQD is translated to graceful disconnect. O/w reset is sent |
| */ |
| if (dwork->status) |
| qp_params.new_state = QED_ROCE_QP_STATE_ERR; |
| else |
| qp_params.new_state = QED_ROCE_QP_STATE_SQD; |
| |
| kfree(dwork); |
| |
| if (ep->cm_id) |
| ep->cm_id->event_handler(ep->cm_id, &event); |
| |
| SET_FIELD(qp_params.modify_flags, |
| QED_RDMA_MODIFY_QP_VALID_NEW_STATE, 1); |
| |
| dev->ops->rdma_modify_qp(dev->rdma_ctx, qp->qed_qp, &qp_params); |
| |
| qedr_iw_qp_rem_ref(&qp->ibqp); |
| } |
| |
| static void |
| qedr_iw_disconnect_event(void *context, |
| struct qed_iwarp_cm_event_params *params) |
| { |
| struct qedr_discon_work *work; |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| struct qedr_dev *dev = ep->dev; |
| struct qedr_qp *qp = ep->qp; |
| |
| work = kzalloc(sizeof(*work), GFP_ATOMIC); |
| if (!work) |
| return; |
| |
| qedr_iw_qp_add_ref(&qp->ibqp); |
| work->ep = ep; |
| work->event = params->event; |
| work->status = params->status; |
| |
| INIT_WORK(&work->work, qedr_iw_disconnect_worker); |
| queue_work(dev->iwarp_wq, &work->work); |
| } |
| |
| static void |
| qedr_iw_passive_complete(void *context, |
| struct qed_iwarp_cm_event_params *params) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| struct qedr_dev *dev = ep->dev; |
| |
| /* We will only reach the following state if MPA_REJECT was called on |
| * passive. In this case there will be no associated QP. |
| */ |
| if ((params->status == -ECONNREFUSED) && (!ep->qp)) { |
| DP_DEBUG(dev, QEDR_MSG_IWARP, |
| "PASSIVE connection refused releasing ep...\n"); |
| kfree(ep); |
| return; |
| } |
| |
| qedr_iw_issue_event(context, params, IW_CM_EVENT_ESTABLISHED); |
| |
| if (params->status < 0) |
| qedr_iw_close_event(context, params); |
| } |
| |
| static int |
| qedr_iw_mpa_reply(void *context, struct qed_iwarp_cm_event_params *params) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| struct qedr_dev *dev = ep->dev; |
| struct qed_iwarp_send_rtr_in rtr_in; |
| |
| rtr_in.ep_context = params->ep_context; |
| |
| return dev->ops->iwarp_send_rtr(dev->rdma_ctx, &rtr_in); |
| } |
| |
| static int |
| qedr_iw_event_handler(void *context, struct qed_iwarp_cm_event_params *params) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| struct qedr_dev *dev = ep->dev; |
| |
| switch (params->event) { |
| case QED_IWARP_EVENT_MPA_REQUEST: |
| qedr_iw_mpa_request(context, params); |
| break; |
| case QED_IWARP_EVENT_ACTIVE_MPA_REPLY: |
| qedr_iw_mpa_reply(context, params); |
| break; |
| case QED_IWARP_EVENT_PASSIVE_COMPLETE: |
| ep->during_connect = 0; |
| qedr_iw_passive_complete(context, params); |
| break; |
| |
| case QED_IWARP_EVENT_ACTIVE_COMPLETE: |
| ep->during_connect = 0; |
| qedr_iw_issue_event(context, |
| params, |
| IW_CM_EVENT_CONNECT_REPLY); |
| if (params->status < 0) { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)context; |
| |
| ep->cm_id->rem_ref(ep->cm_id); |
| ep->cm_id = NULL; |
| } |
| break; |
| case QED_IWARP_EVENT_DISCONNECT: |
| qedr_iw_disconnect_event(context, params); |
| break; |
| case QED_IWARP_EVENT_CLOSE: |
| ep->during_connect = 0; |
| qedr_iw_close_event(context, params); |
| break; |
| case QED_IWARP_EVENT_RQ_EMPTY: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL, |
| "QED_IWARP_EVENT_RQ_EMPTY"); |
| break; |
| case QED_IWARP_EVENT_IRQ_FULL: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL, |
| "QED_IWARP_EVENT_IRQ_FULL"); |
| break; |
| case QED_IWARP_EVENT_LLP_TIMEOUT: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL, |
| "QED_IWARP_EVENT_LLP_TIMEOUT"); |
| break; |
| case QED_IWARP_EVENT_REMOTE_PROTECTION_ERROR: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_ACCESS_ERR, |
| "QED_IWARP_EVENT_REMOTE_PROTECTION_ERROR"); |
| break; |
| case QED_IWARP_EVENT_CQ_OVERFLOW: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL, |
| "QED_IWARP_EVENT_CQ_OVERFLOW"); |
| break; |
| case QED_IWARP_EVENT_QP_CATASTROPHIC: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL, |
| "QED_IWARP_EVENT_QP_CATASTROPHIC"); |
| break; |
| case QED_IWARP_EVENT_LOCAL_ACCESS_ERROR: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_ACCESS_ERR, |
| "QED_IWARP_EVENT_LOCAL_ACCESS_ERROR"); |
| break; |
| case QED_IWARP_EVENT_REMOTE_OPERATION_ERROR: |
| qedr_iw_qp_event(context, params, IB_EVENT_QP_FATAL, |
| "QED_IWARP_EVENT_REMOTE_OPERATION_ERROR"); |
| break; |
| case QED_IWARP_EVENT_TERMINATE_RECEIVED: |
| DP_NOTICE(dev, "Got terminate message\n"); |
| break; |
| default: |
| DP_NOTICE(dev, "Unknown event received %d\n", params->event); |
| break; |
| }; |
| return 0; |
| } |
| |
| static u16 qedr_iw_get_vlan_ipv4(struct qedr_dev *dev, u32 *addr) |
| { |
| struct net_device *ndev; |
| u16 vlan_id = 0; |
| |
| ndev = ip_dev_find(&init_net, htonl(addr[0])); |
| |
| if (ndev) { |
| vlan_id = rdma_vlan_dev_vlan_id(ndev); |
| dev_put(ndev); |
| } |
| if (vlan_id == 0xffff) |
| vlan_id = 0; |
| return vlan_id; |
| } |
| |
| static u16 qedr_iw_get_vlan_ipv6(u32 *addr) |
| { |
| struct net_device *ndev = NULL; |
| struct in6_addr laddr6; |
| u16 vlan_id = 0; |
| int i; |
| |
| if (!IS_ENABLED(CONFIG_IPV6)) |
| return vlan_id; |
| |
| for (i = 0; i < 4; i++) |
| laddr6.in6_u.u6_addr32[i] = htonl(addr[i]); |
| |
| rcu_read_lock(); |
| for_each_netdev_rcu(&init_net, ndev) { |
| if (ipv6_chk_addr(&init_net, &laddr6, ndev, 1)) { |
| vlan_id = rdma_vlan_dev_vlan_id(ndev); |
| break; |
| } |
| } |
| |
| rcu_read_unlock(); |
| if (vlan_id == 0xffff) |
| vlan_id = 0; |
| |
| return vlan_id; |
| } |
| |
| static int |
| qedr_addr4_resolve(struct qedr_dev *dev, |
| struct sockaddr_in *src_in, |
| struct sockaddr_in *dst_in, u8 *dst_mac) |
| { |
| __be32 src_ip = src_in->sin_addr.s_addr; |
| __be32 dst_ip = dst_in->sin_addr.s_addr; |
| struct neighbour *neigh = NULL; |
| struct rtable *rt = NULL; |
| int rc = 0; |
| |
| rt = ip_route_output(&init_net, dst_ip, src_ip, 0, 0); |
| if (IS_ERR(rt)) { |
| DP_ERR(dev, "ip_route_output returned error\n"); |
| return -EINVAL; |
| } |
| |
| neigh = dst_neigh_lookup(&rt->dst, &dst_ip); |
| |
| if (neigh) { |
| rcu_read_lock(); |
| if (neigh->nud_state & NUD_VALID) { |
| ether_addr_copy(dst_mac, neigh->ha); |
| DP_DEBUG(dev, QEDR_MSG_QP, "mac_addr=[%pM]\n", dst_mac); |
| } else { |
| neigh_event_send(neigh, NULL); |
| } |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| } |
| |
| ip_rt_put(rt); |
| |
| return rc; |
| } |
| |
| static int |
| qedr_addr6_resolve(struct qedr_dev *dev, |
| struct sockaddr_in6 *src_in, |
| struct sockaddr_in6 *dst_in, u8 *dst_mac) |
| { |
| struct neighbour *neigh = NULL; |
| struct dst_entry *dst; |
| struct flowi6 fl6; |
| int rc = 0; |
| |
| memset(&fl6, 0, sizeof(fl6)); |
| fl6.daddr = dst_in->sin6_addr; |
| fl6.saddr = src_in->sin6_addr; |
| |
| dst = ip6_route_output(&init_net, NULL, &fl6); |
| |
| if ((!dst) || dst->error) { |
| if (dst) { |
| dst_release(dst); |
| DP_ERR(dev, |
| "ip6_route_output returned dst->error = %d\n", |
| dst->error); |
| } |
| return -EINVAL; |
| } |
| neigh = dst_neigh_lookup(dst, &dst_in); |
| |
| if (neigh) { |
| rcu_read_lock(); |
| if (neigh->nud_state & NUD_VALID) { |
| ether_addr_copy(dst_mac, neigh->ha); |
| DP_DEBUG(dev, QEDR_MSG_QP, "mac_addr=[%pM]\n", dst_mac); |
| } else { |
| neigh_event_send(neigh, NULL); |
| } |
| rcu_read_unlock(); |
| neigh_release(neigh); |
| } |
| |
| dst_release(dst); |
| |
| return rc; |
| } |
| |
| int qedr_iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param) |
| { |
| struct qedr_dev *dev = get_qedr_dev(cm_id->device); |
| struct qed_iwarp_connect_out out_params; |
| struct qed_iwarp_connect_in in_params; |
| struct qed_iwarp_cm_info *cm_info; |
| struct sockaddr_in6 *laddr6; |
| struct sockaddr_in6 *raddr6; |
| struct sockaddr_in *laddr; |
| struct sockaddr_in *raddr; |
| struct qedr_iw_ep *ep; |
| struct qedr_qp *qp; |
| int rc = 0; |
| int i; |
| |
| qp = idr_find(&dev->qpidr, conn_param->qpn); |
| |
| laddr = (struct sockaddr_in *)&cm_id->local_addr; |
| raddr = (struct sockaddr_in *)&cm_id->remote_addr; |
| laddr6 = (struct sockaddr_in6 *)&cm_id->local_addr; |
| raddr6 = (struct sockaddr_in6 *)&cm_id->remote_addr; |
| |
| DP_DEBUG(dev, QEDR_MSG_IWARP, |
| "Connect source address: %pISpc, remote address: %pISpc\n", |
| &cm_id->local_addr, &cm_id->remote_addr); |
| |
| if (!laddr->sin_port || !raddr->sin_port) |
| return -EINVAL; |
| |
| ep = kzalloc(sizeof(*ep), GFP_KERNEL); |
| if (!ep) |
| return -ENOMEM; |
| |
| ep->dev = dev; |
| ep->qp = qp; |
| qp->ep = ep; |
| cm_id->add_ref(cm_id); |
| ep->cm_id = cm_id; |
| |
| in_params.event_cb = qedr_iw_event_handler; |
| in_params.cb_context = ep; |
| |
| cm_info = &in_params.cm_info; |
| memset(cm_info->local_ip, 0, sizeof(cm_info->local_ip)); |
| memset(cm_info->remote_ip, 0, sizeof(cm_info->remote_ip)); |
| |
| if (!IS_ENABLED(CONFIG_IPV6) || |
| cm_id->remote_addr.ss_family == AF_INET) { |
| cm_info->ip_version = QED_TCP_IPV4; |
| |
| cm_info->remote_ip[0] = ntohl(raddr->sin_addr.s_addr); |
| cm_info->local_ip[0] = ntohl(laddr->sin_addr.s_addr); |
| cm_info->remote_port = ntohs(raddr->sin_port); |
| cm_info->local_port = ntohs(laddr->sin_port); |
| cm_info->vlan = qedr_iw_get_vlan_ipv4(dev, cm_info->local_ip); |
| |
| rc = qedr_addr4_resolve(dev, laddr, raddr, |
| (u8 *)in_params.remote_mac_addr); |
| |
| in_params.mss = dev->iwarp_max_mtu - |
| (sizeof(struct iphdr) + sizeof(struct tcphdr)); |
| |
| } else { |
| in_params.cm_info.ip_version = QED_TCP_IPV6; |
| |
| for (i = 0; i < 4; i++) { |
| cm_info->remote_ip[i] = |
| ntohl(raddr6->sin6_addr.in6_u.u6_addr32[i]); |
| cm_info->local_ip[i] = |
| ntohl(laddr6->sin6_addr.in6_u.u6_addr32[i]); |
| } |
| |
| cm_info->local_port = ntohs(laddr6->sin6_port); |
| cm_info->remote_port = ntohs(raddr6->sin6_port); |
| |
| in_params.mss = dev->iwarp_max_mtu - |
| (sizeof(struct ipv6hdr) + sizeof(struct tcphdr)); |
| |
| cm_info->vlan = qedr_iw_get_vlan_ipv6(cm_info->local_ip); |
| |
| rc = qedr_addr6_resolve(dev, laddr6, raddr6, |
| (u8 *)in_params.remote_mac_addr); |
| } |
| if (rc) |
| goto err; |
| |
| DP_DEBUG(dev, QEDR_MSG_IWARP, |
| "ord = %d ird=%d private_data=%p private_data_len=%d rq_psn=%d\n", |
| conn_param->ord, conn_param->ird, conn_param->private_data, |
| conn_param->private_data_len, qp->rq_psn); |
| |
| cm_info->ord = conn_param->ord; |
| cm_info->ird = conn_param->ird; |
| cm_info->private_data = conn_param->private_data; |
| cm_info->private_data_len = conn_param->private_data_len; |
| in_params.qp = qp->qed_qp; |
| memcpy(in_params.local_mac_addr, dev->ndev->dev_addr, ETH_ALEN); |
| |
| ep->during_connect = 1; |
| rc = dev->ops->iwarp_connect(dev->rdma_ctx, &in_params, &out_params); |
| if (rc) |
| goto err; |
| |
| return rc; |
| |
| err: |
| cm_id->rem_ref(cm_id); |
| kfree(ep); |
| return rc; |
| } |
| |
| int qedr_iw_create_listen(struct iw_cm_id *cm_id, int backlog) |
| { |
| struct qedr_dev *dev = get_qedr_dev(cm_id->device); |
| struct qedr_iw_listener *listener; |
| struct qed_iwarp_listen_in iparams; |
| struct qed_iwarp_listen_out oparams; |
| struct sockaddr_in *laddr; |
| struct sockaddr_in6 *laddr6; |
| int rc; |
| int i; |
| |
| laddr = (struct sockaddr_in *)&cm_id->local_addr; |
| laddr6 = (struct sockaddr_in6 *)&cm_id->local_addr; |
| |
| DP_DEBUG(dev, QEDR_MSG_IWARP, |
| "Create Listener address: %pISpc\n", &cm_id->local_addr); |
| |
| listener = kzalloc(sizeof(*listener), GFP_KERNEL); |
| if (!listener) |
| return -ENOMEM; |
| |
| listener->dev = dev; |
| cm_id->add_ref(cm_id); |
| listener->cm_id = cm_id; |
| listener->backlog = backlog; |
| |
| iparams.cb_context = listener; |
| iparams.event_cb = qedr_iw_event_handler; |
| iparams.max_backlog = backlog; |
| |
| if (!IS_ENABLED(CONFIG_IPV6) || |
| cm_id->local_addr.ss_family == AF_INET) { |
| iparams.ip_version = QED_TCP_IPV4; |
| memset(iparams.ip_addr, 0, sizeof(iparams.ip_addr)); |
| |
| iparams.ip_addr[0] = ntohl(laddr->sin_addr.s_addr); |
| iparams.port = ntohs(laddr->sin_port); |
| iparams.vlan = qedr_iw_get_vlan_ipv4(dev, iparams.ip_addr); |
| } else { |
| iparams.ip_version = QED_TCP_IPV6; |
| |
| for (i = 0; i < 4; i++) { |
| iparams.ip_addr[i] = |
| ntohl(laddr6->sin6_addr.in6_u.u6_addr32[i]); |
| } |
| |
| iparams.port = ntohs(laddr6->sin6_port); |
| |
| iparams.vlan = qedr_iw_get_vlan_ipv6(iparams.ip_addr); |
| } |
| rc = dev->ops->iwarp_create_listen(dev->rdma_ctx, &iparams, &oparams); |
| if (rc) |
| goto err; |
| |
| listener->qed_handle = oparams.handle; |
| cm_id->provider_data = listener; |
| return rc; |
| |
| err: |
| cm_id->rem_ref(cm_id); |
| kfree(listener); |
| return rc; |
| } |
| |
| int qedr_iw_destroy_listen(struct iw_cm_id *cm_id) |
| { |
| struct qedr_iw_listener *listener = cm_id->provider_data; |
| struct qedr_dev *dev = get_qedr_dev(cm_id->device); |
| int rc = 0; |
| |
| if (listener->qed_handle) |
| rc = dev->ops->iwarp_destroy_listen(dev->rdma_ctx, |
| listener->qed_handle); |
| |
| cm_id->rem_ref(cm_id); |
| return rc; |
| } |
| |
| int qedr_iw_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)cm_id->provider_data; |
| struct qedr_dev *dev = ep->dev; |
| struct qedr_qp *qp; |
| struct qed_iwarp_accept_in params; |
| int rc; |
| |
| DP_DEBUG(dev, QEDR_MSG_IWARP, "Accept on qpid=%d\n", conn_param->qpn); |
| |
| qp = idr_find(&dev->qpidr, conn_param->qpn); |
| if (!qp) { |
| DP_ERR(dev, "Invalid QP number %d\n", conn_param->qpn); |
| return -EINVAL; |
| } |
| |
| ep->qp = qp; |
| qp->ep = ep; |
| cm_id->add_ref(cm_id); |
| ep->cm_id = cm_id; |
| |
| params.ep_context = ep->qed_context; |
| params.cb_context = ep; |
| params.qp = ep->qp->qed_qp; |
| params.private_data = conn_param->private_data; |
| params.private_data_len = conn_param->private_data_len; |
| params.ird = conn_param->ird; |
| params.ord = conn_param->ord; |
| |
| ep->during_connect = 1; |
| rc = dev->ops->iwarp_accept(dev->rdma_ctx, ¶ms); |
| if (rc) |
| goto err; |
| |
| return rc; |
| err: |
| ep->during_connect = 0; |
| cm_id->rem_ref(cm_id); |
| return rc; |
| } |
| |
| int qedr_iw_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len) |
| { |
| struct qedr_iw_ep *ep = (struct qedr_iw_ep *)cm_id->provider_data; |
| struct qedr_dev *dev = ep->dev; |
| struct qed_iwarp_reject_in params; |
| |
| params.ep_context = ep->qed_context; |
| params.cb_context = ep; |
| params.private_data = pdata; |
| params.private_data_len = pdata_len; |
| ep->qp = NULL; |
| |
| return dev->ops->iwarp_reject(dev->rdma_ctx, ¶ms); |
| } |
| |
| void qedr_iw_qp_add_ref(struct ib_qp *ibqp) |
| { |
| struct qedr_qp *qp = get_qedr_qp(ibqp); |
| |
| atomic_inc(&qp->refcnt); |
| } |
| |
| void qedr_iw_qp_rem_ref(struct ib_qp *ibqp) |
| { |
| struct qedr_qp *qp = get_qedr_qp(ibqp); |
| |
| if (atomic_dec_and_test(&qp->refcnt)) { |
| spin_lock_irq(&qp->dev->idr_lock); |
| idr_remove(&qp->dev->qpidr, qp->qp_id); |
| spin_unlock_irq(&qp->dev->idr_lock); |
| kfree(qp); |
| } |
| } |
| |
| struct ib_qp *qedr_iw_get_qp(struct ib_device *ibdev, int qpn) |
| { |
| struct qedr_dev *dev = get_qedr_dev(ibdev); |
| |
| return idr_find(&dev->qpidr, qpn); |
| } |