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
qedr_fill_sockaddr4(const struct qed_iwarp_cm_info * cm_info,struct iw_cm_event * event)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
qedr_fill_sockaddr6(const struct qed_iwarp_cm_info * cm_info,struct iw_cm_event * event)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
qedr_iw_mpa_request(void * context,struct qed_iwarp_cm_event_params * params)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
qedr_iw_issue_event(void * context,struct qed_iwarp_cm_event_params * params,enum iw_cm_event_type event_type)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
qedr_iw_close_event(void * context,struct qed_iwarp_cm_event_params * params)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
qedr_iw_qp_event(void * context,struct qed_iwarp_cm_event_params * params,enum ib_event_type ib_event,char * str)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
qedr_iw_disconnect_worker(struct work_struct * work)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
qedr_iw_disconnect_event(void * context,struct qed_iwarp_cm_event_params * params)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
qedr_iw_passive_complete(void * context,struct qed_iwarp_cm_event_params * params)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
qedr_iw_mpa_reply(void * context,struct qed_iwarp_cm_event_params * params)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
qedr_iw_event_handler(void * context,struct qed_iwarp_cm_event_params * params)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
qedr_iw_get_vlan_ipv4(struct qedr_dev * dev,u32 * addr)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
qedr_iw_get_vlan_ipv6(u32 * addr)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
qedr_addr4_resolve(struct qedr_dev * dev,struct sockaddr_in * src_in,struct sockaddr_in * dst_in,u8 * dst_mac)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
qedr_addr6_resolve(struct qedr_dev * dev,struct sockaddr_in6 * src_in,struct sockaddr_in6 * dst_in,u8 * dst_mac)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
qedr_iw_connect(struct iw_cm_id * cm_id,struct iw_cm_conn_param * conn_param)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
qedr_iw_create_listen(struct iw_cm_id * cm_id,int backlog)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
qedr_iw_destroy_listen(struct iw_cm_id * cm_id)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
qedr_iw_accept(struct iw_cm_id * cm_id,struct iw_cm_conn_param * conn_param)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, ¶ms);
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
qedr_iw_reject(struct iw_cm_id * cm_id,const void * pdata,u8 pdata_len)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, ¶ms);
738 }
739
qedr_iw_qp_add_ref(struct ib_qp * ibqp)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
qedr_iw_qp_rem_ref(struct ib_qp * ibqp)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
qedr_iw_get_qp(struct ib_device * ibdev,int qpn)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 }
765