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 = xa_load(&dev->qps, 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 = xa_load(&dev->qps, 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, &params);
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, &params);
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 		xa_erase_irq(&qp->dev->qps, qp->qp_id);
743 		kfree(qp);
744 	}
745 }
746 
747 struct ib_qp *qedr_iw_get_qp(struct ib_device *ibdev, int qpn)
748 {
749 	struct qedr_dev *dev = get_qedr_dev(ibdev);
750 
751 	return xa_load(&dev->qps, qpn);
752 }
753