?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / scsi / qedf / qedf_io.c
blobe749a2dcaad7ee678479e3269f80857f383b6c86
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * QLogic FCoE Offload Driver
4 * Copyright (c) 2016-2018 Cavium Inc.
5 */
6 #include <linux/spinlock.h>
7 #include <linux/vmalloc.h>
8 #include "qedf.h"
9 #include <scsi/scsi_tcq.h>
10
11 void qedf_cmd_timer_set(struct qedf_ctx *qedf, struct qedf_ioreq *io_req,
12 unsigned int timer_msec)
13 {
14 queue_delayed_work(qedf->timer_work_queue, &io_req->timeout_work,
15 msecs_to_jiffies(timer_msec));
16 }
17
18 static void qedf_cmd_timeout(struct work_struct *work)
19 {
20
21 struct qedf_ioreq *io_req =
22 container_of(work, struct qedf_ioreq, timeout_work.work);
23 struct qedf_ctx *qedf;
24 struct qedf_rport *fcport;
25 u8 op = 0;
26
27 if (io_req == NULL) {
28 QEDF_INFO(NULL, QEDF_LOG_IO, "io_req is NULL.\n");
29 return;
30 }
31
32 fcport = io_req->fcport;
33 if (io_req->fcport == NULL) {
34 QEDF_INFO(NULL, QEDF_LOG_IO, "fcport is NULL.\n");
35 return;
36 }
37
38 qedf = fcport->qedf;
39
40 switch (io_req->cmd_type) {
41 case QEDF_ABTS:
42 if (qedf == NULL) {
43 QEDF_INFO(NULL, QEDF_LOG_IO,
44 "qedf is NULL for ABTS xid=0x%x.\n",
45 io_req->xid);
46 return;
47 }
48
49 QEDF_ERR((&qedf->dbg_ctx), "ABTS timeout, xid=0x%x.\n",
50 io_req->xid);
51 /* Cleanup timed out ABTS */
52 qedf_initiate_cleanup(io_req, true);
53 complete(&io_req->abts_done);
54
55 /*
56 * Need to call kref_put for reference taken when initiate_abts
57 * was called since abts_compl won't be called now that we've
58 * cleaned up the task.
59 */
60 kref_put(&io_req->refcount, qedf_release_cmd);
61
62 /* Clear in abort bit now that we're done with the command */
63 clear_bit(QEDF_CMD_IN_ABORT, &io_req->flags);
64
65 /*
66 * Now that the original I/O and the ABTS are complete see
67 * if we need to reconnect to the target.
68 */
69 qedf_restart_rport(fcport);
70 break;
71 case QEDF_ELS:
72 if (!qedf) {
73 QEDF_INFO(NULL, QEDF_LOG_IO,
74 "qedf is NULL for ELS xid=0x%x.\n",
75 io_req->xid);
76 return;
77 }
78 /* ELS request no longer outstanding since it timed out */
79 clear_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
80
81 kref_get(&io_req->refcount);
82 /*
83 * Don't attempt to clean an ELS timeout as any subseqeunt
84 * ABTS or cleanup requests just hang. For now just free
85 * the resources of the original I/O and the RRQ
86 */
87 QEDF_ERR(&(qedf->dbg_ctx), "ELS timeout, xid=0x%x.\n",
88 io_req->xid);
89 io_req->event = QEDF_IOREQ_EV_ELS_TMO;
90 /* Call callback function to complete command */
91 if (io_req->cb_func && io_req->cb_arg) {
92 op = io_req->cb_arg->op;
93 io_req->cb_func(io_req->cb_arg);
94 io_req->cb_arg = NULL;
95 }
96 qedf_initiate_cleanup(io_req, true);
97 kref_put(&io_req->refcount, qedf_release_cmd);
98 break;
99 case QEDF_SEQ_CLEANUP:
100 QEDF_ERR(&(qedf->dbg_ctx), "Sequence cleanup timeout, "
101 "xid=0x%x.\n", io_req->xid);
102 qedf_initiate_cleanup(io_req, true);
103 io_req->event = QEDF_IOREQ_EV_ELS_TMO;
104 qedf_process_seq_cleanup_compl(qedf, NULL, io_req);
105 break;
106 default:
107 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
108 "Hit default case, xid=0x%x.\n", io_req->xid);
109 break;
110 }
111 }
112
113 void qedf_cmd_mgr_free(struct qedf_cmd_mgr *cmgr)
114 {
115 struct io_bdt *bdt_info;
116 struct qedf_ctx *qedf = cmgr->qedf;
117 size_t bd_tbl_sz;
118 u16 min_xid = 0;
119 u16 max_xid = (FCOE_PARAMS_NUM_TASKS - 1);
120 int num_ios;
121 int i;
122 struct qedf_ioreq *io_req;
123
124 num_ios = max_xid - min_xid + 1;
125
126 /* Free fcoe_bdt_ctx structures */
127 if (!cmgr->io_bdt_pool) {
128 QEDF_ERR(&qedf->dbg_ctx, "io_bdt_pool is NULL.\n");
129 goto free_cmd_pool;
130 }
131
132 bd_tbl_sz = QEDF_MAX_BDS_PER_CMD * sizeof(struct scsi_sge);
133 for (i = 0; i < num_ios; i++) {
134 bdt_info = cmgr->io_bdt_pool[i];
135 if (bdt_info->bd_tbl) {
136 dma_free_coherent(&qedf->pdev->dev, bd_tbl_sz,
137 bdt_info->bd_tbl, bdt_info->bd_tbl_dma);
138 bdt_info->bd_tbl = NULL;
139 }
140 }
141
142 /* Destroy io_bdt pool */
143 for (i = 0; i < num_ios; i++) {
144 kfree(cmgr->io_bdt_pool[i]);
145 cmgr->io_bdt_pool[i] = NULL;
146 }
147
148 kfree(cmgr->io_bdt_pool);
149 cmgr->io_bdt_pool = NULL;
150
151 free_cmd_pool:
152
153 for (i = 0; i < num_ios; i++) {
154 io_req = &cmgr->cmds[i];
155 kfree(io_req->sgl_task_params);
156 kfree(io_req->task_params);
157 /* Make sure we free per command sense buffer */
158 if (io_req->sense_buffer)
159 dma_free_coherent(&qedf->pdev->dev,
160 QEDF_SCSI_SENSE_BUFFERSIZE, io_req->sense_buffer,
161 io_req->sense_buffer_dma);
162 cancel_delayed_work_sync(&io_req->rrq_work);
163 }
164
165 /* Free command manager itself */
166 vfree(cmgr);
167 }
168
169 static void qedf_handle_rrq(struct work_struct *work)
170 {
171 struct qedf_ioreq *io_req =
172 container_of(work, struct qedf_ioreq, rrq_work.work);
173
174 atomic_set(&io_req->state, QEDFC_CMD_ST_RRQ_ACTIVE);
175 qedf_send_rrq(io_req);
176
177 }
178
179 struct qedf_cmd_mgr *qedf_cmd_mgr_alloc(struct qedf_ctx *qedf)
180 {
181 struct qedf_cmd_mgr *cmgr;
182 struct io_bdt *bdt_info;
183 struct qedf_ioreq *io_req;
184 u16 xid;
185 int i;
186 int num_ios;
187 u16 min_xid = 0;
188 u16 max_xid = (FCOE_PARAMS_NUM_TASKS - 1);
189
190 /* Make sure num_queues is already set before calling this function */
191 if (!qedf->num_queues) {
192 QEDF_ERR(&(qedf->dbg_ctx), "num_queues is not set.\n");
193 return NULL;
194 }
195
196 if (max_xid <= min_xid || max_xid == FC_XID_UNKNOWN) {
197 QEDF_WARN(&(qedf->dbg_ctx), "Invalid min_xid 0x%x and "
198 "max_xid 0x%x.\n", min_xid, max_xid);
199 return NULL;
200 }
201
202 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "min xid 0x%x, max xid "
203 "0x%x.\n", min_xid, max_xid);
204
205 num_ios = max_xid - min_xid + 1;
206
207 cmgr = vzalloc(sizeof(struct qedf_cmd_mgr));
208 if (!cmgr) {
209 QEDF_WARN(&(qedf->dbg_ctx), "Failed to alloc cmd mgr.\n");
210 return NULL;
211 }
212
213 cmgr->qedf = qedf;
214 spin_lock_init(&cmgr->lock);
215
216 /*
217 * Initialize I/O request fields.
218 */
219 xid = 0;
220
221 for (i = 0; i < num_ios; i++) {
222 io_req = &cmgr->cmds[i];
223 INIT_DELAYED_WORK(&io_req->timeout_work, qedf_cmd_timeout);
224
225 io_req->xid = xid++;
226
227 INIT_DELAYED_WORK(&io_req->rrq_work, qedf_handle_rrq);
228
229 /* Allocate DMA memory to hold sense buffer */
230 io_req->sense_buffer = dma_alloc_coherent(&qedf->pdev->dev,
231 QEDF_SCSI_SENSE_BUFFERSIZE, &io_req->sense_buffer_dma,
232 GFP_KERNEL);
233 if (!io_req->sense_buffer) {
234 QEDF_ERR(&qedf->dbg_ctx,
235 "Failed to alloc sense buffer.\n");
236 goto mem_err;
237 }
238
239 /* Allocate task parameters to pass to f/w init funcions */
240 io_req->task_params = kzalloc(sizeof(*io_req->task_params),
241 GFP_KERNEL);
242 if (!io_req->task_params) {
243 QEDF_ERR(&(qedf->dbg_ctx),
244 "Failed to allocate task_params for xid=0x%x\n",
245 i);
246 goto mem_err;
247 }
248
249 /*
250 * Allocate scatter/gather list info to pass to f/w init
251 * functions.
252 */
253 io_req->sgl_task_params = kzalloc(
254 sizeof(struct scsi_sgl_task_params), GFP_KERNEL);
255 if (!io_req->sgl_task_params) {
256 QEDF_ERR(&(qedf->dbg_ctx),
257 "Failed to allocate sgl_task_params for xid=0x%x\n",
258 i);
259 goto mem_err;
260 }
261 }
262
263 /* Allocate pool of io_bdts - one for each qedf_ioreq */
264 cmgr->io_bdt_pool = kmalloc_array(num_ios, sizeof(struct io_bdt *),
265 GFP_KERNEL);
266
267 if (!cmgr->io_bdt_pool) {
268 QEDF_WARN(&(qedf->dbg_ctx), "Failed to alloc io_bdt_pool.\n");
269 goto mem_err;
270 }
271
272 for (i = 0; i < num_ios; i++) {
273 cmgr->io_bdt_pool[i] = kmalloc(sizeof(struct io_bdt),
274 GFP_KERNEL);
275 if (!cmgr->io_bdt_pool[i]) {
276 QEDF_WARN(&(qedf->dbg_ctx),
277 "Failed to alloc io_bdt_pool[%d].\n", i);
278 goto mem_err;
279 }
280 }
281
282 for (i = 0; i < num_ios; i++) {
283 bdt_info = cmgr->io_bdt_pool[i];
284 bdt_info->bd_tbl = dma_alloc_coherent(&qedf->pdev->dev,
285 QEDF_MAX_BDS_PER_CMD * sizeof(struct scsi_sge),
286 &bdt_info->bd_tbl_dma, GFP_KERNEL);
287 if (!bdt_info->bd_tbl) {
288 QEDF_WARN(&(qedf->dbg_ctx),
289 "Failed to alloc bdt_tbl[%d].\n", i);
290 goto mem_err;
291 }
292 }
293 atomic_set(&cmgr->free_list_cnt, num_ios);
294 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
295 "cmgr->free_list_cnt=%d.\n",
296 atomic_read(&cmgr->free_list_cnt));
297
298 return cmgr;
299
300 mem_err:
301 qedf_cmd_mgr_free(cmgr);
302 return NULL;
303 }
304
305 struct qedf_ioreq *qedf_alloc_cmd(struct qedf_rport *fcport, u8 cmd_type)
306 {
307 struct qedf_ctx *qedf = fcport->qedf;
308 struct qedf_cmd_mgr *cmd_mgr = qedf->cmd_mgr;
309 struct qedf_ioreq *io_req = NULL;
310 struct io_bdt *bd_tbl;
311 u16 xid;
312 uint32_t free_sqes;
313 int i;
314 unsigned long flags;
315
316 free_sqes = atomic_read(&fcport->free_sqes);
317
318 if (!free_sqes) {
319 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
320 "Returning NULL, free_sqes=%d.\n ",
321 free_sqes);
322 goto out_failed;
323 }
324
325 /* Limit the number of outstanding R/W tasks */
326 if ((atomic_read(&fcport->num_active_ios) >=
327 NUM_RW_TASKS_PER_CONNECTION)) {
328 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
329 "Returning NULL, num_active_ios=%d.\n",
330 atomic_read(&fcport->num_active_ios));
331 goto out_failed;
332 }
333
334 /* Limit global TIDs certain tasks */
335 if (atomic_read(&cmd_mgr->free_list_cnt) <= GBL_RSVD_TASKS) {
336 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
337 "Returning NULL, free_list_cnt=%d.\n",
338 atomic_read(&cmd_mgr->free_list_cnt));
339 goto out_failed;
340 }
341
342 spin_lock_irqsave(&cmd_mgr->lock, flags);
343 for (i = 0; i < FCOE_PARAMS_NUM_TASKS; i++) {
344 io_req = &cmd_mgr->cmds[cmd_mgr->idx];
345 cmd_mgr->idx++;
346 if (cmd_mgr->idx == FCOE_PARAMS_NUM_TASKS)
347 cmd_mgr->idx = 0;
348
349 /* Check to make sure command was previously freed */
350 if (!io_req->alloc)
351 break;
352 }
353
354 if (i == FCOE_PARAMS_NUM_TASKS) {
355 spin_unlock_irqrestore(&cmd_mgr->lock, flags);
356 goto out_failed;
357 }
358
359 if (test_bit(QEDF_CMD_DIRTY, &io_req->flags))
360 QEDF_ERR(&qedf->dbg_ctx,
361 "io_req found to be dirty ox_id = 0x%x.\n",
362 io_req->xid);
363
364 /* Clear any flags now that we've reallocated the xid */
365 io_req->flags = 0;
366 io_req->alloc = 1;
367 spin_unlock_irqrestore(&cmd_mgr->lock, flags);
368
369 atomic_inc(&fcport->num_active_ios);
370 atomic_dec(&fcport->free_sqes);
371 xid = io_req->xid;
372 atomic_dec(&cmd_mgr->free_list_cnt);
373
374 io_req->cmd_mgr = cmd_mgr;
375 io_req->fcport = fcport;
376
377 /* Clear any stale sc_cmd back pointer */
378 io_req->sc_cmd = NULL;
379 io_req->lun = -1;
380
381 /* Hold the io_req against deletion */
382 kref_init(&io_req->refcount); /* ID: 001 */
383 atomic_set(&io_req->state, QEDFC_CMD_ST_IO_ACTIVE);
384
385 /* Bind io_bdt for this io_req */
386 /* Have a static link between io_req and io_bdt_pool */
387 bd_tbl = io_req->bd_tbl = cmd_mgr->io_bdt_pool[xid];
388 if (bd_tbl == NULL) {
389 QEDF_ERR(&(qedf->dbg_ctx), "bd_tbl is NULL, xid=%x.\n", xid);
390 kref_put(&io_req->refcount, qedf_release_cmd);
391 goto out_failed;
392 }
393 bd_tbl->io_req = io_req;
394 io_req->cmd_type = cmd_type;
395 io_req->tm_flags = 0;
396
397 /* Reset sequence offset data */
398 io_req->rx_buf_off = 0;
399 io_req->tx_buf_off = 0;
400 io_req->rx_id = 0xffff; /* No OX_ID */
401
402 return io_req;
403
404 out_failed:
405 /* Record failure for stats and return NULL to caller */
406 qedf->alloc_failures++;
407 return NULL;
408 }
409
410 static void qedf_free_mp_resc(struct qedf_ioreq *io_req)
411 {
412 struct qedf_mp_req *mp_req = &(io_req->mp_req);
413 struct qedf_ctx *qedf = io_req->fcport->qedf;
414 uint64_t sz = sizeof(struct scsi_sge);
415
416 /* clear tm flags */
417 if (mp_req->mp_req_bd) {
418 dma_free_coherent(&qedf->pdev->dev, sz,
419 mp_req->mp_req_bd, mp_req->mp_req_bd_dma);
420 mp_req->mp_req_bd = NULL;
421 }
422 if (mp_req->mp_resp_bd) {
423 dma_free_coherent(&qedf->pdev->dev, sz,
424 mp_req->mp_resp_bd, mp_req->mp_resp_bd_dma);
425 mp_req->mp_resp_bd = NULL;
426 }
427 if (mp_req->req_buf) {
428 dma_free_coherent(&qedf->pdev->dev, QEDF_PAGE_SIZE,
429 mp_req->req_buf, mp_req->req_buf_dma);
430 mp_req->req_buf = NULL;
431 }
432 if (mp_req->resp_buf) {
433 dma_free_coherent(&qedf->pdev->dev, QEDF_PAGE_SIZE,
434 mp_req->resp_buf, mp_req->resp_buf_dma);
435 mp_req->resp_buf = NULL;
436 }
437 }
438
439 void qedf_release_cmd(struct kref *ref)
440 {
441 struct qedf_ioreq *io_req =
442 container_of(ref, struct qedf_ioreq, refcount);
443 struct qedf_cmd_mgr *cmd_mgr = io_req->cmd_mgr;
444 struct qedf_rport *fcport = io_req->fcport;
445 unsigned long flags;
446
447 if (io_req->cmd_type == QEDF_SCSI_CMD) {
448 QEDF_WARN(&fcport->qedf->dbg_ctx,
449 "Cmd released called without scsi_done called, io_req %p xid=0x%x.\n",
450 io_req, io_req->xid);
451 WARN_ON(io_req->sc_cmd);
452 }
453
454 if (io_req->cmd_type == QEDF_ELS ||
455 io_req->cmd_type == QEDF_TASK_MGMT_CMD)
456 qedf_free_mp_resc(io_req);
457
458 atomic_inc(&cmd_mgr->free_list_cnt);
459 atomic_dec(&fcport->num_active_ios);
460 atomic_set(&io_req->state, QEDF_CMD_ST_INACTIVE);
461 if (atomic_read(&fcport->num_active_ios) < 0) {
462 QEDF_WARN(&(fcport->qedf->dbg_ctx), "active_ios < 0.\n");
463 WARN_ON(1);
464 }
465
466 /* Increment task retry identifier now that the request is released */
467 io_req->task_retry_identifier++;
468 io_req->fcport = NULL;
469
470 clear_bit(QEDF_CMD_DIRTY, &io_req->flags);
471 io_req->cpu = 0;
472 spin_lock_irqsave(&cmd_mgr->lock, flags);
473 io_req->fcport = NULL;
474 io_req->alloc = 0;
475 spin_unlock_irqrestore(&cmd_mgr->lock, flags);
476 }
477
478 static int qedf_map_sg(struct qedf_ioreq *io_req)
479 {
480 struct scsi_cmnd *sc = io_req->sc_cmd;
481 struct Scsi_Host *host = sc->device->host;
482 struct fc_lport *lport = shost_priv(host);
483 struct qedf_ctx *qedf = lport_priv(lport);
484 struct scsi_sge *bd = io_req->bd_tbl->bd_tbl;
485 struct scatterlist *sg;
486 int byte_count = 0;
487 int sg_count = 0;
488 int bd_count = 0;
489 u32 sg_len;
490 u64 addr, end_addr;
491 int i = 0;
492
493 sg_count = dma_map_sg(&qedf->pdev->dev, scsi_sglist(sc),
494 scsi_sg_count(sc), sc->sc_data_direction);
495 sg = scsi_sglist(sc);
496
497 io_req->sge_type = QEDF_IOREQ_UNKNOWN_SGE;
498
499 if (sg_count <= 8 || io_req->io_req_flags == QEDF_READ)
500 io_req->sge_type = QEDF_IOREQ_FAST_SGE;
501
502 scsi_for_each_sg(sc, sg, sg_count, i) {
503 sg_len = (u32)sg_dma_len(sg);
504 addr = (u64)sg_dma_address(sg);
505 end_addr = (u64)(addr + sg_len);
506
507 /*
508 * Intermediate s/g element so check if start and end address
509 * is page aligned. Only required for writes and only if the
510 * number of scatter/gather elements is 8 or more.
511 */
512 if (io_req->sge_type == QEDF_IOREQ_UNKNOWN_SGE && (i) &&
513 (i != (sg_count - 1)) && sg_len < QEDF_PAGE_SIZE)
514 io_req->sge_type = QEDF_IOREQ_SLOW_SGE;
515
516 bd[bd_count].sge_addr.lo = cpu_to_le32(U64_LO(addr));
517 bd[bd_count].sge_addr.hi = cpu_to_le32(U64_HI(addr));
518 bd[bd_count].sge_len = cpu_to_le32(sg_len);
519
520 bd_count++;
521 byte_count += sg_len;
522 }
523
524 /* To catch a case where FAST and SLOW nothing is set, set FAST */
525 if (io_req->sge_type == QEDF_IOREQ_UNKNOWN_SGE)
526 io_req->sge_type = QEDF_IOREQ_FAST_SGE;
527
528 if (byte_count != scsi_bufflen(sc))
529 QEDF_ERR(&(qedf->dbg_ctx), "byte_count = %d != "
530 "scsi_bufflen = %d, task_id = 0x%x.\n", byte_count,
531 scsi_bufflen(sc), io_req->xid);
532
533 return bd_count;
534 }
535
536 static int qedf_build_bd_list_from_sg(struct qedf_ioreq *io_req)
537 {
538 struct scsi_cmnd *sc = io_req->sc_cmd;
539 struct scsi_sge *bd = io_req->bd_tbl->bd_tbl;
540 int bd_count;
541
542 if (scsi_sg_count(sc)) {
543 bd_count = qedf_map_sg(io_req);
544 if (bd_count == 0)
545 return -ENOMEM;
546 } else {
547 bd_count = 0;
548 bd[0].sge_addr.lo = bd[0].sge_addr.hi = 0;
549 bd[0].sge_len = 0;
550 }
551 io_req->bd_tbl->bd_valid = bd_count;
552
553 return 0;
554 }
555
556 static void qedf_build_fcp_cmnd(struct qedf_ioreq *io_req,
557 struct fcp_cmnd *fcp_cmnd)
558 {
559 struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
560
561 /* fcp_cmnd is 32 bytes */
562 memset(fcp_cmnd, 0, FCP_CMND_LEN);
563
564 /* 8 bytes: SCSI LUN info */
565 int_to_scsilun(sc_cmd->device->lun,
566 (struct scsi_lun *)&fcp_cmnd->fc_lun);
567
568 /* 4 bytes: flag info */
569 fcp_cmnd->fc_pri_ta = 0;
570 fcp_cmnd->fc_tm_flags = io_req->tm_flags;
571 fcp_cmnd->fc_flags = io_req->io_req_flags;
572 fcp_cmnd->fc_cmdref = 0;
573
574 /* Populate data direction */
575 if (io_req->cmd_type == QEDF_TASK_MGMT_CMD) {
576 fcp_cmnd->fc_flags |= FCP_CFL_RDDATA;
577 } else {
578 if (sc_cmd->sc_data_direction == DMA_TO_DEVICE)
579 fcp_cmnd->fc_flags |= FCP_CFL_WRDATA;
580 else if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE)
581 fcp_cmnd->fc_flags |= FCP_CFL_RDDATA;
582 }
583
584 fcp_cmnd->fc_pri_ta = FCP_PTA_SIMPLE;
585
586 /* 16 bytes: CDB information */
587 if (io_req->cmd_type != QEDF_TASK_MGMT_CMD)
588 memcpy(fcp_cmnd->fc_cdb, sc_cmd->cmnd, sc_cmd->cmd_len);
589
590 /* 4 bytes: FCP data length */
591 fcp_cmnd->fc_dl = htonl(io_req->data_xfer_len);
592 }
593
594 static void qedf_init_task(struct qedf_rport *fcport, struct fc_lport *lport,
595 struct qedf_ioreq *io_req, struct e4_fcoe_task_context *task_ctx,
596 struct fcoe_wqe *sqe)
597 {
598 enum fcoe_task_type task_type;
599 struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
600 struct io_bdt *bd_tbl = io_req->bd_tbl;
601 u8 fcp_cmnd[32];
602 u32 tmp_fcp_cmnd[8];
603 int bd_count = 0;
604 struct qedf_ctx *qedf = fcport->qedf;
605 uint16_t cq_idx = smp_processor_id() % qedf->num_queues;
606 struct regpair sense_data_buffer_phys_addr;
607 u32 tx_io_size = 0;
608 u32 rx_io_size = 0;
609 int i, cnt;
610
611 /* Note init_initiator_rw_fcoe_task memsets the task context */
612 io_req->task = task_ctx;
613 memset(task_ctx, 0, sizeof(struct e4_fcoe_task_context));
614 memset(io_req->task_params, 0, sizeof(struct fcoe_task_params));
615 memset(io_req->sgl_task_params, 0, sizeof(struct scsi_sgl_task_params));
616
617 /* Set task type bassed on DMA directio of command */
618 if (io_req->cmd_type == QEDF_TASK_MGMT_CMD) {
619 task_type = FCOE_TASK_TYPE_READ_INITIATOR;
620 } else {
621 if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
622 task_type = FCOE_TASK_TYPE_WRITE_INITIATOR;
623 tx_io_size = io_req->data_xfer_len;
624 } else {
625 task_type = FCOE_TASK_TYPE_READ_INITIATOR;
626 rx_io_size = io_req->data_xfer_len;
627 }
628 }
629
630 /* Setup the fields for fcoe_task_params */
631 io_req->task_params->context = task_ctx;
632 io_req->task_params->sqe = sqe;
633 io_req->task_params->task_type = task_type;
634 io_req->task_params->tx_io_size = tx_io_size;
635 io_req->task_params->rx_io_size = rx_io_size;
636 io_req->task_params->conn_cid = fcport->fw_cid;
637 io_req->task_params->itid = io_req->xid;
638 io_req->task_params->cq_rss_number = cq_idx;
639 io_req->task_params->is_tape_device = fcport->dev_type;
640
641 /* Fill in information for scatter/gather list */
642 if (io_req->cmd_type != QEDF_TASK_MGMT_CMD) {
643 bd_count = bd_tbl->bd_valid;
644 io_req->sgl_task_params->sgl = bd_tbl->bd_tbl;
645 io_req->sgl_task_params->sgl_phys_addr.lo =
646 U64_LO(bd_tbl->bd_tbl_dma);
647 io_req->sgl_task_params->sgl_phys_addr.hi =
648 U64_HI(bd_tbl->bd_tbl_dma);
649 io_req->sgl_task_params->num_sges = bd_count;
650 io_req->sgl_task_params->total_buffer_size =
651 scsi_bufflen(io_req->sc_cmd);
652 if (io_req->sge_type == QEDF_IOREQ_SLOW_SGE)
653 io_req->sgl_task_params->small_mid_sge = 1;
654 else
655 io_req->sgl_task_params->small_mid_sge = 0;
656 }
657
658 /* Fill in physical address of sense buffer */
659 sense_data_buffer_phys_addr.lo = U64_LO(io_req->sense_buffer_dma);
660 sense_data_buffer_phys_addr.hi = U64_HI(io_req->sense_buffer_dma);
661
662 /* fill FCP_CMND IU */
663 qedf_build_fcp_cmnd(io_req, (struct fcp_cmnd *)tmp_fcp_cmnd);
664
665 /* Swap fcp_cmnd since FC is big endian */
666 cnt = sizeof(struct fcp_cmnd) / sizeof(u32);
667 for (i = 0; i < cnt; i++) {
668 tmp_fcp_cmnd[i] = cpu_to_be32(tmp_fcp_cmnd[i]);
669 }
670 memcpy(fcp_cmnd, tmp_fcp_cmnd, sizeof(struct fcp_cmnd));
671
672 init_initiator_rw_fcoe_task(io_req->task_params,
673 io_req->sgl_task_params,
674 sense_data_buffer_phys_addr,
675 io_req->task_retry_identifier, fcp_cmnd);
676
677 /* Increment SGL type counters */
678 if (io_req->sge_type == QEDF_IOREQ_SLOW_SGE)
679 qedf->slow_sge_ios++;
680 else
681 qedf->fast_sge_ios++;
682 }
683
684 void qedf_init_mp_task(struct qedf_ioreq *io_req,
685 struct e4_fcoe_task_context *task_ctx, struct fcoe_wqe *sqe)
686 {
687 struct qedf_mp_req *mp_req = &(io_req->mp_req);
688 struct qedf_rport *fcport = io_req->fcport;
689 struct qedf_ctx *qedf = io_req->fcport->qedf;
690 struct fc_frame_header *fc_hdr;
691 struct fcoe_tx_mid_path_params task_fc_hdr;
692 struct scsi_sgl_task_params tx_sgl_task_params;
693 struct scsi_sgl_task_params rx_sgl_task_params;
694
695 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
696 "Initializing MP task for cmd_type=%d\n",
697 io_req->cmd_type);
698
699 qedf->control_requests++;
700
701 memset(&tx_sgl_task_params, 0, sizeof(struct scsi_sgl_task_params));
702 memset(&rx_sgl_task_params, 0, sizeof(struct scsi_sgl_task_params));
703 memset(task_ctx, 0, sizeof(struct e4_fcoe_task_context));
704 memset(&task_fc_hdr, 0, sizeof(struct fcoe_tx_mid_path_params));
705
706 /* Setup the task from io_req for easy reference */
707 io_req->task = task_ctx;
708
709 /* Setup the fields for fcoe_task_params */
710 io_req->task_params->context = task_ctx;
711 io_req->task_params->sqe = sqe;
712 io_req->task_params->task_type = FCOE_TASK_TYPE_MIDPATH;
713 io_req->task_params->tx_io_size = io_req->data_xfer_len;
714 /* rx_io_size tells the f/w how large a response buffer we have */
715 io_req->task_params->rx_io_size = PAGE_SIZE;
716 io_req->task_params->conn_cid = fcport->fw_cid;
717 io_req->task_params->itid = io_req->xid;
718 /* Return middle path commands on CQ 0 */
719 io_req->task_params->cq_rss_number = 0;
720 io_req->task_params->is_tape_device = fcport->dev_type;
721
722 fc_hdr = &(mp_req->req_fc_hdr);
723 /* Set OX_ID and RX_ID based on driver task id */
724 fc_hdr->fh_ox_id = io_req->xid;
725 fc_hdr->fh_rx_id = htons(0xffff);
726
727 /* Set up FC header information */
728 task_fc_hdr.parameter = fc_hdr->fh_parm_offset;
729 task_fc_hdr.r_ctl = fc_hdr->fh_r_ctl;
730 task_fc_hdr.type = fc_hdr->fh_type;
731 task_fc_hdr.cs_ctl = fc_hdr->fh_cs_ctl;
732 task_fc_hdr.df_ctl = fc_hdr->fh_df_ctl;
733 task_fc_hdr.rx_id = fc_hdr->fh_rx_id;
734 task_fc_hdr.ox_id = fc_hdr->fh_ox_id;
735
736 /* Set up s/g list parameters for request buffer */
737 tx_sgl_task_params.sgl = mp_req->mp_req_bd;
738 tx_sgl_task_params.sgl_phys_addr.lo = U64_LO(mp_req->mp_req_bd_dma);
739 tx_sgl_task_params.sgl_phys_addr.hi = U64_HI(mp_req->mp_req_bd_dma);
740 tx_sgl_task_params.num_sges = 1;
741 /* Set PAGE_SIZE for now since sg element is that size ??? */
742 tx_sgl_task_params.total_buffer_size = io_req->data_xfer_len;
743 tx_sgl_task_params.small_mid_sge = 0;
744
745 /* Set up s/g list parameters for request buffer */
746 rx_sgl_task_params.sgl = mp_req->mp_resp_bd;
747 rx_sgl_task_params.sgl_phys_addr.lo = U64_LO(mp_req->mp_resp_bd_dma);
748 rx_sgl_task_params.sgl_phys_addr.hi = U64_HI(mp_req->mp_resp_bd_dma);
749 rx_sgl_task_params.num_sges = 1;
750 /* Set PAGE_SIZE for now since sg element is that size ??? */
751 rx_sgl_task_params.total_buffer_size = PAGE_SIZE;
752 rx_sgl_task_params.small_mid_sge = 0;
753
754
755 /*
756 * Last arg is 0 as previous code did not set that we wanted the
757 * fc header information.
758 */
759 init_initiator_midpath_unsolicited_fcoe_task(io_req->task_params,
760 &task_fc_hdr,
761 &tx_sgl_task_params,
762 &rx_sgl_task_params, 0);
763 }
764
765 /* Presumed that fcport->rport_lock is held */
766 u16 qedf_get_sqe_idx(struct qedf_rport *fcport)
767 {
768 uint16_t total_sqe = (fcport->sq_mem_size)/(sizeof(struct fcoe_wqe));
769 u16 rval;
770
771 rval = fcport->sq_prod_idx;
772
773 /* Adjust ring index */
774 fcport->sq_prod_idx++;
775 fcport->fw_sq_prod_idx++;
776 if (fcport->sq_prod_idx == total_sqe)
777 fcport->sq_prod_idx = 0;
778
779 return rval;
780 }
781
782 void qedf_ring_doorbell(struct qedf_rport *fcport)
783 {
784 struct fcoe_db_data dbell = { 0 };
785
786 dbell.agg_flags = 0;
787
788 dbell.params |= DB_DEST_XCM << FCOE_DB_DATA_DEST_SHIFT;
789 dbell.params |= DB_AGG_CMD_SET << FCOE_DB_DATA_AGG_CMD_SHIFT;
790 dbell.params |= DQ_XCM_FCOE_SQ_PROD_CMD <<
791 FCOE_DB_DATA_AGG_VAL_SEL_SHIFT;
792
793 dbell.sq_prod = fcport->fw_sq_prod_idx;
794 /* wmb makes sure that the BDs data is updated before updating the
795 * producer, otherwise FW may read old data from the BDs.
796 */
797 wmb();
798 barrier();
799 writel(*(u32 *)&dbell, fcport->p_doorbell);
800 /*
801 * Fence required to flush the write combined buffer, since another
802 * CPU may write to the same doorbell address and data may be lost
803 * due to relaxed order nature of write combined bar.
804 */
805 wmb();
806 }
807
808 static void qedf_trace_io(struct qedf_rport *fcport, struct qedf_ioreq *io_req,
809 int8_t direction)
810 {
811 struct qedf_ctx *qedf = fcport->qedf;
812 struct qedf_io_log *io_log;
813 struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
814 unsigned long flags;
815 uint8_t op;
816
817 spin_lock_irqsave(&qedf->io_trace_lock, flags);
818
819 io_log = &qedf->io_trace_buf[qedf->io_trace_idx];
820 io_log->direction = direction;
821 io_log->task_id = io_req->xid;
822 io_log->port_id = fcport->rdata->ids.port_id;
823 io_log->lun = sc_cmd->device->lun;
824 io_log->op = op = sc_cmd->cmnd[0];
825 io_log->lba[0] = sc_cmd->cmnd[2];
826 io_log->lba[1] = sc_cmd->cmnd[3];
827 io_log->lba[2] = sc_cmd->cmnd[4];
828 io_log->lba[3] = sc_cmd->cmnd[5];
829 io_log->bufflen = scsi_bufflen(sc_cmd);
830 io_log->sg_count = scsi_sg_count(sc_cmd);
831 io_log->result = sc_cmd->result;
832 io_log->jiffies = jiffies;
833 io_log->refcount = kref_read(&io_req->refcount);
834
835 if (direction == QEDF_IO_TRACE_REQ) {
836 /* For requests we only care abot the submission CPU */
837 io_log->req_cpu = io_req->cpu;
838 io_log->int_cpu = 0;
839 io_log->rsp_cpu = 0;
840 } else if (direction == QEDF_IO_TRACE_RSP) {
841 io_log->req_cpu = io_req->cpu;
842 io_log->int_cpu = io_req->int_cpu;
843 io_log->rsp_cpu = smp_processor_id();
844 }
845
846 io_log->sge_type = io_req->sge_type;
847
848 qedf->io_trace_idx++;
849 if (qedf->io_trace_idx == QEDF_IO_TRACE_SIZE)
850 qedf->io_trace_idx = 0;
851
852 spin_unlock_irqrestore(&qedf->io_trace_lock, flags);
853 }
854
855 int qedf_post_io_req(struct qedf_rport *fcport, struct qedf_ioreq *io_req)
856 {
857 struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
858 struct Scsi_Host *host = sc_cmd->device->host;
859 struct fc_lport *lport = shost_priv(host);
860 struct qedf_ctx *qedf = lport_priv(lport);
861 struct e4_fcoe_task_context *task_ctx;
862 u16 xid;
863 enum fcoe_task_type req_type = 0;
864 struct fcoe_wqe *sqe;
865 u16 sqe_idx;
866
867 /* Initialize rest of io_req fileds */
868 io_req->data_xfer_len = scsi_bufflen(sc_cmd);
869 sc_cmd->SCp.ptr = (char *)io_req;
870 io_req->sge_type = QEDF_IOREQ_FAST_SGE; /* Assume fast SGL by default */
871
872 /* Record which cpu this request is associated with */
873 io_req->cpu = smp_processor_id();
874
875 if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
876 req_type = FCOE_TASK_TYPE_READ_INITIATOR;
877 io_req->io_req_flags = QEDF_READ;
878 qedf->input_requests++;
879 } else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
880 req_type = FCOE_TASK_TYPE_WRITE_INITIATOR;
881 io_req->io_req_flags = QEDF_WRITE;
882 qedf->output_requests++;
883 } else {
884 io_req->io_req_flags = 0;
885 qedf->control_requests++;
886 }
887
888 xid = io_req->xid;
889
890 /* Build buffer descriptor list for firmware from sg list */
891 if (qedf_build_bd_list_from_sg(io_req)) {
892 QEDF_ERR(&(qedf->dbg_ctx), "BD list creation failed.\n");
893 /* Release cmd will release io_req, but sc_cmd is assigned */
894 io_req->sc_cmd = NULL;
895 kref_put(&io_req->refcount, qedf_release_cmd);
896 return -EAGAIN;
897 }
898
899 if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags) ||
900 test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
901 QEDF_ERR(&(qedf->dbg_ctx), "Session not offloaded yet.\n");
902 /* Release cmd will release io_req, but sc_cmd is assigned */
903 io_req->sc_cmd = NULL;
904 kref_put(&io_req->refcount, qedf_release_cmd);
905 return -EINVAL;
906 }
907
908 /* Record LUN number for later use if we neeed them */
909 io_req->lun = (int)sc_cmd->device->lun;
910
911 /* Obtain free SQE */
912 sqe_idx = qedf_get_sqe_idx(fcport);
913 sqe = &fcport->sq[sqe_idx];
914 memset(sqe, 0, sizeof(struct fcoe_wqe));
915
916 /* Get the task context */
917 task_ctx = qedf_get_task_mem(&qedf->tasks, xid);
918 if (!task_ctx) {
919 QEDF_WARN(&(qedf->dbg_ctx), "task_ctx is NULL, xid=%d.\n",
920 xid);
921 /* Release cmd will release io_req, but sc_cmd is assigned */
922 io_req->sc_cmd = NULL;
923 kref_put(&io_req->refcount, qedf_release_cmd);
924 return -EINVAL;
925 }
926
927 qedf_init_task(fcport, lport, io_req, task_ctx, sqe);
928
929 /* Ring doorbell */
930 qedf_ring_doorbell(fcport);
931
932 /* Set that command is with the firmware now */
933 set_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
934
935 if (qedf_io_tracing && io_req->sc_cmd)
936 qedf_trace_io(fcport, io_req, QEDF_IO_TRACE_REQ);
937
938 return false;
939 }
940
941 int
942 qedf_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc_cmd)
943 {
944 struct fc_lport *lport = shost_priv(host);
945 struct qedf_ctx *qedf = lport_priv(lport);
946 struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
947 struct fc_rport_libfc_priv *rp = rport->dd_data;
948 struct qedf_rport *fcport;
949 struct qedf_ioreq *io_req;
950 int rc = 0;
951 int rval;
952 unsigned long flags = 0;
953 int num_sgs = 0;
954
955 num_sgs = scsi_sg_count(sc_cmd);
956 if (scsi_sg_count(sc_cmd) > QEDF_MAX_BDS_PER_CMD) {
957 QEDF_ERR(&qedf->dbg_ctx,
958 "Number of SG elements %d exceeds what hardware limitation of %d.\n",
959 num_sgs, QEDF_MAX_BDS_PER_CMD);
960 sc_cmd->result = DID_ERROR;
961 sc_cmd->scsi_done(sc_cmd);
962 return 0;
963 }
964
965 if (test_bit(QEDF_UNLOADING, &qedf->flags) ||
966 test_bit(QEDF_DBG_STOP_IO, &qedf->flags)) {
967 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
968 "Returning DNC as unloading or stop io, flags 0x%lx.\n",
969 qedf->flags);
970 sc_cmd->result = DID_NO_CONNECT << 16;
971 sc_cmd->scsi_done(sc_cmd);
972 return 0;
973 }
974
975 if (!qedf->pdev->msix_enabled) {
976 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
977 "Completing sc_cmd=%p DID_NO_CONNECT as MSI-X is not enabled.\n",
978 sc_cmd);
979 sc_cmd->result = DID_NO_CONNECT << 16;
980 sc_cmd->scsi_done(sc_cmd);
981 return 0;
982 }
983
984 rval = fc_remote_port_chkready(rport);
985 if (rval) {
986 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
987 "fc_remote_port_chkready failed=0x%x for port_id=0x%06x.\n",
988 rval, rport->port_id);
989 sc_cmd->result = rval;
990 sc_cmd->scsi_done(sc_cmd);
991 return 0;
992 }
993
994 /* Retry command if we are doing a qed drain operation */
995 if (test_bit(QEDF_DRAIN_ACTIVE, &qedf->flags)) {
996 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO, "Drain active.\n");
997 rc = SCSI_MLQUEUE_HOST_BUSY;
998 goto exit_qcmd;
999 }
1000
1001 if (lport->state != LPORT_ST_READY ||
1002 atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
1003 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO, "Link down.\n");
1004 rc = SCSI_MLQUEUE_HOST_BUSY;
1005 goto exit_qcmd;
1006 }
1007
1008 /* rport and tgt are allocated together, so tgt should be non-NULL */
1009 fcport = (struct qedf_rport *)&rp[1];
1010
1011 if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags) ||
1012 test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
1013 /*
1014 * Session is not offloaded yet. Let SCSI-ml retry
1015 * the command.
1016 */
1017 rc = SCSI_MLQUEUE_TARGET_BUSY;
1018 goto exit_qcmd;
1019 }
1020
1021 atomic_inc(&fcport->ios_to_queue);
1022
1023 if (fcport->retry_delay_timestamp) {
1024 if (time_after(jiffies, fcport->retry_delay_timestamp)) {
1025 fcport->retry_delay_timestamp = 0;
1026 } else {
1027 /* If retry_delay timer is active, flow off the ML */
1028 rc = SCSI_MLQUEUE_TARGET_BUSY;
1029 atomic_dec(&fcport->ios_to_queue);
1030 goto exit_qcmd;
1031 }
1032 }
1033
1034 io_req = qedf_alloc_cmd(fcport, QEDF_SCSI_CMD);
1035 if (!io_req) {
1036 rc = SCSI_MLQUEUE_HOST_BUSY;
1037 atomic_dec(&fcport->ios_to_queue);
1038 goto exit_qcmd;
1039 }
1040
1041 io_req->sc_cmd = sc_cmd;
1042
1043 /* Take fcport->rport_lock for posting to fcport send queue */
1044 spin_lock_irqsave(&fcport->rport_lock, flags);
1045 if (qedf_post_io_req(fcport, io_req)) {
1046 QEDF_WARN(&(qedf->dbg_ctx), "Unable to post io_req\n");
1047 /* Return SQE to pool */
1048 atomic_inc(&fcport->free_sqes);
1049 rc = SCSI_MLQUEUE_HOST_BUSY;
1050 }
1051 spin_unlock_irqrestore(&fcport->rport_lock, flags);
1052 atomic_dec(&fcport->ios_to_queue);
1053
1054 exit_qcmd:
1055 return rc;
1056 }
1057
1058 static void qedf_parse_fcp_rsp(struct qedf_ioreq *io_req,
1059 struct fcoe_cqe_rsp_info *fcp_rsp)
1060 {
1061 struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
1062 struct qedf_ctx *qedf = io_req->fcport->qedf;
1063 u8 rsp_flags = fcp_rsp->rsp_flags.flags;
1064 int fcp_sns_len = 0;
1065 int fcp_rsp_len = 0;
1066 uint8_t *rsp_info, *sense_data;
1067
1068 io_req->fcp_status = FC_GOOD;
1069 io_req->fcp_resid = 0;
1070 if (rsp_flags & (FCOE_FCP_RSP_FLAGS_FCP_RESID_OVER |
1071 FCOE_FCP_RSP_FLAGS_FCP_RESID_UNDER))
1072 io_req->fcp_resid = fcp_rsp->fcp_resid;
1073
1074 io_req->scsi_comp_flags = rsp_flags;
1075 CMD_SCSI_STATUS(sc_cmd) = io_req->cdb_status =
1076 fcp_rsp->scsi_status_code;
1077
1078 if (rsp_flags &
1079 FCOE_FCP_RSP_FLAGS_FCP_RSP_LEN_VALID)
1080 fcp_rsp_len = fcp_rsp->fcp_rsp_len;
1081
1082 if (rsp_flags &
1083 FCOE_FCP_RSP_FLAGS_FCP_SNS_LEN_VALID)
1084 fcp_sns_len = fcp_rsp->fcp_sns_len;
1085
1086 io_req->fcp_rsp_len = fcp_rsp_len;
1087 io_req->fcp_sns_len = fcp_sns_len;
1088 rsp_info = sense_data = io_req->sense_buffer;
1089
1090 /* fetch fcp_rsp_code */
1091 if ((fcp_rsp_len == 4) || (fcp_rsp_len == 8)) {
1092 /* Only for task management function */
1093 io_req->fcp_rsp_code = rsp_info[3];
1094 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
1095 "fcp_rsp_code = %d\n", io_req->fcp_rsp_code);
1096 /* Adjust sense-data location. */
1097 sense_data += fcp_rsp_len;
1098 }
1099
1100 if (fcp_sns_len > SCSI_SENSE_BUFFERSIZE) {
1101 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
1102 "Truncating sense buffer\n");
1103 fcp_sns_len = SCSI_SENSE_BUFFERSIZE;
1104 }
1105
1106 /* The sense buffer can be NULL for TMF commands */
1107 if (sc_cmd->sense_buffer) {
1108 memset(sc_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1109 if (fcp_sns_len)
1110 memcpy(sc_cmd->sense_buffer, sense_data,
1111 fcp_sns_len);
1112 }
1113 }
1114
1115 static void qedf_unmap_sg_list(struct qedf_ctx *qedf, struct qedf_ioreq *io_req)
1116 {
1117 struct scsi_cmnd *sc = io_req->sc_cmd;
1118
1119 if (io_req->bd_tbl->bd_valid && sc && scsi_sg_count(sc)) {
1120 dma_unmap_sg(&qedf->pdev->dev, scsi_sglist(sc),
1121 scsi_sg_count(sc), sc->sc_data_direction);
1122 io_req->bd_tbl->bd_valid = 0;
1123 }
1124 }
1125
1126 void qedf_scsi_completion(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
1127 struct qedf_ioreq *io_req)
1128 {
1129 u16 xid;
1130 struct e4_fcoe_task_context *task_ctx;
1131 struct scsi_cmnd *sc_cmd;
1132 struct fcoe_cqe_rsp_info *fcp_rsp;
1133 struct qedf_rport *fcport;
1134 int refcount;
1135 u16 scope, qualifier = 0;
1136 u8 fw_residual_flag = 0;
1137
1138 if (!io_req)
1139 return;
1140 if (!cqe)
1141 return;
1142
1143 if (!test_bit(QEDF_CMD_OUTSTANDING, &io_req->flags) ||
1144 test_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags) ||
1145 test_bit(QEDF_CMD_IN_ABORT, &io_req->flags)) {
1146 QEDF_ERR(&qedf->dbg_ctx,
1147 "io_req xid=0x%x already in cleanup or abort processing or already completed.\n",
1148 io_req->xid);
1149 return;
1150 }
1151
1152 xid = io_req->xid;
1153 task_ctx = qedf_get_task_mem(&qedf->tasks, xid);
1154 sc_cmd = io_req->sc_cmd;
1155 fcp_rsp = &cqe->cqe_info.rsp_info;
1156
1157 if (!sc_cmd) {
1158 QEDF_WARN(&(qedf->dbg_ctx), "sc_cmd is NULL!\n");
1159 return;
1160 }
1161
1162 if (!sc_cmd->SCp.ptr) {
1163 QEDF_WARN(&(qedf->dbg_ctx), "SCp.ptr is NULL, returned in "
1164 "another context.\n");
1165 return;
1166 }
1167
1168 if (!sc_cmd->device) {
1169 QEDF_ERR(&qedf->dbg_ctx,
1170 "Device for sc_cmd %p is NULL.\n", sc_cmd);
1171 return;
1172 }
1173
1174 if (!sc_cmd->request) {
1175 QEDF_WARN(&(qedf->dbg_ctx), "sc_cmd->request is NULL, "
1176 "sc_cmd=%p.\n", sc_cmd);
1177 return;
1178 }
1179
1180 if (!sc_cmd->request->q) {
1181 QEDF_WARN(&(qedf->dbg_ctx), "request->q is NULL so request "
1182 "is not valid, sc_cmd=%p.\n", sc_cmd);
1183 return;
1184 }
1185
1186 fcport = io_req->fcport;
1187
1188 /*
1189 * When flush is active, let the cmds be completed from the cleanup
1190 * context
1191 */
1192 if (test_bit(QEDF_RPORT_IN_TARGET_RESET, &fcport->flags) ||
1193 (test_bit(QEDF_RPORT_IN_LUN_RESET, &fcport->flags) &&
1194 sc_cmd->device->lun == (u64)fcport->lun_reset_lun)) {
1195 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1196 "Dropping good completion xid=0x%x as fcport is flushing",
1197 io_req->xid);
1198 return;
1199 }
1200
1201 qedf_parse_fcp_rsp(io_req, fcp_rsp);
1202
1203 qedf_unmap_sg_list(qedf, io_req);
1204
1205 /* Check for FCP transport error */
1206 if (io_req->fcp_rsp_len > 3 && io_req->fcp_rsp_code) {
1207 QEDF_ERR(&(qedf->dbg_ctx),
1208 "FCP I/O protocol failure xid=0x%x fcp_rsp_len=%d "
1209 "fcp_rsp_code=%d.\n", io_req->xid, io_req->fcp_rsp_len,
1210 io_req->fcp_rsp_code);
1211 sc_cmd->result = DID_BUS_BUSY << 16;
1212 goto out;
1213 }
1214
1215 fw_residual_flag = GET_FIELD(cqe->cqe_info.rsp_info.fw_error_flags,
1216 FCOE_CQE_RSP_INFO_FW_UNDERRUN);
1217 if (fw_residual_flag) {
1218 QEDF_ERR(&qedf->dbg_ctx,
1219 "Firmware detected underrun: xid=0x%x fcp_rsp.flags=0x%02x fcp_resid=%d fw_residual=0x%x lba=%02x%02x%02x%02x.\n",
1220 io_req->xid, fcp_rsp->rsp_flags.flags,
1221 io_req->fcp_resid,
1222 cqe->cqe_info.rsp_info.fw_residual, sc_cmd->cmnd[2],
1223 sc_cmd->cmnd[3], sc_cmd->cmnd[4], sc_cmd->cmnd[5]);
1224
1225 if (io_req->cdb_status == 0)
1226 sc_cmd->result = (DID_ERROR << 16) | io_req->cdb_status;
1227 else
1228 sc_cmd->result = (DID_OK << 16) | io_req->cdb_status;
1229
1230 /*
1231 * Set resid to the whole buffer length so we won't try to resue
1232 * any previously data.
1233 */
1234 scsi_set_resid(sc_cmd, scsi_bufflen(sc_cmd));
1235 goto out;
1236 }
1237
1238 switch (io_req->fcp_status) {
1239 case FC_GOOD:
1240 if (io_req->cdb_status == 0) {
1241 /* Good I/O completion */
1242 sc_cmd->result = DID_OK << 16;
1243 } else {
1244 refcount = kref_read(&io_req->refcount);
1245 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
1246 "%d:0:%d:%lld xid=0x%0x op=0x%02x "
1247 "lba=%02x%02x%02x%02x cdb_status=%d "
1248 "fcp_resid=0x%x refcount=%d.\n",
1249 qedf->lport->host->host_no, sc_cmd->device->id,
1250 sc_cmd->device->lun, io_req->xid,
1251 sc_cmd->cmnd[0], sc_cmd->cmnd[2], sc_cmd->cmnd[3],
1252 sc_cmd->cmnd[4], sc_cmd->cmnd[5],
1253 io_req->cdb_status, io_req->fcp_resid,
1254 refcount);
1255 sc_cmd->result = (DID_OK << 16) | io_req->cdb_status;
1256
1257 if (io_req->cdb_status == SAM_STAT_TASK_SET_FULL ||
1258 io_req->cdb_status == SAM_STAT_BUSY) {
1259 /*
1260 * Check whether we need to set retry_delay at
1261 * all based on retry_delay module parameter
1262 * and the status qualifier.
1263 */
1264
1265 /* Upper 2 bits */
1266 scope = fcp_rsp->retry_delay_timer & 0xC000;
1267 /* Lower 14 bits */
1268 qualifier = fcp_rsp->retry_delay_timer & 0x3FFF;
1269
1270 if (qedf_retry_delay &&
1271 scope > 0 && qualifier > 0 &&
1272 qualifier <= 0x3FEF) {
1273 /* Check we don't go over the max */
1274 if (qualifier > QEDF_RETRY_DELAY_MAX)
1275 qualifier =
1276 QEDF_RETRY_DELAY_MAX;
1277 fcport->retry_delay_timestamp =
1278 jiffies + (qualifier * HZ / 10);
1279 }
1280 /* Record stats */
1281 if (io_req->cdb_status ==
1282 SAM_STAT_TASK_SET_FULL)
1283 qedf->task_set_fulls++;
1284 else
1285 qedf->busy++;
1286 }
1287 }
1288 if (io_req->fcp_resid)
1289 scsi_set_resid(sc_cmd, io_req->fcp_resid);
1290 break;
1291 default:
1292 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO, "fcp_status=%d.\n",
1293 io_req->fcp_status);
1294 break;
1295 }
1296
1297 out:
1298 if (qedf_io_tracing)
1299 qedf_trace_io(fcport, io_req, QEDF_IO_TRACE_RSP);
1300
1301 /*
1302 * We wait till the end of the function to clear the
1303 * outstanding bit in case we need to send an abort
1304 */
1305 clear_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
1306
1307 io_req->sc_cmd = NULL;
1308 sc_cmd->SCp.ptr = NULL;
1309 sc_cmd->scsi_done(sc_cmd);
1310 kref_put(&io_req->refcount, qedf_release_cmd);
1311 }
1312
1313 /* Return a SCSI command in some other context besides a normal completion */
1314 void qedf_scsi_done(struct qedf_ctx *qedf, struct qedf_ioreq *io_req,
1315 int result)
1316 {
1317 u16 xid;
1318 struct scsi_cmnd *sc_cmd;
1319 int refcount;
1320
1321 if (!io_req) {
1322 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO, "io_req is NULL\n");
1323 return;
1324 }
1325
1326 if (test_and_set_bit(QEDF_CMD_ERR_SCSI_DONE, &io_req->flags)) {
1327 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1328 "io_req:%p scsi_done handling already done\n",
1329 io_req);
1330 return;
1331 }
1332
1333 /*
1334 * We will be done with this command after this call so clear the
1335 * outstanding bit.
1336 */
1337 clear_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
1338
1339 xid = io_req->xid;
1340 sc_cmd = io_req->sc_cmd;
1341
1342 if (!sc_cmd) {
1343 QEDF_WARN(&(qedf->dbg_ctx), "sc_cmd is NULL!\n");
1344 return;
1345 }
1346
1347 if (!virt_addr_valid(sc_cmd)) {
1348 QEDF_ERR(&qedf->dbg_ctx, "sc_cmd=%p is not valid.", sc_cmd);
1349 goto bad_scsi_ptr;
1350 }
1351
1352 if (!sc_cmd->SCp.ptr) {
1353 QEDF_WARN(&(qedf->dbg_ctx), "SCp.ptr is NULL, returned in "
1354 "another context.\n");
1355 return;
1356 }
1357
1358 if (!sc_cmd->device) {
1359 QEDF_ERR(&qedf->dbg_ctx, "Device for sc_cmd %p is NULL.\n",
1360 sc_cmd);
1361 goto bad_scsi_ptr;
1362 }
1363
1364 if (!virt_addr_valid(sc_cmd->device)) {
1365 QEDF_ERR(&qedf->dbg_ctx,
1366 "Device pointer for sc_cmd %p is bad.\n", sc_cmd);
1367 goto bad_scsi_ptr;
1368 }
1369
1370 if (!sc_cmd->sense_buffer) {
1371 QEDF_ERR(&qedf->dbg_ctx,
1372 "sc_cmd->sense_buffer for sc_cmd %p is NULL.\n",
1373 sc_cmd);
1374 goto bad_scsi_ptr;
1375 }
1376
1377 if (!virt_addr_valid(sc_cmd->sense_buffer)) {
1378 QEDF_ERR(&qedf->dbg_ctx,
1379 "sc_cmd->sense_buffer for sc_cmd %p is bad.\n",
1380 sc_cmd);
1381 goto bad_scsi_ptr;
1382 }
1383
1384 if (!sc_cmd->scsi_done) {
1385 QEDF_ERR(&qedf->dbg_ctx,
1386 "sc_cmd->scsi_done for sc_cmd %p is NULL.\n",
1387 sc_cmd);
1388 goto bad_scsi_ptr;
1389 }
1390
1391 qedf_unmap_sg_list(qedf, io_req);
1392
1393 sc_cmd->result = result << 16;
1394 refcount = kref_read(&io_req->refcount);
1395 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO, "%d:0:%d:%lld: Completing "
1396 "sc_cmd=%p result=0x%08x op=0x%02x lba=0x%02x%02x%02x%02x, "
1397 "allowed=%d retries=%d refcount=%d.\n",
1398 qedf->lport->host->host_no, sc_cmd->device->id,
1399 sc_cmd->device->lun, sc_cmd, sc_cmd->result, sc_cmd->cmnd[0],
1400 sc_cmd->cmnd[2], sc_cmd->cmnd[3], sc_cmd->cmnd[4],
1401 sc_cmd->cmnd[5], sc_cmd->allowed, sc_cmd->retries,
1402 refcount);
1403
1404 /*
1405 * Set resid to the whole buffer length so we won't try to resue any
1406 * previously read data
1407 */
1408 scsi_set_resid(sc_cmd, scsi_bufflen(sc_cmd));
1409
1410 if (qedf_io_tracing)
1411 qedf_trace_io(io_req->fcport, io_req, QEDF_IO_TRACE_RSP);
1412
1413 io_req->sc_cmd = NULL;
1414 sc_cmd->SCp.ptr = NULL;
1415 sc_cmd->scsi_done(sc_cmd);
1416 kref_put(&io_req->refcount, qedf_release_cmd);
1417 return;
1418
1419 bad_scsi_ptr:
1420 /*
1421 * Clear the io_req->sc_cmd backpointer so we don't try to process
1422 * this again
1423 */
1424 io_req->sc_cmd = NULL;
1425 kref_put(&io_req->refcount, qedf_release_cmd); /* ID: 001 */
1426 }
1427
1428 /*
1429 * Handle warning type CQE completions. This is mainly used for REC timer
1430 * popping.
1431 */
1432 void qedf_process_warning_compl(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
1433 struct qedf_ioreq *io_req)
1434 {
1435 int rval, i;
1436 struct qedf_rport *fcport = io_req->fcport;
1437 u64 err_warn_bit_map;
1438 u8 err_warn = 0xff;
1439
1440 if (!cqe) {
1441 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1442 "cqe is NULL for io_req %p xid=0x%x\n",
1443 io_req, io_req->xid);
1444 return;
1445 }
1446
1447 QEDF_ERR(&(io_req->fcport->qedf->dbg_ctx), "Warning CQE, "
1448 "xid=0x%x\n", io_req->xid);
1449 QEDF_ERR(&(io_req->fcport->qedf->dbg_ctx),
1450 "err_warn_bitmap=%08x:%08x\n",
1451 le32_to_cpu(cqe->cqe_info.err_info.err_warn_bitmap_hi),
1452 le32_to_cpu(cqe->cqe_info.err_info.err_warn_bitmap_lo));
1453 QEDF_ERR(&(io_req->fcport->qedf->dbg_ctx), "tx_buff_off=%08x, "
1454 "rx_buff_off=%08x, rx_id=%04x\n",
1455 le32_to_cpu(cqe->cqe_info.err_info.tx_buf_off),
1456 le32_to_cpu(cqe->cqe_info.err_info.rx_buf_off),
1457 le32_to_cpu(cqe->cqe_info.err_info.rx_id));
1458
1459 /* Normalize the error bitmap value to an just an unsigned int */
1460 err_warn_bit_map = (u64)
1461 ((u64)cqe->cqe_info.err_info.err_warn_bitmap_hi << 32) |
1462 (u64)cqe->cqe_info.err_info.err_warn_bitmap_lo;
1463 for (i = 0; i < 64; i++) {
1464 if (err_warn_bit_map & (u64)((u64)1 << i)) {
1465 err_warn = i;
1466 break;
1467 }
1468 }
1469
1470 /* Check if REC TOV expired if this is a tape device */
1471 if (fcport->dev_type == QEDF_RPORT_TYPE_TAPE) {
1472 if (err_warn ==
1473 FCOE_WARNING_CODE_REC_TOV_TIMER_EXPIRATION) {
1474 QEDF_ERR(&(qedf->dbg_ctx), "REC timer expired.\n");
1475 if (!test_bit(QEDF_CMD_SRR_SENT, &io_req->flags)) {
1476 io_req->rx_buf_off =
1477 cqe->cqe_info.err_info.rx_buf_off;
1478 io_req->tx_buf_off =
1479 cqe->cqe_info.err_info.tx_buf_off;
1480 io_req->rx_id = cqe->cqe_info.err_info.rx_id;
1481 rval = qedf_send_rec(io_req);
1482 /*
1483 * We only want to abort the io_req if we
1484 * can't queue the REC command as we want to
1485 * keep the exchange open for recovery.
1486 */
1487 if (rval)
1488 goto send_abort;
1489 }
1490 return;
1491 }
1492 }
1493
1494 send_abort:
1495 init_completion(&io_req->abts_done);
1496 rval = qedf_initiate_abts(io_req, true);
1497 if (rval)
1498 QEDF_ERR(&(qedf->dbg_ctx), "Failed to queue ABTS.\n");
1499 }
1500
1501 /* Cleanup a command when we receive an error detection completion */
1502 void qedf_process_error_detect(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
1503 struct qedf_ioreq *io_req)
1504 {
1505 int rval;
1506
1507 if (!cqe) {
1508 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1509 "cqe is NULL for io_req %p\n", io_req);
1510 return;
1511 }
1512
1513 QEDF_ERR(&(io_req->fcport->qedf->dbg_ctx), "Error detection CQE, "
1514 "xid=0x%x\n", io_req->xid);
1515 QEDF_ERR(&(io_req->fcport->qedf->dbg_ctx),
1516 "err_warn_bitmap=%08x:%08x\n",
1517 le32_to_cpu(cqe->cqe_info.err_info.err_warn_bitmap_hi),
1518 le32_to_cpu(cqe->cqe_info.err_info.err_warn_bitmap_lo));
1519 QEDF_ERR(&(io_req->fcport->qedf->dbg_ctx), "tx_buff_off=%08x, "
1520 "rx_buff_off=%08x, rx_id=%04x\n",
1521 le32_to_cpu(cqe->cqe_info.err_info.tx_buf_off),
1522 le32_to_cpu(cqe->cqe_info.err_info.rx_buf_off),
1523 le32_to_cpu(cqe->cqe_info.err_info.rx_id));
1524
1525 if (qedf->stop_io_on_error) {
1526 qedf_stop_all_io(qedf);
1527 return;
1528 }
1529
1530 init_completion(&io_req->abts_done);
1531 rval = qedf_initiate_abts(io_req, true);
1532 if (rval)
1533 QEDF_ERR(&(qedf->dbg_ctx), "Failed to queue ABTS.\n");
1534 }
1535
1536 static void qedf_flush_els_req(struct qedf_ctx *qedf,
1537 struct qedf_ioreq *els_req)
1538 {
1539 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
1540 "Flushing ELS request xid=0x%x refcount=%d.\n", els_req->xid,
1541 kref_read(&els_req->refcount));
1542
1543 /*
1544 * Need to distinguish this from a timeout when calling the
1545 * els_req->cb_func.
1546 */
1547 els_req->event = QEDF_IOREQ_EV_ELS_FLUSH;
1548
1549 /* Cancel the timer */
1550 cancel_delayed_work_sync(&els_req->timeout_work);
1551
1552 /* Call callback function to complete command */
1553 if (els_req->cb_func && els_req->cb_arg) {
1554 els_req->cb_func(els_req->cb_arg);
1555 els_req->cb_arg = NULL;
1556 }
1557
1558 /* Release kref for original initiate_els */
1559 kref_put(&els_req->refcount, qedf_release_cmd);
1560 }
1561
1562 /* A value of -1 for lun is a wild card that means flush all
1563 * active SCSI I/Os for the target.
1564 */
1565 void qedf_flush_active_ios(struct qedf_rport *fcport, int lun)
1566 {
1567 struct qedf_ioreq *io_req;
1568 struct qedf_ctx *qedf;
1569 struct qedf_cmd_mgr *cmd_mgr;
1570 int i, rc;
1571 unsigned long flags;
1572 int flush_cnt = 0;
1573 int wait_cnt = 100;
1574 int refcount = 0;
1575
1576 if (!fcport) {
1577 QEDF_ERR(NULL, "fcport is NULL\n");
1578 return;
1579 }
1580
1581 /* Check that fcport is still offloaded */
1582 if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
1583 QEDF_ERR(NULL, "fcport is no longer offloaded.\n");
1584 return;
1585 }
1586
1587 qedf = fcport->qedf;
1588
1589 if (!qedf) {
1590 QEDF_ERR(NULL, "qedf is NULL.\n");
1591 return;
1592 }
1593
1594 /* Only wait for all commands to be queued in the Upload context */
1595 if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags) &&
1596 (lun == -1)) {
1597 while (atomic_read(&fcport->ios_to_queue)) {
1598 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1599 "Waiting for %d I/Os to be queued\n",
1600 atomic_read(&fcport->ios_to_queue));
1601 if (wait_cnt == 0) {
1602 QEDF_ERR(NULL,
1603 "%d IOs request could not be queued\n",
1604 atomic_read(&fcport->ios_to_queue));
1605 }
1606 msleep(20);
1607 wait_cnt--;
1608 }
1609 }
1610
1611 cmd_mgr = qedf->cmd_mgr;
1612
1613 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1614 "Flush active i/o's num=0x%x fcport=0x%p port_id=0x%06x scsi_id=%d.\n",
1615 atomic_read(&fcport->num_active_ios), fcport,
1616 fcport->rdata->ids.port_id, fcport->rport->scsi_target_id);
1617 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO, "Locking flush mutex.\n");
1618
1619 mutex_lock(&qedf->flush_mutex);
1620 if (lun == -1) {
1621 set_bit(QEDF_RPORT_IN_TARGET_RESET, &fcport->flags);
1622 } else {
1623 set_bit(QEDF_RPORT_IN_LUN_RESET, &fcport->flags);
1624 fcport->lun_reset_lun = lun;
1625 }
1626
1627 for (i = 0; i < FCOE_PARAMS_NUM_TASKS; i++) {
1628 io_req = &cmd_mgr->cmds[i];
1629
1630 if (!io_req)
1631 continue;
1632 if (!io_req->fcport)
1633 continue;
1634
1635 spin_lock_irqsave(&cmd_mgr->lock, flags);
1636
1637 if (io_req->alloc) {
1638 if (!test_bit(QEDF_CMD_OUTSTANDING, &io_req->flags)) {
1639 if (io_req->cmd_type == QEDF_SCSI_CMD)
1640 QEDF_ERR(&qedf->dbg_ctx,
1641 "Allocated but not queued, xid=0x%x\n",
1642 io_req->xid);
1643 }
1644 spin_unlock_irqrestore(&cmd_mgr->lock, flags);
1645 } else {
1646 spin_unlock_irqrestore(&cmd_mgr->lock, flags);
1647 continue;
1648 }
1649
1650 if (io_req->fcport != fcport)
1651 continue;
1652
1653 /* In case of ABTS, CMD_OUTSTANDING is cleared on ABTS response,
1654 * but RRQ is still pending.
1655 * Workaround: Within qedf_send_rrq, we check if the fcport is
1656 * NULL, and we drop the ref on the io_req to clean it up.
1657 */
1658 if (!test_bit(QEDF_CMD_OUTSTANDING, &io_req->flags)) {
1659 refcount = kref_read(&io_req->refcount);
1660 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1661 "Not outstanding, xid=0x%x, cmd_type=%d refcount=%d.\n",
1662 io_req->xid, io_req->cmd_type, refcount);
1663 /* If RRQ work has been queue, try to cancel it and
1664 * free the io_req
1665 */
1666 if (atomic_read(&io_req->state) ==
1667 QEDFC_CMD_ST_RRQ_WAIT) {
1668 if (cancel_delayed_work_sync
1669 (&io_req->rrq_work)) {
1670 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1671 "Putting reference for pending RRQ work xid=0x%x.\n",
1672 io_req->xid);
1673 /* ID: 003 */
1674 kref_put(&io_req->refcount,
1675 qedf_release_cmd);
1676 }
1677 }
1678 continue;
1679 }
1680
1681 /* Only consider flushing ELS during target reset */
1682 if (io_req->cmd_type == QEDF_ELS &&
1683 lun == -1) {
1684 rc = kref_get_unless_zero(&io_req->refcount);
1685 if (!rc) {
1686 QEDF_ERR(&(qedf->dbg_ctx),
1687 "Could not get kref for ELS io_req=0x%p xid=0x%x.\n",
1688 io_req, io_req->xid);
1689 continue;
1690 }
1691 flush_cnt++;
1692 qedf_flush_els_req(qedf, io_req);
1693 /*
1694 * Release the kref and go back to the top of the
1695 * loop.
1696 */
1697 goto free_cmd;
1698 }
1699
1700 if (io_req->cmd_type == QEDF_ABTS) {
1701 /* ID: 004 */
1702 rc = kref_get_unless_zero(&io_req->refcount);
1703 if (!rc) {
1704 QEDF_ERR(&(qedf->dbg_ctx),
1705 "Could not get kref for abort io_req=0x%p xid=0x%x.\n",
1706 io_req, io_req->xid);
1707 continue;
1708 }
1709 if (lun != -1 && io_req->lun != lun)
1710 goto free_cmd;
1711
1712 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1713 "Flushing abort xid=0x%x.\n", io_req->xid);
1714
1715 if (cancel_delayed_work_sync(&io_req->rrq_work)) {
1716 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1717 "Putting ref for cancelled RRQ work xid=0x%x.\n",
1718 io_req->xid);
1719 kref_put(&io_req->refcount, qedf_release_cmd);
1720 }
1721
1722 if (cancel_delayed_work_sync(&io_req->timeout_work)) {
1723 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1724 "Putting ref for cancelled tmo work xid=0x%x.\n",
1725 io_req->xid);
1726 qedf_initiate_cleanup(io_req, true);
1727 /* Notify eh_abort handler that ABTS is
1728 * complete
1729 */
1730 complete(&io_req->abts_done);
1731 clear_bit(QEDF_CMD_IN_ABORT, &io_req->flags);
1732 /* ID: 002 */
1733 kref_put(&io_req->refcount, qedf_release_cmd);
1734 }
1735 flush_cnt++;
1736 goto free_cmd;
1737 }
1738
1739 if (!io_req->sc_cmd)
1740 continue;
1741 if (!io_req->sc_cmd->device) {
1742 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1743 "Device backpointer NULL for sc_cmd=%p.\n",
1744 io_req->sc_cmd);
1745 /* Put reference for non-existent scsi_cmnd */
1746 io_req->sc_cmd = NULL;
1747 qedf_initiate_cleanup(io_req, false);
1748 kref_put(&io_req->refcount, qedf_release_cmd);
1749 continue;
1750 }
1751 if (lun > -1) {
1752 if (io_req->lun != lun)
1753 continue;
1754 }
1755
1756 /*
1757 * Use kref_get_unless_zero in the unlikely case the command
1758 * we're about to flush was completed in the normal SCSI path
1759 */
1760 rc = kref_get_unless_zero(&io_req->refcount);
1761 if (!rc) {
1762 QEDF_ERR(&(qedf->dbg_ctx), "Could not get kref for "
1763 "io_req=0x%p xid=0x%x\n", io_req, io_req->xid);
1764 continue;
1765 }
1766
1767 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
1768 "Cleanup xid=0x%x.\n", io_req->xid);
1769 flush_cnt++;
1770
1771 /* Cleanup task and return I/O mid-layer */
1772 qedf_initiate_cleanup(io_req, true);
1773
1774 free_cmd:
1775 kref_put(&io_req->refcount, qedf_release_cmd); /* ID: 004 */
1776 }
1777
1778 wait_cnt = 60;
1779 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1780 "Flushed 0x%x I/Os, active=0x%x.\n",
1781 flush_cnt, atomic_read(&fcport->num_active_ios));
1782 /* Only wait for all commands to complete in the Upload context */
1783 if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags) &&
1784 (lun == -1)) {
1785 while (atomic_read(&fcport->num_active_ios)) {
1786 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1787 "Flushed 0x%x I/Os, active=0x%x cnt=%d.\n",
1788 flush_cnt,
1789 atomic_read(&fcport->num_active_ios),
1790 wait_cnt);
1791 if (wait_cnt == 0) {
1792 QEDF_ERR(&qedf->dbg_ctx,
1793 "Flushed %d I/Os, active=%d.\n",
1794 flush_cnt,
1795 atomic_read(&fcport->num_active_ios));
1796 for (i = 0; i < FCOE_PARAMS_NUM_TASKS; i++) {
1797 io_req = &cmd_mgr->cmds[i];
1798 if (io_req->fcport &&
1799 io_req->fcport == fcport) {
1800 refcount =
1801 kref_read(&io_req->refcount);
1802 set_bit(QEDF_CMD_DIRTY,
1803 &io_req->flags);
1804 QEDF_ERR(&qedf->dbg_ctx,
1805 "Outstanding io_req =%p xid=0x%x flags=0x%lx, sc_cmd=%p refcount=%d cmd_type=%d.\n",
1806 io_req, io_req->xid,
1807 io_req->flags,
1808 io_req->sc_cmd,
1809 refcount,
1810 io_req->cmd_type);
1811 }
1812 }
1813 WARN_ON(1);
1814 break;
1815 }
1816 msleep(500);
1817 wait_cnt--;
1818 }
1819 }
1820
1821 clear_bit(QEDF_RPORT_IN_LUN_RESET, &fcport->flags);
1822 clear_bit(QEDF_RPORT_IN_TARGET_RESET, &fcport->flags);
1823 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO, "Unlocking flush mutex.\n");
1824 mutex_unlock(&qedf->flush_mutex);
1825 }
1826
1827 /*
1828 * Initiate a ABTS middle path command. Note that we don't have to initialize
1829 * the task context for an ABTS task.
1830 */
1831 int qedf_initiate_abts(struct qedf_ioreq *io_req, bool return_scsi_cmd_on_abts)
1832 {
1833 struct fc_lport *lport;
1834 struct qedf_rport *fcport = io_req->fcport;
1835 struct fc_rport_priv *rdata;
1836 struct qedf_ctx *qedf;
1837 u16 xid;
1838 u32 r_a_tov = 0;
1839 int rc = 0;
1840 unsigned long flags;
1841 struct fcoe_wqe *sqe;
1842 u16 sqe_idx;
1843 int refcount = 0;
1844
1845 /* Sanity check qedf_rport before dereferencing any pointers */
1846 if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
1847 QEDF_ERR(NULL, "tgt not offloaded\n");
1848 rc = 1;
1849 goto out;
1850 }
1851
1852 qedf = fcport->qedf;
1853 rdata = fcport->rdata;
1854
1855 if (!rdata || !kref_get_unless_zero(&rdata->kref)) {
1856 QEDF_ERR(&qedf->dbg_ctx, "stale rport\n");
1857 rc = 1;
1858 goto out;
1859 }
1860
1861 r_a_tov = rdata->r_a_tov;
1862 lport = qedf->lport;
1863
1864 if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
1865 QEDF_ERR(&(qedf->dbg_ctx), "link is not ready\n");
1866 rc = 1;
1867 goto drop_rdata_kref;
1868 }
1869
1870 if (atomic_read(&qedf->link_down_tmo_valid) > 0) {
1871 QEDF_ERR(&(qedf->dbg_ctx), "link_down_tmo active.\n");
1872 rc = 1;
1873 goto drop_rdata_kref;
1874 }
1875
1876 /* Ensure room on SQ */
1877 if (!atomic_read(&fcport->free_sqes)) {
1878 QEDF_ERR(&(qedf->dbg_ctx), "No SQ entries available\n");
1879 rc = 1;
1880 goto drop_rdata_kref;
1881 }
1882
1883 if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
1884 QEDF_ERR(&qedf->dbg_ctx, "fcport is uploading.\n");
1885 rc = 1;
1886 goto drop_rdata_kref;
1887 }
1888
1889 if (!test_bit(QEDF_CMD_OUTSTANDING, &io_req->flags) ||
1890 test_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags) ||
1891 test_bit(QEDF_CMD_IN_ABORT, &io_req->flags)) {
1892 QEDF_ERR(&qedf->dbg_ctx,
1893 "io_req xid=0x%x sc_cmd=%p already in cleanup or abort processing or already completed.\n",
1894 io_req->xid, io_req->sc_cmd);
1895 rc = 1;
1896 goto drop_rdata_kref;
1897 }
1898
1899 kref_get(&io_req->refcount);
1900
1901 xid = io_req->xid;
1902 qedf->control_requests++;
1903 qedf->packet_aborts++;
1904
1905 /* Set the command type to abort */
1906 io_req->cmd_type = QEDF_ABTS;
1907 io_req->return_scsi_cmd_on_abts = return_scsi_cmd_on_abts;
1908
1909 set_bit(QEDF_CMD_IN_ABORT, &io_req->flags);
1910 refcount = kref_read(&io_req->refcount);
1911 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_SCSI_TM,
1912 "ABTS io_req xid = 0x%x refcount=%d\n",
1913 xid, refcount);
1914
1915 qedf_cmd_timer_set(qedf, io_req, QEDF_ABORT_TIMEOUT);
1916
1917 spin_lock_irqsave(&fcport->rport_lock, flags);
1918
1919 sqe_idx = qedf_get_sqe_idx(fcport);
1920 sqe = &fcport->sq[sqe_idx];
1921 memset(sqe, 0, sizeof(struct fcoe_wqe));
1922 io_req->task_params->sqe = sqe;
1923
1924 init_initiator_abort_fcoe_task(io_req->task_params);
1925 qedf_ring_doorbell(fcport);
1926
1927 spin_unlock_irqrestore(&fcport->rport_lock, flags);
1928
1929 drop_rdata_kref:
1930 kref_put(&rdata->kref, fc_rport_destroy);
1931 out:
1932 return rc;
1933 }
1934
1935 void qedf_process_abts_compl(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
1936 struct qedf_ioreq *io_req)
1937 {
1938 uint32_t r_ctl;
1939 uint16_t xid;
1940 int rc;
1941 struct qedf_rport *fcport = io_req->fcport;
1942
1943 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_SCSI_TM, "Entered with xid = "
1944 "0x%x cmd_type = %d\n", io_req->xid, io_req->cmd_type);
1945
1946 xid = io_req->xid;
1947 r_ctl = cqe->cqe_info.abts_info.r_ctl;
1948
1949 /* This was added at a point when we were scheduling abts_compl &
1950 * cleanup_compl on different CPUs and there was a possibility of
1951 * the io_req to be freed from the other context before we got here.
1952 */
1953 if (!fcport) {
1954 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1955 "Dropping ABTS completion xid=0x%x as fcport is NULL",
1956 io_req->xid);
1957 return;
1958 }
1959
1960 /*
1961 * When flush is active, let the cmds be completed from the cleanup
1962 * context
1963 */
1964 if (test_bit(QEDF_RPORT_IN_TARGET_RESET, &fcport->flags) ||
1965 test_bit(QEDF_RPORT_IN_LUN_RESET, &fcport->flags)) {
1966 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
1967 "Dropping ABTS completion xid=0x%x as fcport is flushing",
1968 io_req->xid);
1969 return;
1970 }
1971
1972 if (!cancel_delayed_work(&io_req->timeout_work)) {
1973 QEDF_ERR(&qedf->dbg_ctx,
1974 "Wasn't able to cancel abts timeout work.\n");
1975 }
1976
1977 switch (r_ctl) {
1978 case FC_RCTL_BA_ACC:
1979 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_SCSI_TM,
1980 "ABTS response - ACC Send RRQ after R_A_TOV\n");
1981 io_req->event = QEDF_IOREQ_EV_ABORT_SUCCESS;
1982 rc = kref_get_unless_zero(&io_req->refcount); /* ID: 003 */
1983 if (!rc) {
1984 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_SCSI_TM,
1985 "kref is already zero so ABTS was already completed or flushed xid=0x%x.\n",
1986 io_req->xid);
1987 return;
1988 }
1989 /*
1990 * Dont release this cmd yet. It will be relesed
1991 * after we get RRQ response
1992 */
1993 queue_delayed_work(qedf->dpc_wq, &io_req->rrq_work,
1994 msecs_to_jiffies(qedf->lport->r_a_tov));
1995 atomic_set(&io_req->state, QEDFC_CMD_ST_RRQ_WAIT);
1996 break;
1997 /* For error cases let the cleanup return the command */
1998 case FC_RCTL_BA_RJT:
1999 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_SCSI_TM,
2000 "ABTS response - RJT\n");
2001 io_req->event = QEDF_IOREQ_EV_ABORT_FAILED;
2002 break;
2003 default:
2004 QEDF_ERR(&(qedf->dbg_ctx), "Unknown ABTS response\n");
2005 break;
2006 }
2007
2008 clear_bit(QEDF_CMD_IN_ABORT, &io_req->flags);
2009
2010 if (io_req->sc_cmd) {
2011 if (!io_req->return_scsi_cmd_on_abts)
2012 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_SCSI_TM,
2013 "Not call scsi_done for xid=0x%x.\n",
2014 io_req->xid);
2015 if (io_req->return_scsi_cmd_on_abts)
2016 qedf_scsi_done(qedf, io_req, DID_ERROR);
2017 }
2018
2019 /* Notify eh_abort handler that ABTS is complete */
2020 complete(&io_req->abts_done);
2021
2022 kref_put(&io_req->refcount, qedf_release_cmd);
2023 }
2024
2025 int qedf_init_mp_req(struct qedf_ioreq *io_req)
2026 {
2027 struct qedf_mp_req *mp_req;
2028 struct scsi_sge *mp_req_bd;
2029 struct scsi_sge *mp_resp_bd;
2030 struct qedf_ctx *qedf = io_req->fcport->qedf;
2031 dma_addr_t addr;
2032 uint64_t sz;
2033
2034 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_MP_REQ, "Entered.\n");
2035
2036 mp_req = (struct qedf_mp_req *)&(io_req->mp_req);
2037 memset(mp_req, 0, sizeof(struct qedf_mp_req));
2038
2039 if (io_req->cmd_type != QEDF_ELS) {
2040 mp_req->req_len = sizeof(struct fcp_cmnd);
2041 io_req->data_xfer_len = mp_req->req_len;
2042 } else
2043 mp_req->req_len = io_req->data_xfer_len;
2044
2045 mp_req->req_buf = dma_alloc_coherent(&qedf->pdev->dev, QEDF_PAGE_SIZE,
2046 &mp_req->req_buf_dma, GFP_KERNEL);
2047 if (!mp_req->req_buf) {
2048 QEDF_ERR(&(qedf->dbg_ctx), "Unable to alloc MP req buffer\n");
2049 qedf_free_mp_resc(io_req);
2050 return -ENOMEM;
2051 }
2052
2053 mp_req->resp_buf = dma_alloc_coherent(&qedf->pdev->dev,
2054 QEDF_PAGE_SIZE, &mp_req->resp_buf_dma, GFP_KERNEL);
2055 if (!mp_req->resp_buf) {
2056 QEDF_ERR(&(qedf->dbg_ctx), "Unable to alloc TM resp "
2057 "buffer\n");
2058 qedf_free_mp_resc(io_req);
2059 return -ENOMEM;
2060 }
2061
2062 /* Allocate and map mp_req_bd and mp_resp_bd */
2063 sz = sizeof(struct scsi_sge);
2064 mp_req->mp_req_bd = dma_alloc_coherent(&qedf->pdev->dev, sz,
2065 &mp_req->mp_req_bd_dma, GFP_KERNEL);
2066 if (!mp_req->mp_req_bd) {
2067 QEDF_ERR(&(qedf->dbg_ctx), "Unable to alloc MP req bd\n");
2068 qedf_free_mp_resc(io_req);
2069 return -ENOMEM;
2070 }
2071
2072 mp_req->mp_resp_bd = dma_alloc_coherent(&qedf->pdev->dev, sz,
2073 &mp_req->mp_resp_bd_dma, GFP_KERNEL);
2074 if (!mp_req->mp_resp_bd) {
2075 QEDF_ERR(&(qedf->dbg_ctx), "Unable to alloc MP resp bd\n");
2076 qedf_free_mp_resc(io_req);
2077 return -ENOMEM;
2078 }
2079
2080 /* Fill bd table */
2081 addr = mp_req->req_buf_dma;
2082 mp_req_bd = mp_req->mp_req_bd;
2083 mp_req_bd->sge_addr.lo = U64_LO(addr);
2084 mp_req_bd->sge_addr.hi = U64_HI(addr);
2085 mp_req_bd->sge_len = QEDF_PAGE_SIZE;
2086
2087 /*
2088 * MP buffer is either a task mgmt command or an ELS.
2089 * So the assumption is that it consumes a single bd
2090 * entry in the bd table
2091 */
2092 mp_resp_bd = mp_req->mp_resp_bd;
2093 addr = mp_req->resp_buf_dma;
2094 mp_resp_bd->sge_addr.lo = U64_LO(addr);
2095 mp_resp_bd->sge_addr.hi = U64_HI(addr);
2096 mp_resp_bd->sge_len = QEDF_PAGE_SIZE;
2097
2098 return 0;
2099 }
2100
2101 /*
2102 * Last ditch effort to clear the port if it's stuck. Used only after a
2103 * cleanup task times out.
2104 */
2105 static void qedf_drain_request(struct qedf_ctx *qedf)
2106 {
2107 if (test_bit(QEDF_DRAIN_ACTIVE, &qedf->flags)) {
2108 QEDF_ERR(&(qedf->dbg_ctx), "MCP drain already active.\n");
2109 return;
2110 }
2111
2112 /* Set bit to return all queuecommand requests as busy */
2113 set_bit(QEDF_DRAIN_ACTIVE, &qedf->flags);
2114
2115 /* Call qed drain request for function. Should be synchronous */
2116 qed_ops->common->drain(qedf->cdev);
2117
2118 /* Settle time for CQEs to be returned */
2119 msleep(100);
2120
2121 /* Unplug and continue */
2122 clear_bit(QEDF_DRAIN_ACTIVE, &qedf->flags);
2123 }
2124
2125 /*
2126 * Returns SUCCESS if the cleanup task does not timeout, otherwise return
2127 * FAILURE.
2128 */
2129 int qedf_initiate_cleanup(struct qedf_ioreq *io_req,
2130 bool return_scsi_cmd_on_abts)
2131 {
2132 struct qedf_rport *fcport;
2133 struct qedf_ctx *qedf;
2134 uint16_t xid;
2135 struct e4_fcoe_task_context *task;
2136 int tmo = 0;
2137 int rc = SUCCESS;
2138 unsigned long flags;
2139 struct fcoe_wqe *sqe;
2140 u16 sqe_idx;
2141 int refcount = 0;
2142
2143 fcport = io_req->fcport;
2144 if (!fcport) {
2145 QEDF_ERR(NULL, "fcport is NULL.\n");
2146 return SUCCESS;
2147 }
2148
2149 /* Sanity check qedf_rport before dereferencing any pointers */
2150 if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
2151 QEDF_ERR(NULL, "tgt not offloaded\n");
2152 rc = 1;
2153 return SUCCESS;
2154 }
2155
2156 qedf = fcport->qedf;
2157 if (!qedf) {
2158 QEDF_ERR(NULL, "qedf is NULL.\n");
2159 return SUCCESS;
2160 }
2161
2162 if (!test_bit(QEDF_CMD_OUTSTANDING, &io_req->flags) ||
2163 test_and_set_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags)) {
2164 QEDF_ERR(&(qedf->dbg_ctx), "io_req xid=0x%x already in "
2165 "cleanup processing or already completed.\n",
2166 io_req->xid);
2167 return SUCCESS;
2168 }
2169 set_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags);
2170
2171 /* Ensure room on SQ */
2172 if (!atomic_read(&fcport->free_sqes)) {
2173 QEDF_ERR(&(qedf->dbg_ctx), "No SQ entries available\n");
2174 /* Need to make sure we clear the flag since it was set */
2175 clear_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags);
2176 return FAILED;
2177 }
2178
2179 if (io_req->cmd_type == QEDF_CLEANUP) {
2180 QEDF_ERR(&qedf->dbg_ctx,
2181 "io_req=0x%x is already a cleanup command cmd_type=%d.\n",
2182 io_req->xid, io_req->cmd_type);
2183 clear_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags);
2184 return SUCCESS;
2185 }
2186
2187 refcount = kref_read(&io_req->refcount);
2188
2189 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_IO,
2190 "Entered xid=0x%x sc_cmd=%p cmd_type=%d flags=0x%lx refcount=%d fcport=%p port_id=0x%06x\n",
2191 io_req->xid, io_req->sc_cmd, io_req->cmd_type, io_req->flags,
2192 refcount, fcport, fcport->rdata->ids.port_id);
2193
2194 /* Cleanup cmds re-use the same TID as the original I/O */
2195 xid = io_req->xid;
2196 io_req->cmd_type = QEDF_CLEANUP;
2197 io_req->return_scsi_cmd_on_abts = return_scsi_cmd_on_abts;
2198
2199 task = qedf_get_task_mem(&qedf->tasks, xid);
2200
2201 init_completion(&io_req->cleanup_done);
2202
2203 spin_lock_irqsave(&fcport->rport_lock, flags);
2204
2205 sqe_idx = qedf_get_sqe_idx(fcport);
2206 sqe = &fcport->sq[sqe_idx];
2207 memset(sqe, 0, sizeof(struct fcoe_wqe));
2208 io_req->task_params->sqe = sqe;
2209
2210 init_initiator_cleanup_fcoe_task(io_req->task_params);
2211 qedf_ring_doorbell(fcport);
2212
2213 spin_unlock_irqrestore(&fcport->rport_lock, flags);
2214
2215 tmo = wait_for_completion_timeout(&io_req->cleanup_done,
2216 QEDF_CLEANUP_TIMEOUT * HZ);
2217
2218 if (!tmo) {
2219 rc = FAILED;
2220 /* Timeout case */
2221 QEDF_ERR(&(qedf->dbg_ctx), "Cleanup command timeout, "
2222 "xid=%x.\n", io_req->xid);
2223 clear_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags);
2224 /* Issue a drain request if cleanup task times out */
2225 QEDF_ERR(&(qedf->dbg_ctx), "Issuing MCP drain request.\n");
2226 qedf_drain_request(qedf);
2227 }
2228
2229 /* If it TASK MGMT handle it, reference will be decreased
2230 * in qedf_execute_tmf
2231 */
2232 if (io_req->tm_flags == FCP_TMF_LUN_RESET ||
2233 io_req->tm_flags == FCP_TMF_TGT_RESET) {
2234 clear_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
2235 io_req->sc_cmd = NULL;
2236 complete(&io_req->tm_done);
2237 }
2238
2239 if (io_req->sc_cmd) {
2240 if (!io_req->return_scsi_cmd_on_abts)
2241 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_SCSI_TM,
2242 "Not call scsi_done for xid=0x%x.\n",
2243 io_req->xid);
2244 if (io_req->return_scsi_cmd_on_abts)
2245 qedf_scsi_done(qedf, io_req, DID_ERROR);
2246 }
2247
2248 if (rc == SUCCESS)
2249 io_req->event = QEDF_IOREQ_EV_CLEANUP_SUCCESS;
2250 else
2251 io_req->event = QEDF_IOREQ_EV_CLEANUP_FAILED;
2252
2253 return rc;
2254 }
2255
2256 void qedf_process_cleanup_compl(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
2257 struct qedf_ioreq *io_req)
2258 {
2259 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO, "Entered xid = 0x%x\n",
2260 io_req->xid);
2261
2262 clear_bit(QEDF_CMD_IN_CLEANUP, &io_req->flags);
2263
2264 /* Complete so we can finish cleaning up the I/O */
2265 complete(&io_req->cleanup_done);
2266 }
2267
2268 static int qedf_execute_tmf(struct qedf_rport *fcport, struct scsi_cmnd *sc_cmd,
2269 uint8_t tm_flags)
2270 {
2271 struct qedf_ioreq *io_req;
2272 struct e4_fcoe_task_context *task;
2273 struct qedf_ctx *qedf = fcport->qedf;
2274 struct fc_lport *lport = qedf->lport;
2275 int rc = 0;
2276 uint16_t xid;
2277 int tmo = 0;
2278 int lun = 0;
2279 unsigned long flags;
2280 struct fcoe_wqe *sqe;
2281 u16 sqe_idx;
2282
2283 if (!sc_cmd) {
2284 QEDF_ERR(&qedf->dbg_ctx, "sc_cmd is NULL\n");
2285 return FAILED;
2286 }
2287
2288 lun = (int)sc_cmd->device->lun;
2289 if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
2290 QEDF_ERR(&(qedf->dbg_ctx), "fcport not offloaded\n");
2291 rc = FAILED;
2292 goto no_flush;
2293 }
2294
2295 io_req = qedf_alloc_cmd(fcport, QEDF_TASK_MGMT_CMD);
2296 if (!io_req) {
2297 QEDF_ERR(&(qedf->dbg_ctx), "Failed TMF");
2298 rc = -EAGAIN;
2299 goto no_flush;
2300 }
2301
2302 if (tm_flags == FCP_TMF_LUN_RESET)
2303 qedf->lun_resets++;
2304 else if (tm_flags == FCP_TMF_TGT_RESET)
2305 qedf->target_resets++;
2306
2307 /* Initialize rest of io_req fields */
2308 io_req->sc_cmd = sc_cmd;
2309 io_req->fcport = fcport;
2310 io_req->cmd_type = QEDF_TASK_MGMT_CMD;
2311
2312 /* Record which cpu this request is associated with */
2313 io_req->cpu = smp_processor_id();
2314
2315 /* Set TM flags */
2316 io_req->io_req_flags = QEDF_READ;
2317 io_req->data_xfer_len = 0;
2318 io_req->tm_flags = tm_flags;
2319
2320 /* Default is to return a SCSI command when an error occurs */
2321 io_req->return_scsi_cmd_on_abts = false;
2322
2323 /* Obtain exchange id */
2324 xid = io_req->xid;
2325
2326 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_SCSI_TM, "TMF io_req xid = "
2327 "0x%x\n", xid);
2328
2329 /* Initialize task context for this IO request */
2330 task = qedf_get_task_mem(&qedf->tasks, xid);
2331
2332 init_completion(&io_req->tm_done);
2333
2334 spin_lock_irqsave(&fcport->rport_lock, flags);
2335
2336 sqe_idx = qedf_get_sqe_idx(fcport);
2337 sqe = &fcport->sq[sqe_idx];
2338 memset(sqe, 0, sizeof(struct fcoe_wqe));
2339
2340 qedf_init_task(fcport, lport, io_req, task, sqe);
2341 qedf_ring_doorbell(fcport);
2342
2343 spin_unlock_irqrestore(&fcport->rport_lock, flags);
2344
2345 set_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
2346 tmo = wait_for_completion_timeout(&io_req->tm_done,
2347 QEDF_TM_TIMEOUT * HZ);
2348
2349 if (!tmo) {
2350 rc = FAILED;
2351 QEDF_ERR(&(qedf->dbg_ctx), "wait for tm_cmpl timeout!\n");
2352 /* Clear outstanding bit since command timed out */
2353 clear_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
2354 io_req->sc_cmd = NULL;
2355 } else {
2356 /* Check TMF response code */
2357 if (io_req->fcp_rsp_code == 0)
2358 rc = SUCCESS;
2359 else
2360 rc = FAILED;
2361 }
2362 /*
2363 * Double check that fcport has not gone into an uploading state before
2364 * executing the command flush for the LUN/target.
2365 */
2366 if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
2367 QEDF_ERR(&qedf->dbg_ctx,
2368 "fcport is uploading, not executing flush.\n");
2369 goto no_flush;
2370 }
2371 /* We do not need this io_req any more */
2372 kref_put(&io_req->refcount, qedf_release_cmd);
2373
2374
2375 if (tm_flags == FCP_TMF_LUN_RESET)
2376 qedf_flush_active_ios(fcport, lun);
2377 else
2378 qedf_flush_active_ios(fcport, -1);
2379
2380 no_flush:
2381 if (rc != SUCCESS) {
2382 QEDF_ERR(&(qedf->dbg_ctx), "task mgmt command failed...\n");
2383 rc = FAILED;
2384 } else {
2385 QEDF_ERR(&(qedf->dbg_ctx), "task mgmt command success...\n");
2386 rc = SUCCESS;
2387 }
2388 return rc;
2389 }
2390
2391 int qedf_initiate_tmf(struct scsi_cmnd *sc_cmd, u8 tm_flags)
2392 {
2393 struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
2394 struct fc_rport_libfc_priv *rp = rport->dd_data;
2395 struct qedf_rport *fcport = (struct qedf_rport *)&rp[1];
2396 struct qedf_ctx *qedf;
2397 struct fc_lport *lport = shost_priv(sc_cmd->device->host);
2398 int rc = SUCCESS;
2399 int rval;
2400 struct qedf_ioreq *io_req = NULL;
2401 int ref_cnt = 0;
2402 struct fc_rport_priv *rdata = fcport->rdata;
2403
2404 QEDF_ERR(NULL,
2405 "tm_flags 0x%x sc_cmd %p op = 0x%02x target_id = 0x%x lun=%d\n",
2406 tm_flags, sc_cmd, sc_cmd->cmd_len ? sc_cmd->cmnd[0] : 0xff,
2407 rport->scsi_target_id, (int)sc_cmd->device->lun);
2408
2409 if (!rdata || !kref_get_unless_zero(&rdata->kref)) {
2410 QEDF_ERR(NULL, "stale rport\n");
2411 return FAILED;
2412 }
2413
2414 QEDF_ERR(NULL, "portid=%06x tm_flags =%s\n", rdata->ids.port_id,
2415 (tm_flags == FCP_TMF_TGT_RESET) ? "TARGET RESET" :
2416 "LUN RESET");
2417
2418 if (sc_cmd->SCp.ptr) {
2419 io_req = (struct qedf_ioreq *)sc_cmd->SCp.ptr;
2420 ref_cnt = kref_read(&io_req->refcount);
2421 QEDF_ERR(NULL,
2422 "orig io_req = %p xid = 0x%x ref_cnt = %d.\n",
2423 io_req, io_req->xid, ref_cnt);
2424 }
2425
2426 rval = fc_remote_port_chkready(rport);
2427 if (rval) {
2428 QEDF_ERR(NULL, "device_reset rport not ready\n");
2429 rc = FAILED;
2430 goto tmf_err;
2431 }
2432
2433 rc = fc_block_scsi_eh(sc_cmd);
2434 if (rc)
2435 goto tmf_err;
2436
2437 if (!fcport) {
2438 QEDF_ERR(NULL, "device_reset: rport is NULL\n");
2439 rc = FAILED;
2440 goto tmf_err;
2441 }
2442
2443 qedf = fcport->qedf;
2444
2445 if (!qedf) {
2446 QEDF_ERR(NULL, "qedf is NULL.\n");
2447 rc = FAILED;
2448 goto tmf_err;
2449 }
2450
2451 if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
2452 QEDF_ERR(&qedf->dbg_ctx, "Connection is getting uploaded.\n");
2453 rc = SUCCESS;
2454 goto tmf_err;
2455 }
2456
2457 if (test_bit(QEDF_UNLOADING, &qedf->flags) ||
2458 test_bit(QEDF_DBG_STOP_IO, &qedf->flags)) {
2459 rc = SUCCESS;
2460 goto tmf_err;
2461 }
2462
2463 if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
2464 QEDF_ERR(&(qedf->dbg_ctx), "link is not ready\n");
2465 rc = FAILED;
2466 goto tmf_err;
2467 }
2468
2469 if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
2470 if (!fcport->rdata)
2471 QEDF_ERR(&qedf->dbg_ctx, "fcport %p is uploading.\n",
2472 fcport);
2473 else
2474 QEDF_ERR(&qedf->dbg_ctx,
2475 "fcport %p port_id=%06x is uploading.\n",
2476 fcport, fcport->rdata->ids.port_id);
2477 rc = FAILED;
2478 goto tmf_err;
2479 }
2480
2481 rc = qedf_execute_tmf(fcport, sc_cmd, tm_flags);
2482
2483 tmf_err:
2484 kref_put(&rdata->kref, fc_rport_destroy);
2485 return rc;
2486 }
2487
2488 void qedf_process_tmf_compl(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
2489 struct qedf_ioreq *io_req)
2490 {
2491 struct fcoe_cqe_rsp_info *fcp_rsp;
2492
2493 clear_bit(QEDF_CMD_OUTSTANDING, &io_req->flags);
2494
2495 fcp_rsp = &cqe->cqe_info.rsp_info;
2496 qedf_parse_fcp_rsp(io_req, fcp_rsp);
2497
2498 io_req->sc_cmd = NULL;
2499 complete(&io_req->tm_done);
2500 }
2501
2502 void qedf_process_unsol_compl(struct qedf_ctx *qedf, uint16_t que_idx,
2503 struct fcoe_cqe *cqe)
2504 {
2505 unsigned long flags;
2506 uint16_t tmp;
2507 uint16_t pktlen = cqe->cqe_info.unsolic_info.pkt_len;
2508 u32 payload_len, crc;
2509 struct fc_frame_header *fh;
2510 struct fc_frame *fp;
2511 struct qedf_io_work *io_work;
2512 u32 bdq_idx;
2513 void *bdq_addr;
2514 struct scsi_bd *p_bd_info;
2515
2516 p_bd_info = &cqe->cqe_info.unsolic_info.bd_info;
2517 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_UNSOL,
2518 "address.hi=%x, address.lo=%x, opaque_data.hi=%x, opaque_data.lo=%x, bdq_prod_idx=%u, len=%u\n",
2519 le32_to_cpu(p_bd_info->address.hi),
2520 le32_to_cpu(p_bd_info->address.lo),
2521 le32_to_cpu(p_bd_info->opaque.fcoe_opaque.hi),
2522 le32_to_cpu(p_bd_info->opaque.fcoe_opaque.lo),
2523 qedf->bdq_prod_idx, pktlen);
2524
2525 bdq_idx = le32_to_cpu(p_bd_info->opaque.fcoe_opaque.lo);
2526 if (bdq_idx >= QEDF_BDQ_SIZE) {
2527 QEDF_ERR(&(qedf->dbg_ctx), "bdq_idx is out of range %d.\n",
2528 bdq_idx);
2529 goto increment_prod;
2530 }
2531
2532 bdq_addr = qedf->bdq[bdq_idx].buf_addr;
2533 if (!bdq_addr) {
2534 QEDF_ERR(&(qedf->dbg_ctx), "bdq_addr is NULL, dropping "
2535 "unsolicited packet.\n");
2536 goto increment_prod;
2537 }
2538
2539 if (qedf_dump_frames) {
2540 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_UNSOL,
2541 "BDQ frame is at addr=%p.\n", bdq_addr);
2542 print_hex_dump(KERN_WARNING, "bdq ", DUMP_PREFIX_OFFSET, 16, 1,
2543 (void *)bdq_addr, pktlen, false);
2544 }
2545
2546 /* Allocate frame */
2547 payload_len = pktlen - sizeof(struct fc_frame_header);
2548 fp = fc_frame_alloc(qedf->lport, payload_len);
2549 if (!fp) {
2550 QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate fp.\n");
2551 goto increment_prod;
2552 }
2553
2554 /* Copy data from BDQ buffer into fc_frame struct */
2555 fh = (struct fc_frame_header *)fc_frame_header_get(fp);
2556 memcpy(fh, (void *)bdq_addr, pktlen);
2557
2558 QEDF_WARN(&qedf->dbg_ctx,
2559 "Processing Unsolicated frame, src=%06x dest=%06x r_ctl=0x%x type=0x%x cmd=%02x\n",
2560 ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id), fh->fh_r_ctl,
2561 fh->fh_type, fc_frame_payload_op(fp));
2562
2563 /* Initialize the frame so libfc sees it as a valid frame */
2564 crc = fcoe_fc_crc(fp);
2565 fc_frame_init(fp);
2566 fr_dev(fp) = qedf->lport;
2567 fr_sof(fp) = FC_SOF_I3;
2568 fr_eof(fp) = FC_EOF_T;
2569 fr_crc(fp) = cpu_to_le32(~crc);
2570
2571 /*
2572 * We need to return the frame back up to libfc in a non-atomic
2573 * context
2574 */
2575 io_work = mempool_alloc(qedf->io_mempool, GFP_ATOMIC);
2576 if (!io_work) {
2577 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate "
2578 "work for I/O completion.\n");
2579 fc_frame_free(fp);
2580 goto increment_prod;
2581 }
2582 memset(io_work, 0, sizeof(struct qedf_io_work));
2583
2584 INIT_WORK(&io_work->work, qedf_fp_io_handler);
2585
2586 /* Copy contents of CQE for deferred processing */
2587 memcpy(&io_work->cqe, cqe, sizeof(struct fcoe_cqe));
2588
2589 io_work->qedf = qedf;
2590 io_work->fp = fp;
2591
2592 queue_work_on(smp_processor_id(), qedf_io_wq, &io_work->work);
2593 increment_prod:
2594 spin_lock_irqsave(&qedf->hba_lock, flags);
2595
2596 /* Increment producer to let f/w know we've handled the frame */
2597 qedf->bdq_prod_idx++;
2598
2599 /* Producer index wraps at uint16_t boundary */
2600 if (qedf->bdq_prod_idx == 0xffff)
2601 qedf->bdq_prod_idx = 0;
2602
2603 writew(qedf->bdq_prod_idx, qedf->bdq_primary_prod);
2604 tmp = readw(qedf->bdq_primary_prod);
2605 writew(qedf->bdq_prod_idx, qedf->bdq_secondary_prod);
2606 tmp = readw(qedf->bdq_secondary_prod);
2607
2608 spin_unlock_irqrestore(&qedf->hba_lock, flags);
2609 }
Linux with added FPC-III support