?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/tests: hdmi: Fix memory leaks in drm_display_mode_from_cea_vic()
[drm/drm-misc.git] / drivers / scsi / qla2xxx / qla_nvme.c
blob8f4cc136a9c9c46f5f2d5408f9b7688ef520a8a3
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * QLogic Fibre Channel HBA Driver
4 * Copyright (c) 2003-2017 QLogic Corporation
5 */
6 #include "qla_nvme.h"
7 #include <linux/scatterlist.h>
8 #include <linux/delay.h>
9 #include <linux/nvme.h>
10 #include <linux/nvme-fc.h>
11 #include <linux/blk-mq-pci.h>
12 #include <linux/blk-mq.h>
13
14 static struct nvme_fc_port_template qla_nvme_fc_transport;
15 static int qla_nvme_ls_reject_iocb(struct scsi_qla_host *vha,
16 struct qla_qpair *qp,
17 struct qla_nvme_lsrjt_pt_arg *a,
18 bool is_xchg_terminate);
19
20 struct qla_nvme_unsol_ctx {
21 struct list_head elem;
22 struct scsi_qla_host *vha;
23 struct fc_port *fcport;
24 struct srb *sp;
25 struct nvmefc_ls_rsp lsrsp;
26 struct nvmefc_ls_rsp *fd_rsp;
27 struct work_struct lsrsp_work;
28 struct work_struct abort_work;
29 __le32 exchange_address;
30 __le16 nport_handle;
31 __le16 ox_id;
32 int comp_status;
33 spinlock_t cmd_lock;
34 };
35
36 int qla_nvme_register_remote(struct scsi_qla_host *vha, struct fc_port *fcport)
37 {
38 struct qla_nvme_rport *rport;
39 struct nvme_fc_port_info req;
40 int ret;
41
42 if (!IS_ENABLED(CONFIG_NVME_FC))
43 return 0;
44
45 if (!vha->flags.nvme_enabled) {
46 ql_log(ql_log_info, vha, 0x2100,
47 "%s: Not registering target since Host NVME is not enabled\n",
48 __func__);
49 return 0;
50 }
51
52 if (qla_nvme_register_hba(vha))
53 return 0;
54
55 if (!vha->nvme_local_port)
56 return 0;
57
58 if (!(fcport->nvme_prli_service_param &
59 (NVME_PRLI_SP_TARGET | NVME_PRLI_SP_DISCOVERY)) ||
60 (fcport->nvme_flag & NVME_FLAG_REGISTERED))
61 return 0;
62
63 fcport->nvme_flag &= ~NVME_FLAG_RESETTING;
64
65 memset(&req, 0, sizeof(struct nvme_fc_port_info));
66 req.port_name = wwn_to_u64(fcport->port_name);
67 req.node_name = wwn_to_u64(fcport->node_name);
68 req.port_role = 0;
69 req.dev_loss_tmo = fcport->dev_loss_tmo;
70
71 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_INITIATOR)
72 req.port_role = FC_PORT_ROLE_NVME_INITIATOR;
73
74 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_TARGET)
75 req.port_role |= FC_PORT_ROLE_NVME_TARGET;
76
77 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_DISCOVERY)
78 req.port_role |= FC_PORT_ROLE_NVME_DISCOVERY;
79
80 req.port_id = fcport->d_id.b24;
81
82 ql_log(ql_log_info, vha, 0x2102,
83 "%s: traddr=nn-0x%016llx:pn-0x%016llx PortID:%06x\n",
84 __func__, req.node_name, req.port_name,
85 req.port_id);
86
87 ret = nvme_fc_register_remoteport(vha->nvme_local_port, &req,
88 &fcport->nvme_remote_port);
89 if (ret) {
90 ql_log(ql_log_warn, vha, 0x212e,
91 "Failed to register remote port. Transport returned %d\n",
92 ret);
93 return ret;
94 }
95
96 nvme_fc_set_remoteport_devloss(fcport->nvme_remote_port,
97 fcport->dev_loss_tmo);
98
99 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_SLER)
100 ql_log(ql_log_info, vha, 0x212a,
101 "PortID:%06x Supports SLER\n", req.port_id);
102
103 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_PI_CTRL)
104 ql_log(ql_log_info, vha, 0x212b,
105 "PortID:%06x Supports PI control\n", req.port_id);
106
107 rport = fcport->nvme_remote_port->private;
108 rport->fcport = fcport;
109
110 fcport->nvme_flag |= NVME_FLAG_REGISTERED;
111 return 0;
112 }
113
114 /* Allocate a queue for NVMe traffic */
115 static int qla_nvme_alloc_queue(struct nvme_fc_local_port *lport,
116 unsigned int qidx, u16 qsize, void **handle)
117 {
118 struct scsi_qla_host *vha;
119 struct qla_hw_data *ha;
120 struct qla_qpair *qpair;
121
122 /* Map admin queue and 1st IO queue to index 0 */
123 if (qidx)
124 qidx--;
125
126 vha = (struct scsi_qla_host *)lport->private;
127 ha = vha->hw;
128
129 ql_log(ql_log_info, vha, 0x2104,
130 "%s: handle %p, idx =%d, qsize %d\n",
131 __func__, handle, qidx, qsize);
132
133 if (qidx > qla_nvme_fc_transport.max_hw_queues) {
134 ql_log(ql_log_warn, vha, 0x212f,
135 "%s: Illegal qidx=%d. Max=%d\n",
136 __func__, qidx, qla_nvme_fc_transport.max_hw_queues);
137 return -EINVAL;
138 }
139
140 /* Use base qpair if max_qpairs is 0 */
141 if (!ha->max_qpairs) {
142 qpair = ha->base_qpair;
143 } else {
144 if (ha->queue_pair_map[qidx]) {
145 *handle = ha->queue_pair_map[qidx];
146 ql_log(ql_log_info, vha, 0x2121,
147 "Returning existing qpair of %p for idx=%x\n",
148 *handle, qidx);
149 return 0;
150 }
151
152 qpair = qla2xxx_create_qpair(vha, 5, vha->vp_idx, true);
153 if (!qpair) {
154 ql_log(ql_log_warn, vha, 0x2122,
155 "Failed to allocate qpair\n");
156 return -EINVAL;
157 }
158 qla_adjust_iocb_limit(vha);
159 }
160 *handle = qpair;
161
162 return 0;
163 }
164
165 static void qla_nvme_release_fcp_cmd_kref(struct kref *kref)
166 {
167 struct srb *sp = container_of(kref, struct srb, cmd_kref);
168 struct nvme_private *priv = (struct nvme_private *)sp->priv;
169 struct nvmefc_fcp_req *fd;
170 struct srb_iocb *nvme;
171 unsigned long flags;
172
173 if (!priv)
174 goto out;
175
176 nvme = &sp->u.iocb_cmd;
177 fd = nvme->u.nvme.desc;
178
179 spin_lock_irqsave(&priv->cmd_lock, flags);
180 priv->sp = NULL;
181 sp->priv = NULL;
182 if (priv->comp_status == QLA_SUCCESS) {
183 fd->rcv_rsplen = le16_to_cpu(nvme->u.nvme.rsp_pyld_len);
184 fd->status = NVME_SC_SUCCESS;
185 } else {
186 fd->rcv_rsplen = 0;
187 fd->transferred_length = 0;
188 fd->status = NVME_SC_INTERNAL;
189 }
190 spin_unlock_irqrestore(&priv->cmd_lock, flags);
191
192 fd->done(fd);
193 out:
194 qla2xxx_rel_qpair_sp(sp->qpair, sp);
195 }
196
197 static void qla_nvme_release_ls_cmd_kref(struct kref *kref)
198 {
199 struct srb *sp = container_of(kref, struct srb, cmd_kref);
200 struct nvme_private *priv = (struct nvme_private *)sp->priv;
201 struct nvmefc_ls_req *fd;
202 unsigned long flags;
203
204 if (!priv)
205 goto out;
206
207 spin_lock_irqsave(&priv->cmd_lock, flags);
208 priv->sp = NULL;
209 sp->priv = NULL;
210 spin_unlock_irqrestore(&priv->cmd_lock, flags);
211
212 fd = priv->fd;
213
214 fd->done(fd, priv->comp_status);
215 out:
216 qla2x00_rel_sp(sp);
217 }
218
219 static void qla_nvme_ls_complete(struct work_struct *work)
220 {
221 struct nvme_private *priv =
222 container_of(work, struct nvme_private, ls_work);
223
224 kref_put(&priv->sp->cmd_kref, qla_nvme_release_ls_cmd_kref);
225 }
226
227 static void qla_nvme_sp_ls_done(srb_t *sp, int res)
228 {
229 struct nvme_private *priv = sp->priv;
230
231 if (WARN_ON_ONCE(kref_read(&sp->cmd_kref) == 0))
232 return;
233
234 if (res)
235 res = -EINVAL;
236
237 priv->comp_status = res;
238 INIT_WORK(&priv->ls_work, qla_nvme_ls_complete);
239 schedule_work(&priv->ls_work);
240 }
241
242 static void qla_nvme_release_lsrsp_cmd_kref(struct kref *kref)
243 {
244 struct srb *sp = container_of(kref, struct srb, cmd_kref);
245 struct qla_nvme_unsol_ctx *uctx = sp->priv;
246 struct nvmefc_ls_rsp *fd_rsp;
247 unsigned long flags;
248
249 if (!uctx) {
250 qla2x00_rel_sp(sp);
251 return;
252 }
253
254 spin_lock_irqsave(&uctx->cmd_lock, flags);
255 uctx->sp = NULL;
256 sp->priv = NULL;
257 spin_unlock_irqrestore(&uctx->cmd_lock, flags);
258
259 fd_rsp = uctx->fd_rsp;
260
261 list_del(&uctx->elem);
262
263 fd_rsp->done(fd_rsp);
264 kfree(uctx);
265 qla2x00_rel_sp(sp);
266 }
267
268 static void qla_nvme_lsrsp_complete(struct work_struct *work)
269 {
270 struct qla_nvme_unsol_ctx *uctx =
271 container_of(work, struct qla_nvme_unsol_ctx, lsrsp_work);
272
273 kref_put(&uctx->sp->cmd_kref, qla_nvme_release_lsrsp_cmd_kref);
274 }
275
276 static void qla_nvme_sp_lsrsp_done(srb_t *sp, int res)
277 {
278 struct qla_nvme_unsol_ctx *uctx = sp->priv;
279
280 if (WARN_ON_ONCE(kref_read(&sp->cmd_kref) == 0))
281 return;
282
283 if (res)
284 res = -EINVAL;
285
286 uctx->comp_status = res;
287 INIT_WORK(&uctx->lsrsp_work, qla_nvme_lsrsp_complete);
288 schedule_work(&uctx->lsrsp_work);
289 }
290
291 /* it assumed that QPair lock is held. */
292 static void qla_nvme_sp_done(srb_t *sp, int res)
293 {
294 struct nvme_private *priv = sp->priv;
295
296 priv->comp_status = res;
297 kref_put(&sp->cmd_kref, qla_nvme_release_fcp_cmd_kref);
298
299 return;
300 }
301
302 static void qla_nvme_abort_work(struct work_struct *work)
303 {
304 struct nvme_private *priv =
305 container_of(work, struct nvme_private, abort_work);
306 srb_t *sp = priv->sp;
307 fc_port_t *fcport = sp->fcport;
308 struct qla_hw_data *ha = fcport->vha->hw;
309 int rval, abts_done_called = 1;
310 bool io_wait_for_abort_done;
311 uint32_t handle;
312
313 ql_dbg(ql_dbg_io, fcport->vha, 0xffff,
314 "%s called for sp=%p, hndl=%x on fcport=%p desc=%p deleted=%d\n",
315 __func__, sp, sp->handle, fcport, sp->u.iocb_cmd.u.nvme.desc, fcport->deleted);
316
317 if (!ha->flags.fw_started || fcport->deleted == QLA_SESS_DELETED)
318 goto out;
319
320 if (ha->flags.host_shutting_down) {
321 ql_log(ql_log_info, sp->fcport->vha, 0xffff,
322 "%s Calling done on sp: %p, type: 0x%x\n",
323 __func__, sp, sp->type);
324 sp->done(sp, 0);
325 goto out;
326 }
327
328 /*
329 * sp may not be valid after abort_command if return code is either
330 * SUCCESS or ERR_FROM_FW codes, so cache the value here.
331 */
332 io_wait_for_abort_done = ql2xabts_wait_nvme &&
333 QLA_ABTS_WAIT_ENABLED(sp);
334 handle = sp->handle;
335
336 rval = ha->isp_ops->abort_command(sp);
337
338 ql_dbg(ql_dbg_io, fcport->vha, 0x212b,
339 "%s: %s command for sp=%p, handle=%x on fcport=%p rval=%x\n",
340 __func__, (rval != QLA_SUCCESS) ? "Failed to abort" : "Aborted",
341 sp, handle, fcport, rval);
342
343 /*
344 * If async tmf is enabled, the abort callback is called only on
345 * return codes QLA_SUCCESS and QLA_ERR_FROM_FW.
346 */
347 if (ql2xasynctmfenable &&
348 rval != QLA_SUCCESS && rval != QLA_ERR_FROM_FW)
349 abts_done_called = 0;
350
351 /*
352 * Returned before decreasing kref so that I/O requests
353 * are waited until ABTS complete. This kref is decreased
354 * at qla24xx_abort_sp_done function.
355 */
356 if (abts_done_called && io_wait_for_abort_done)
357 return;
358 out:
359 /* kref_get was done before work was schedule. */
360 kref_put(&sp->cmd_kref, sp->put_fn);
361 }
362
363 static int qla_nvme_xmt_ls_rsp(struct nvme_fc_local_port *lport,
364 struct nvme_fc_remote_port *rport,
365 struct nvmefc_ls_rsp *fd_resp)
366 {
367 struct qla_nvme_unsol_ctx *uctx = container_of(fd_resp,
368 struct qla_nvme_unsol_ctx, lsrsp);
369 struct qla_nvme_rport *qla_rport = rport->private;
370 fc_port_t *fcport = qla_rport->fcport;
371 struct scsi_qla_host *vha = uctx->vha;
372 struct qla_hw_data *ha = vha->hw;
373 struct qla_nvme_lsrjt_pt_arg a;
374 struct srb_iocb *nvme;
375 srb_t *sp;
376 int rval = QLA_FUNCTION_FAILED;
377 uint8_t cnt = 0;
378
379 if (!fcport || fcport->deleted)
380 goto out;
381
382 if (!ha->flags.fw_started)
383 goto out;
384
385 /* Alloc SRB structure */
386 sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
387 if (!sp)
388 goto out;
389
390 sp->type = SRB_NVME_LS;
391 sp->name = "nvme_ls";
392 sp->done = qla_nvme_sp_lsrsp_done;
393 sp->put_fn = qla_nvme_release_lsrsp_cmd_kref;
394 sp->priv = (void *)uctx;
395 sp->unsol_rsp = 1;
396 uctx->sp = sp;
397 spin_lock_init(&uctx->cmd_lock);
398 nvme = &sp->u.iocb_cmd;
399 uctx->fd_rsp = fd_resp;
400 nvme->u.nvme.desc = fd_resp;
401 nvme->u.nvme.dir = 0;
402 nvme->u.nvme.dl = 0;
403 nvme->u.nvme.timeout_sec = 0;
404 nvme->u.nvme.cmd_dma = fd_resp->rspdma;
405 nvme->u.nvme.cmd_len = cpu_to_le32(fd_resp->rsplen);
406 nvme->u.nvme.rsp_len = 0;
407 nvme->u.nvme.rsp_dma = 0;
408 nvme->u.nvme.exchange_address = uctx->exchange_address;
409 nvme->u.nvme.nport_handle = uctx->nport_handle;
410 nvme->u.nvme.ox_id = uctx->ox_id;
411 dma_sync_single_for_device(&ha->pdev->dev, nvme->u.nvme.cmd_dma,
412 fd_resp->rsplen, DMA_TO_DEVICE);
413
414 ql_dbg(ql_dbg_unsol, vha, 0x2122,
415 "Unsol lsreq portid=%06x %8phC exchange_address 0x%x ox_id 0x%x hdl 0x%x\n",
416 fcport->d_id.b24, fcport->port_name, uctx->exchange_address,
417 uctx->ox_id, uctx->nport_handle);
418 retry:
419 rval = qla2x00_start_sp(sp);
420 switch (rval) {
421 case QLA_SUCCESS:
422 break;
423 case EAGAIN:
424 msleep(PURLS_MSLEEP_INTERVAL);
425 cnt++;
426 if (cnt < PURLS_RETRY_COUNT)
427 goto retry;
428
429 fallthrough;
430 default:
431 ql_dbg(ql_log_warn, vha, 0x2123,
432 "Failed to xmit Unsol ls response = %d\n", rval);
433 rval = -EIO;
434 qla2x00_rel_sp(sp);
435 goto out;
436 }
437
438 return 0;
439 out:
440 memset((void *)&a, 0, sizeof(a));
441 a.vp_idx = vha->vp_idx;
442 a.nport_handle = uctx->nport_handle;
443 a.xchg_address = uctx->exchange_address;
444 qla_nvme_ls_reject_iocb(vha, ha->base_qpair, &a, true);
445 kfree(uctx);
446 return rval;
447 }
448
449 static void qla_nvme_ls_abort(struct nvme_fc_local_port *lport,
450 struct nvme_fc_remote_port *rport, struct nvmefc_ls_req *fd)
451 {
452 struct nvme_private *priv = fd->private;
453 unsigned long flags;
454
455 spin_lock_irqsave(&priv->cmd_lock, flags);
456 if (!priv->sp) {
457 spin_unlock_irqrestore(&priv->cmd_lock, flags);
458 return;
459 }
460
461 if (!kref_get_unless_zero(&priv->sp->cmd_kref)) {
462 spin_unlock_irqrestore(&priv->cmd_lock, flags);
463 return;
464 }
465 spin_unlock_irqrestore(&priv->cmd_lock, flags);
466
467 INIT_WORK(&priv->abort_work, qla_nvme_abort_work);
468 schedule_work(&priv->abort_work);
469 }
470
471 static int qla_nvme_ls_req(struct nvme_fc_local_port *lport,
472 struct nvme_fc_remote_port *rport, struct nvmefc_ls_req *fd)
473 {
474 struct qla_nvme_rport *qla_rport = rport->private;
475 fc_port_t *fcport = qla_rport->fcport;
476 struct srb_iocb *nvme;
477 struct nvme_private *priv = fd->private;
478 struct scsi_qla_host *vha;
479 int rval = QLA_FUNCTION_FAILED;
480 struct qla_hw_data *ha;
481 srb_t *sp;
482
483 if (!fcport || fcport->deleted)
484 return rval;
485
486 vha = fcport->vha;
487 ha = vha->hw;
488
489 if (!ha->flags.fw_started)
490 return rval;
491
492 /* Alloc SRB structure */
493 sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
494 if (!sp)
495 return rval;
496
497 sp->type = SRB_NVME_LS;
498 sp->name = "nvme_ls";
499 sp->done = qla_nvme_sp_ls_done;
500 sp->put_fn = qla_nvme_release_ls_cmd_kref;
501 sp->priv = priv;
502 priv->sp = sp;
503 kref_init(&sp->cmd_kref);
504 spin_lock_init(&priv->cmd_lock);
505 nvme = &sp->u.iocb_cmd;
506 priv->fd = fd;
507 nvme->u.nvme.desc = fd;
508 nvme->u.nvme.dir = 0;
509 nvme->u.nvme.dl = 0;
510 nvme->u.nvme.cmd_len = cpu_to_le32(fd->rqstlen);
511 nvme->u.nvme.rsp_len = cpu_to_le32(fd->rsplen);
512 nvme->u.nvme.rsp_dma = fd->rspdma;
513 nvme->u.nvme.timeout_sec = fd->timeout;
514 nvme->u.nvme.cmd_dma = fd->rqstdma;
515 dma_sync_single_for_device(&ha->pdev->dev, nvme->u.nvme.cmd_dma,
516 fd->rqstlen, DMA_TO_DEVICE);
517
518 rval = qla2x00_start_sp(sp);
519 if (rval != QLA_SUCCESS) {
520 ql_log(ql_log_warn, vha, 0x700e,
521 "qla2x00_start_sp failed = %d\n", rval);
522 sp->priv = NULL;
523 priv->sp = NULL;
524 qla2x00_rel_sp(sp);
525 return rval;
526 }
527
528 return rval;
529 }
530
531 static void qla_nvme_fcp_abort(struct nvme_fc_local_port *lport,
532 struct nvme_fc_remote_port *rport, void *hw_queue_handle,
533 struct nvmefc_fcp_req *fd)
534 {
535 struct nvme_private *priv = fd->private;
536 unsigned long flags;
537
538 spin_lock_irqsave(&priv->cmd_lock, flags);
539 if (!priv->sp) {
540 spin_unlock_irqrestore(&priv->cmd_lock, flags);
541 return;
542 }
543 if (!kref_get_unless_zero(&priv->sp->cmd_kref)) {
544 spin_unlock_irqrestore(&priv->cmd_lock, flags);
545 return;
546 }
547 spin_unlock_irqrestore(&priv->cmd_lock, flags);
548
549 INIT_WORK(&priv->abort_work, qla_nvme_abort_work);
550 schedule_work(&priv->abort_work);
551 }
552
553 static inline int qla2x00_start_nvme_mq(srb_t *sp)
554 {
555 unsigned long flags;
556 uint32_t *clr_ptr;
557 uint32_t handle;
558 struct cmd_nvme *cmd_pkt;
559 uint16_t cnt, i;
560 uint16_t req_cnt;
561 uint16_t tot_dsds;
562 uint16_t avail_dsds;
563 struct dsd64 *cur_dsd;
564 struct req_que *req = NULL;
565 struct rsp_que *rsp = NULL;
566 struct scsi_qla_host *vha = sp->fcport->vha;
567 struct qla_hw_data *ha = vha->hw;
568 struct qla_qpair *qpair = sp->qpair;
569 struct srb_iocb *nvme = &sp->u.iocb_cmd;
570 struct scatterlist *sgl, *sg;
571 struct nvmefc_fcp_req *fd = nvme->u.nvme.desc;
572 struct nvme_fc_cmd_iu *cmd = fd->cmdaddr;
573 uint32_t rval = QLA_SUCCESS;
574
575 /* Setup qpair pointers */
576 req = qpair->req;
577 rsp = qpair->rsp;
578 tot_dsds = fd->sg_cnt;
579
580 /* Acquire qpair specific lock */
581 spin_lock_irqsave(&qpair->qp_lock, flags);
582
583 handle = qla2xxx_get_next_handle(req);
584 if (handle == 0) {
585 rval = -EBUSY;
586 goto queuing_error;
587 }
588 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
589
590 sp->iores.res_type = RESOURCE_IOCB | RESOURCE_EXCH;
591 sp->iores.exch_cnt = 1;
592 sp->iores.iocb_cnt = req_cnt;
593 if (qla_get_fw_resources(sp->qpair, &sp->iores)) {
594 rval = -EBUSY;
595 goto queuing_error;
596 }
597
598 if (req->cnt < (req_cnt + 2)) {
599 if (IS_SHADOW_REG_CAPABLE(ha)) {
600 cnt = *req->out_ptr;
601 } else {
602 cnt = rd_reg_dword_relaxed(req->req_q_out);
603 if (qla2x00_check_reg16_for_disconnect(vha, cnt)) {
604 rval = -EBUSY;
605 goto queuing_error;
606 }
607 }
608
609 if (req->ring_index < cnt)
610 req->cnt = cnt - req->ring_index;
611 else
612 req->cnt = req->length - (req->ring_index - cnt);
613
614 if (req->cnt < (req_cnt + 2)){
615 rval = -EBUSY;
616 goto queuing_error;
617 }
618 }
619
620 if (unlikely(!fd->sqid)) {
621 if (cmd->sqe.common.opcode == nvme_admin_async_event) {
622 nvme->u.nvme.aen_op = 1;
623 atomic_inc(&ha->nvme_active_aen_cnt);
624 }
625 }
626
627 /* Build command packet. */
628 req->current_outstanding_cmd = handle;
629 req->outstanding_cmds[handle] = sp;
630 sp->handle = handle;
631 req->cnt -= req_cnt;
632
633 cmd_pkt = (struct cmd_nvme *)req->ring_ptr;
634 cmd_pkt->handle = make_handle(req->id, handle);
635
636 /* Zero out remaining portion of packet. */
637 clr_ptr = (uint32_t *)cmd_pkt + 2;
638 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
639
640 cmd_pkt->entry_status = 0;
641
642 /* Update entry type to indicate Command NVME IOCB */
643 cmd_pkt->entry_type = COMMAND_NVME;
644
645 /* No data transfer how do we check buffer len == 0?? */
646 if (fd->io_dir == NVMEFC_FCP_READ) {
647 cmd_pkt->control_flags = cpu_to_le16(CF_READ_DATA);
648 qpair->counters.input_bytes += fd->payload_length;
649 qpair->counters.input_requests++;
650 } else if (fd->io_dir == NVMEFC_FCP_WRITE) {
651 cmd_pkt->control_flags = cpu_to_le16(CF_WRITE_DATA);
652 if ((vha->flags.nvme_first_burst) &&
653 (sp->fcport->nvme_prli_service_param &
654 NVME_PRLI_SP_FIRST_BURST)) {
655 if ((fd->payload_length <=
656 sp->fcport->nvme_first_burst_size) ||
657 (sp->fcport->nvme_first_burst_size == 0))
658 cmd_pkt->control_flags |=
659 cpu_to_le16(CF_NVME_FIRST_BURST_ENABLE);
660 }
661 qpair->counters.output_bytes += fd->payload_length;
662 qpair->counters.output_requests++;
663 } else if (fd->io_dir == 0) {
664 cmd_pkt->control_flags = 0;
665 }
666
667 if (sp->fcport->edif.enable && fd->io_dir != 0)
668 cmd_pkt->control_flags |= cpu_to_le16(CF_EN_EDIF);
669
670 /* Set BIT_13 of control flags for Async event */
671 if (vha->flags.nvme2_enabled &&
672 cmd->sqe.common.opcode == nvme_admin_async_event) {
673 cmd_pkt->control_flags |= cpu_to_le16(CF_ADMIN_ASYNC_EVENT);
674 }
675
676 /* Set NPORT-ID */
677 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
678 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
679 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
680 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
681 cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
682
683 /* NVME RSP IU */
684 cmd_pkt->nvme_rsp_dsd_len = cpu_to_le16(fd->rsplen);
685 put_unaligned_le64(fd->rspdma, &cmd_pkt->nvme_rsp_dseg_address);
686
687 /* NVME CNMD IU */
688 cmd_pkt->nvme_cmnd_dseg_len = cpu_to_le16(fd->cmdlen);
689 cmd_pkt->nvme_cmnd_dseg_address = cpu_to_le64(fd->cmddma);
690
691 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
692 cmd_pkt->byte_count = cpu_to_le32(fd->payload_length);
693
694 /* One DSD is available in the Command Type NVME IOCB */
695 avail_dsds = 1;
696 cur_dsd = &cmd_pkt->nvme_dsd;
697 sgl = fd->first_sgl;
698
699 /* Load data segments */
700 for_each_sg(sgl, sg, tot_dsds, i) {
701 cont_a64_entry_t *cont_pkt;
702
703 /* Allocate additional continuation packets? */
704 if (avail_dsds == 0) {
705 /*
706 * Five DSDs are available in the Continuation
707 * Type 1 IOCB.
708 */
709
710 /* Adjust ring index */
711 req->ring_index++;
712 if (req->ring_index == req->length) {
713 req->ring_index = 0;
714 req->ring_ptr = req->ring;
715 } else {
716 req->ring_ptr++;
717 }
718 cont_pkt = (cont_a64_entry_t *)req->ring_ptr;
719 put_unaligned_le32(CONTINUE_A64_TYPE,
720 &cont_pkt->entry_type);
721
722 cur_dsd = cont_pkt->dsd;
723 avail_dsds = ARRAY_SIZE(cont_pkt->dsd);
724 }
725
726 append_dsd64(&cur_dsd, sg);
727 avail_dsds--;
728 }
729
730 /* Set total entry count. */
731 cmd_pkt->entry_count = (uint8_t)req_cnt;
732 wmb();
733
734 /* Adjust ring index. */
735 req->ring_index++;
736 if (req->ring_index == req->length) {
737 req->ring_index = 0;
738 req->ring_ptr = req->ring;
739 } else {
740 req->ring_ptr++;
741 }
742
743 /* ignore nvme async cmd due to long timeout */
744 if (!nvme->u.nvme.aen_op)
745 sp->qpair->cmd_cnt++;
746
747 /* Set chip new ring index. */
748 wrt_reg_dword(req->req_q_in, req->ring_index);
749
750 if (vha->flags.process_response_queue &&
751 rsp->ring_ptr->signature != RESPONSE_PROCESSED)
752 qla24xx_process_response_queue(vha, rsp);
753
754 queuing_error:
755 if (rval)
756 qla_put_fw_resources(sp->qpair, &sp->iores);
757 spin_unlock_irqrestore(&qpair->qp_lock, flags);
758
759 return rval;
760 }
761
762 /* Post a command */
763 static int qla_nvme_post_cmd(struct nvme_fc_local_port *lport,
764 struct nvme_fc_remote_port *rport, void *hw_queue_handle,
765 struct nvmefc_fcp_req *fd)
766 {
767 fc_port_t *fcport;
768 struct srb_iocb *nvme;
769 struct scsi_qla_host *vha;
770 struct qla_hw_data *ha;
771 int rval;
772 srb_t *sp;
773 struct qla_qpair *qpair = hw_queue_handle;
774 struct nvme_private *priv = fd->private;
775 struct qla_nvme_rport *qla_rport = rport->private;
776
777 if (!priv) {
778 /* nvme association has been torn down */
779 return -ENODEV;
780 }
781
782 fcport = qla_rport->fcport;
783
784 if (unlikely(!qpair || !fcport || fcport->deleted))
785 return -EBUSY;
786
787 if (!(fcport->nvme_flag & NVME_FLAG_REGISTERED))
788 return -ENODEV;
789
790 vha = fcport->vha;
791 ha = vha->hw;
792
793 if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
794 return -EBUSY;
795
796 /*
797 * If we know the dev is going away while the transport is still sending
798 * IO's return busy back to stall the IO Q. This happens when the
799 * link goes away and fw hasn't notified us yet, but IO's are being
800 * returned. If the dev comes back quickly we won't exhaust the IO
801 * retry count at the core.
802 */
803 if (fcport->nvme_flag & NVME_FLAG_RESETTING)
804 return -EBUSY;
805
806 qpair = qla_mapq_nvme_select_qpair(ha, qpair);
807
808 /* Alloc SRB structure */
809 sp = qla2xxx_get_qpair_sp(vha, qpair, fcport, GFP_ATOMIC);
810 if (!sp)
811 return -EBUSY;
812
813 kref_init(&sp->cmd_kref);
814 spin_lock_init(&priv->cmd_lock);
815 sp->priv = priv;
816 priv->sp = sp;
817 sp->type = SRB_NVME_CMD;
818 sp->name = "nvme_cmd";
819 sp->done = qla_nvme_sp_done;
820 sp->put_fn = qla_nvme_release_fcp_cmd_kref;
821 sp->qpair = qpair;
822 sp->vha = vha;
823 sp->cmd_sp = sp;
824 nvme = &sp->u.iocb_cmd;
825 nvme->u.nvme.desc = fd;
826
827 rval = qla2x00_start_nvme_mq(sp);
828 if (rval != QLA_SUCCESS) {
829 ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x212d,
830 "qla2x00_start_nvme_mq failed = %d\n", rval);
831 sp->priv = NULL;
832 priv->sp = NULL;
833 qla2xxx_rel_qpair_sp(sp->qpair, sp);
834 }
835
836 return rval;
837 }
838
839 static void qla_nvme_map_queues(struct nvme_fc_local_port *lport,
840 struct blk_mq_queue_map *map)
841 {
842 struct scsi_qla_host *vha = lport->private;
843
844 blk_mq_pci_map_queues(map, vha->hw->pdev, vha->irq_offset);
845 }
846
847 static void qla_nvme_localport_delete(struct nvme_fc_local_port *lport)
848 {
849 struct scsi_qla_host *vha = lport->private;
850
851 ql_log(ql_log_info, vha, 0x210f,
852 "localport delete of %p completed.\n", vha->nvme_local_port);
853 vha->nvme_local_port = NULL;
854 complete(&vha->nvme_del_done);
855 }
856
857 static void qla_nvme_remoteport_delete(struct nvme_fc_remote_port *rport)
858 {
859 fc_port_t *fcport;
860 struct qla_nvme_rport *qla_rport = rport->private;
861
862 fcport = qla_rport->fcport;
863 fcport->nvme_remote_port = NULL;
864 fcport->nvme_flag &= ~NVME_FLAG_REGISTERED;
865 fcport->nvme_flag &= ~NVME_FLAG_DELETING;
866 ql_log(ql_log_info, fcport->vha, 0x2110,
867 "remoteport_delete of %p %8phN completed.\n",
868 fcport, fcport->port_name);
869 complete(&fcport->nvme_del_done);
870 }
871
872 static struct nvme_fc_port_template qla_nvme_fc_transport = {
873 .localport_delete = qla_nvme_localport_delete,
874 .remoteport_delete = qla_nvme_remoteport_delete,
875 .create_queue = qla_nvme_alloc_queue,
876 .delete_queue = NULL,
877 .ls_req = qla_nvme_ls_req,
878 .ls_abort = qla_nvme_ls_abort,
879 .fcp_io = qla_nvme_post_cmd,
880 .fcp_abort = qla_nvme_fcp_abort,
881 .xmt_ls_rsp = qla_nvme_xmt_ls_rsp,
882 .map_queues = qla_nvme_map_queues,
883 .max_hw_queues = DEF_NVME_HW_QUEUES,
884 .max_sgl_segments = 1024,
885 .max_dif_sgl_segments = 64,
886 .dma_boundary = 0xFFFFFFFF,
887 .local_priv_sz = 8,
888 .remote_priv_sz = sizeof(struct qla_nvme_rport),
889 .lsrqst_priv_sz = sizeof(struct nvme_private),
890 .fcprqst_priv_sz = sizeof(struct nvme_private),
891 };
892
893 void qla_nvme_unregister_remote_port(struct fc_port *fcport)
894 {
895 int ret;
896
897 if (!IS_ENABLED(CONFIG_NVME_FC))
898 return;
899
900 ql_log(ql_log_warn, fcport->vha, 0x2112,
901 "%s: unregister remoteport on %p %8phN\n",
902 __func__, fcport, fcport->port_name);
903
904 if (test_bit(PFLG_DRIVER_REMOVING, &fcport->vha->pci_flags))
905 nvme_fc_set_remoteport_devloss(fcport->nvme_remote_port, 0);
906
907 init_completion(&fcport->nvme_del_done);
908 ret = nvme_fc_unregister_remoteport(fcport->nvme_remote_port);
909 if (ret)
910 ql_log(ql_log_info, fcport->vha, 0x2114,
911 "%s: Failed to unregister nvme_remote_port (%d)\n",
912 __func__, ret);
913 wait_for_completion(&fcport->nvme_del_done);
914 }
915
916 void qla_nvme_delete(struct scsi_qla_host *vha)
917 {
918 int nv_ret;
919
920 if (!IS_ENABLED(CONFIG_NVME_FC))
921 return;
922
923 if (vha->nvme_local_port) {
924 init_completion(&vha->nvme_del_done);
925 ql_log(ql_log_info, vha, 0x2116,
926 "unregister localport=%p\n",
927 vha->nvme_local_port);
928 nv_ret = nvme_fc_unregister_localport(vha->nvme_local_port);
929 if (nv_ret)
930 ql_log(ql_log_info, vha, 0x2115,
931 "Unregister of localport failed\n");
932 else
933 wait_for_completion(&vha->nvme_del_done);
934 }
935 }
936
937 int qla_nvme_register_hba(struct scsi_qla_host *vha)
938 {
939 struct nvme_fc_port_template *tmpl;
940 struct qla_hw_data *ha;
941 struct nvme_fc_port_info pinfo;
942 int ret = -EINVAL;
943
944 if (!IS_ENABLED(CONFIG_NVME_FC))
945 return ret;
946
947 ha = vha->hw;
948 tmpl = &qla_nvme_fc_transport;
949
950 if (ql2xnvme_queues < MIN_NVME_HW_QUEUES) {
951 ql_log(ql_log_warn, vha, 0xfffd,
952 "ql2xnvme_queues=%d is lower than minimum queues: %d. Resetting ql2xnvme_queues to:%d\n",
953 ql2xnvme_queues, MIN_NVME_HW_QUEUES, DEF_NVME_HW_QUEUES);
954 ql2xnvme_queues = DEF_NVME_HW_QUEUES;
955 } else if (ql2xnvme_queues > (ha->max_qpairs - 1)) {
956 ql_log(ql_log_warn, vha, 0xfffd,
957 "ql2xnvme_queues=%d is greater than available IRQs: %d. Resetting ql2xnvme_queues to: %d\n",
958 ql2xnvme_queues, (ha->max_qpairs - 1),
959 (ha->max_qpairs - 1));
960 ql2xnvme_queues = ((ha->max_qpairs - 1));
961 }
962
963 qla_nvme_fc_transport.max_hw_queues =
964 min((uint8_t)(ql2xnvme_queues),
965 (uint8_t)((ha->max_qpairs - 1) ? (ha->max_qpairs - 1) : 1));
966
967 ql_log(ql_log_info, vha, 0xfffb,
968 "Number of NVME queues used for this port: %d\n",
969 qla_nvme_fc_transport.max_hw_queues);
970
971 pinfo.node_name = wwn_to_u64(vha->node_name);
972 pinfo.port_name = wwn_to_u64(vha->port_name);
973 pinfo.port_role = FC_PORT_ROLE_NVME_INITIATOR;
974 pinfo.port_id = vha->d_id.b24;
975
976 mutex_lock(&ha->vport_lock);
977 /*
978 * Check again for nvme_local_port to see if any other thread raced
979 * with this one and finished registration.
980 */
981 if (!vha->nvme_local_port) {
982 ql_log(ql_log_info, vha, 0xffff,
983 "register_localport: host-traddr=nn-0x%llx:pn-0x%llx on portID:%x\n",
984 pinfo.node_name, pinfo.port_name, pinfo.port_id);
985 qla_nvme_fc_transport.dma_boundary = vha->host->dma_boundary;
986
987 ret = nvme_fc_register_localport(&pinfo, tmpl,
988 get_device(&ha->pdev->dev),
989 &vha->nvme_local_port);
990 mutex_unlock(&ha->vport_lock);
991 } else {
992 mutex_unlock(&ha->vport_lock);
993 return 0;
994 }
995 if (ret) {
996 ql_log(ql_log_warn, vha, 0xffff,
997 "register_localport failed: ret=%x\n", ret);
998 } else {
999 vha->nvme_local_port->private = vha;
1000 }
1001
1002 return ret;
1003 }
1004
1005 void qla_nvme_abort_set_option(struct abort_entry_24xx *abt, srb_t *orig_sp)
1006 {
1007 struct qla_hw_data *ha;
1008
1009 if (!(ql2xabts_wait_nvme && QLA_ABTS_WAIT_ENABLED(orig_sp)))
1010 return;
1011
1012 ha = orig_sp->fcport->vha->hw;
1013
1014 WARN_ON_ONCE(abt->options & cpu_to_le16(BIT_0));
1015 /* Use Driver Specified Retry Count */
1016 abt->options |= cpu_to_le16(AOF_ABTS_RTY_CNT);
1017 abt->drv.abts_rty_cnt = cpu_to_le16(2);
1018 /* Use specified response timeout */
1019 abt->options |= cpu_to_le16(AOF_RSP_TIMEOUT);
1020 /* set it to 2 * r_a_tov in secs */
1021 abt->drv.rsp_timeout = cpu_to_le16(2 * (ha->r_a_tov / 10));
1022 }
1023
1024 void qla_nvme_abort_process_comp_status(struct abort_entry_24xx *abt, srb_t *orig_sp)
1025 {
1026 u16 comp_status;
1027 struct scsi_qla_host *vha;
1028
1029 if (!(ql2xabts_wait_nvme && QLA_ABTS_WAIT_ENABLED(orig_sp)))
1030 return;
1031
1032 vha = orig_sp->fcport->vha;
1033
1034 comp_status = le16_to_cpu(abt->comp_status);
1035 switch (comp_status) {
1036 case CS_RESET: /* reset event aborted */
1037 case CS_ABORTED: /* IOCB was cleaned */
1038 /* N_Port handle is not currently logged in */
1039 case CS_TIMEOUT:
1040 /* N_Port handle was logged out while waiting for ABTS to complete */
1041 case CS_PORT_UNAVAILABLE:
1042 /* Firmware found that the port name changed */
1043 case CS_PORT_LOGGED_OUT:
1044 /* BA_RJT was received for the ABTS */
1045 case CS_PORT_CONFIG_CHG:
1046 ql_dbg(ql_dbg_async, vha, 0xf09d,
1047 "Abort I/O IOCB completed with error, comp_status=%x\n",
1048 comp_status);
1049 break;
1050
1051 /* BA_RJT was received for the ABTS */
1052 case CS_REJECT_RECEIVED:
1053 ql_dbg(ql_dbg_async, vha, 0xf09e,
1054 "BA_RJT was received for the ABTS rjt_vendorUnique = %u",
1055 abt->fw.ba_rjt_vendorUnique);
1056 ql_dbg(ql_dbg_async + ql_dbg_mbx, vha, 0xf09e,
1057 "ba_rjt_reasonCodeExpl = %u, ba_rjt_reasonCode = %u\n",
1058 abt->fw.ba_rjt_reasonCodeExpl, abt->fw.ba_rjt_reasonCode);
1059 break;
1060
1061 case CS_COMPLETE:
1062 ql_dbg(ql_dbg_async + ql_dbg_verbose, vha, 0xf09f,
1063 "IOCB request is completed successfully comp_status=%x\n",
1064 comp_status);
1065 break;
1066
1067 case CS_IOCB_ERROR:
1068 ql_dbg(ql_dbg_async, vha, 0xf0a0,
1069 "IOCB request is failed, comp_status=%x\n", comp_status);
1070 break;
1071
1072 default:
1073 ql_dbg(ql_dbg_async, vha, 0xf0a1,
1074 "Invalid Abort IO IOCB Completion Status %x\n",
1075 comp_status);
1076 break;
1077 }
1078 }
1079
1080 inline void qla_wait_nvme_release_cmd_kref(srb_t *orig_sp)
1081 {
1082 if (!(ql2xabts_wait_nvme && QLA_ABTS_WAIT_ENABLED(orig_sp)))
1083 return;
1084 kref_put(&orig_sp->cmd_kref, orig_sp->put_fn);
1085 }
1086
1087 static void qla_nvme_fc_format_rjt(void *buf, u8 ls_cmd, u8 reason,
1088 u8 explanation, u8 vendor)
1089 {
1090 struct fcnvme_ls_rjt *rjt = buf;
1091
1092 rjt->w0.ls_cmd = FCNVME_LSDESC_RQST;
1093 rjt->desc_list_len = fcnvme_lsdesc_len(sizeof(struct fcnvme_ls_rjt));
1094 rjt->rqst.desc_tag = cpu_to_be32(FCNVME_LSDESC_RQST);
1095 rjt->rqst.desc_len =
1096 fcnvme_lsdesc_len(sizeof(struct fcnvme_lsdesc_rqst));
1097 rjt->rqst.w0.ls_cmd = ls_cmd;
1098 rjt->rjt.desc_tag = cpu_to_be32(FCNVME_LSDESC_RJT);
1099 rjt->rjt.desc_len = fcnvme_lsdesc_len(sizeof(struct fcnvme_lsdesc_rjt));
1100 rjt->rjt.reason_code = reason;
1101 rjt->rjt.reason_explanation = explanation;
1102 rjt->rjt.vendor = vendor;
1103 }
1104
1105 static void qla_nvme_lsrjt_pt_iocb(struct scsi_qla_host *vha,
1106 struct pt_ls4_request *lsrjt_iocb,
1107 struct qla_nvme_lsrjt_pt_arg *a)
1108 {
1109 lsrjt_iocb->entry_type = PT_LS4_REQUEST;
1110 lsrjt_iocb->entry_count = 1;
1111 lsrjt_iocb->sys_define = 0;
1112 lsrjt_iocb->entry_status = 0;
1113 lsrjt_iocb->handle = QLA_SKIP_HANDLE;
1114 lsrjt_iocb->nport_handle = a->nport_handle;
1115 lsrjt_iocb->exchange_address = a->xchg_address;
1116 lsrjt_iocb->vp_index = a->vp_idx;
1117
1118 lsrjt_iocb->control_flags = cpu_to_le16(a->control_flags);
1119
1120 put_unaligned_le64(a->tx_addr, &lsrjt_iocb->dsd[0].address);
1121 lsrjt_iocb->dsd[0].length = cpu_to_le32(a->tx_byte_count);
1122 lsrjt_iocb->tx_dseg_count = cpu_to_le16(1);
1123 lsrjt_iocb->tx_byte_count = cpu_to_le32(a->tx_byte_count);
1124
1125 put_unaligned_le64(a->rx_addr, &lsrjt_iocb->dsd[1].address);
1126 lsrjt_iocb->dsd[1].length = 0;
1127 lsrjt_iocb->rx_dseg_count = 0;
1128 lsrjt_iocb->rx_byte_count = 0;
1129 }
1130
1131 static int
1132 qla_nvme_ls_reject_iocb(struct scsi_qla_host *vha, struct qla_qpair *qp,
1133 struct qla_nvme_lsrjt_pt_arg *a, bool is_xchg_terminate)
1134 {
1135 struct pt_ls4_request *lsrjt_iocb;
1136
1137 lsrjt_iocb = __qla2x00_alloc_iocbs(qp, NULL);
1138 if (!lsrjt_iocb) {
1139 ql_log(ql_log_warn, vha, 0x210e,
1140 "qla2x00_alloc_iocbs failed.\n");
1141 return QLA_FUNCTION_FAILED;
1142 }
1143
1144 if (!is_xchg_terminate) {
1145 qla_nvme_fc_format_rjt((void *)vha->hw->lsrjt.c, a->opcode,
1146 a->reason, a->explanation, 0);
1147
1148 a->tx_byte_count = sizeof(struct fcnvme_ls_rjt);
1149 a->tx_addr = vha->hw->lsrjt.cdma;
1150 a->control_flags = CF_LS4_RESPONDER << CF_LS4_SHIFT;
1151
1152 ql_dbg(ql_dbg_unsol, vha, 0x211f,
1153 "Sending nvme fc ls reject ox_id %04x op %04x\n",
1154 a->ox_id, a->opcode);
1155 ql_dump_buffer(ql_dbg_unsol + ql_dbg_verbose, vha, 0x210f,
1156 vha->hw->lsrjt.c, sizeof(*vha->hw->lsrjt.c));
1157 } else {
1158 a->tx_byte_count = 0;
1159 a->control_flags = CF_LS4_RESPONDER_TERM << CF_LS4_SHIFT;
1160 ql_dbg(ql_dbg_unsol, vha, 0x2110,
1161 "Terminate nvme ls xchg 0x%x\n", a->xchg_address);
1162 }
1163
1164 qla_nvme_lsrjt_pt_iocb(vha, lsrjt_iocb, a);
1165 /* flush iocb to mem before notifying hw doorbell */
1166 wmb();
1167 qla2x00_start_iocbs(vha, qp->req);
1168 return 0;
1169 }
1170
1171 /*
1172 * qla2xxx_process_purls_pkt() - Pass-up Unsolicited
1173 * Received FC-NVMe Link Service pkt to nvme_fc_rcv_ls_req().
1174 * LLDD need to provide memory for response buffer, which
1175 * will be used to reference the exchange corresponding
1176 * to the LS when issuing an ls response. LLDD will have to free
1177 * response buffer in lport->ops->xmt_ls_rsp().
1178 *
1179 * @vha: SCSI qla host
1180 * @item: ptr to purex_item
1181 */
1182 static void
1183 qla2xxx_process_purls_pkt(struct scsi_qla_host *vha, struct purex_item *item)
1184 {
1185 struct qla_nvme_unsol_ctx *uctx = item->purls_context;
1186 struct qla_nvme_lsrjt_pt_arg a;
1187 int ret = 1;
1188
1189 #if (IS_ENABLED(CONFIG_NVME_FC))
1190 ret = nvme_fc_rcv_ls_req(uctx->fcport->nvme_remote_port, &uctx->lsrsp,
1191 &item->iocb, item->size);
1192 #endif
1193 if (ret) {
1194 ql_dbg(ql_dbg_unsol, vha, 0x2125, "NVMe transport ls_req failed\n");
1195 memset((void *)&a, 0, sizeof(a));
1196 a.vp_idx = vha->vp_idx;
1197 a.nport_handle = uctx->nport_handle;
1198 a.xchg_address = uctx->exchange_address;
1199 qla_nvme_ls_reject_iocb(vha, vha->hw->base_qpair, &a, true);
1200 list_del(&uctx->elem);
1201 kfree(uctx);
1202 }
1203 }
1204
1205 static scsi_qla_host_t *
1206 qla2xxx_get_vha_from_vp_idx(struct qla_hw_data *ha, uint16_t vp_index)
1207 {
1208 scsi_qla_host_t *base_vha, *vha, *tvp;
1209 unsigned long flags;
1210
1211 base_vha = pci_get_drvdata(ha->pdev);
1212
1213 if (!vp_index && !ha->num_vhosts)
1214 return base_vha;
1215
1216 spin_lock_irqsave(&ha->vport_slock, flags);
1217 list_for_each_entry_safe(vha, tvp, &ha->vp_list, list) {
1218 if (vha->vp_idx == vp_index) {
1219 spin_unlock_irqrestore(&ha->vport_slock, flags);
1220 return vha;
1221 }
1222 }
1223 spin_unlock_irqrestore(&ha->vport_slock, flags);
1224
1225 return NULL;
1226 }
1227
1228 void qla2xxx_process_purls_iocb(void **pkt, struct rsp_que **rsp)
1229 {
1230 struct nvme_fc_remote_port *rport;
1231 struct qla_nvme_rport *qla_rport;
1232 struct qla_nvme_lsrjt_pt_arg a;
1233 struct pt_ls4_rx_unsol *p = *pkt;
1234 struct qla_nvme_unsol_ctx *uctx;
1235 struct rsp_que *rsp_q = *rsp;
1236 struct qla_hw_data *ha;
1237 scsi_qla_host_t *vha;
1238 fc_port_t *fcport = NULL;
1239 struct purex_item *item;
1240 port_id_t d_id = {0};
1241 port_id_t id = {0};
1242 u8 *opcode;
1243 bool xmt_reject = false;
1244
1245 ha = rsp_q->hw;
1246
1247 vha = qla2xxx_get_vha_from_vp_idx(ha, p->vp_index);
1248 if (!vha) {
1249 ql_log(ql_log_warn, NULL, 0x2110, "Invalid vp index %d\n", p->vp_index);
1250 WARN_ON_ONCE(1);
1251 return;
1252 }
1253
1254 memset((void *)&a, 0, sizeof(a));
1255 opcode = (u8 *)&p->payload[0];
1256 a.opcode = opcode[3];
1257 a.vp_idx = p->vp_index;
1258 a.nport_handle = p->nport_handle;
1259 a.ox_id = p->ox_id;
1260 a.xchg_address = p->exchange_address;
1261
1262 id.b.domain = p->s_id.domain;
1263 id.b.area = p->s_id.area;
1264 id.b.al_pa = p->s_id.al_pa;
1265 d_id.b.domain = p->d_id[2];
1266 d_id.b.area = p->d_id[1];
1267 d_id.b.al_pa = p->d_id[0];
1268
1269 fcport = qla2x00_find_fcport_by_nportid(vha, &id, 0);
1270 if (!fcport) {
1271 ql_dbg(ql_dbg_unsol, vha, 0x211e,
1272 "Failed to find sid=%06x did=%06x\n",
1273 id.b24, d_id.b24);
1274 a.reason = FCNVME_RJT_RC_INV_ASSOC;
1275 a.explanation = FCNVME_RJT_EXP_NONE;
1276 xmt_reject = true;
1277 goto out;
1278 }
1279 rport = fcport->nvme_remote_port;
1280 qla_rport = rport->private;
1281
1282 item = qla27xx_copy_multiple_pkt(vha, pkt, rsp, true, false);
1283 if (!item) {
1284 a.reason = FCNVME_RJT_RC_LOGIC;
1285 a.explanation = FCNVME_RJT_EXP_NONE;
1286 xmt_reject = true;
1287 goto out;
1288 }
1289
1290 uctx = kzalloc(sizeof(*uctx), GFP_ATOMIC);
1291 if (!uctx) {
1292 ql_log(ql_log_info, vha, 0x2126, "Failed allocate memory\n");
1293 a.reason = FCNVME_RJT_RC_LOGIC;
1294 a.explanation = FCNVME_RJT_EXP_NONE;
1295 xmt_reject = true;
1296 kfree(item);
1297 goto out;
1298 }
1299
1300 uctx->vha = vha;
1301 uctx->fcport = fcport;
1302 uctx->exchange_address = p->exchange_address;
1303 uctx->nport_handle = p->nport_handle;
1304 uctx->ox_id = p->ox_id;
1305 qla_rport->uctx = uctx;
1306 INIT_LIST_HEAD(&uctx->elem);
1307 list_add_tail(&uctx->elem, &fcport->unsol_ctx_head);
1308 item->purls_context = (void *)uctx;
1309
1310 ql_dbg(ql_dbg_unsol, vha, 0x2121,
1311 "PURLS OP[%01x] size %d xchg addr 0x%x portid %06x\n",
1312 item->iocb.iocb[3], item->size, uctx->exchange_address,
1313 fcport->d_id.b24);
1314 /* +48 0 1 2 3 4 5 6 7 8 9 A B C D E F
1315 * ----- -----------------------------------------------
1316 * 0000: 00 00 00 05 28 00 00 00 07 00 00 00 08 00 00 00
1317 * 0010: ab ec 0f cc 00 00 8d 7d 05 00 00 00 10 00 00 00
1318 * 0020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
1319 */
1320 ql_dump_buffer(ql_dbg_unsol + ql_dbg_verbose, vha, 0x2120,
1321 &item->iocb, item->size);
1322
1323 qla24xx_queue_purex_item(vha, item, qla2xxx_process_purls_pkt);
1324 out:
1325 if (xmt_reject) {
1326 qla_nvme_ls_reject_iocb(vha, (*rsp)->qpair, &a, false);
1327 __qla_consume_iocb(vha, pkt, rsp);
1328 }
1329 }
Kernel DRM miscellaneous fixes and cross-tree changes