1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/pci.h>
22#include <linux/slab.h>
23#include <linux/interrupt.h>
24#include <linux/export.h>
25#include <linux/delay.h>
26#include <asm/unaligned.h>
27#include <linux/crc-t10dif.h>
28#include <net/checksum.h>
29
30#include <scsi/scsi.h>
31#include <scsi/scsi_device.h>
32#include <scsi/scsi_eh.h>
33#include <scsi/scsi_host.h>
34#include <scsi/scsi_tcq.h>
35#include <scsi/scsi_transport_fc.h>
36
37#include "lpfc_version.h"
38#include "lpfc_hw4.h"
39#include "lpfc_hw.h"
40#include "lpfc_sli.h"
41#include "lpfc_sli4.h"
42#include "lpfc_nl.h"
43#include "lpfc_disc.h"
44#include "lpfc.h"
45#include "lpfc_scsi.h"
46#include "lpfc_logmsg.h"
47#include "lpfc_crtn.h"
48#include "lpfc_vport.h"
49
50#define LPFC_RESET_WAIT 2
51#define LPFC_ABORT_WAIT 2
52
53int _dump_buf_done = 1;
54
55static char *dif_op_str[] = {
56 "PROT_NORMAL",
57 "PROT_READ_INSERT",
58 "PROT_WRITE_STRIP",
59 "PROT_READ_STRIP",
60 "PROT_WRITE_INSERT",
61 "PROT_READ_PASS",
62 "PROT_WRITE_PASS",
63};
64
65struct scsi_dif_tuple {
66 __be16 guard_tag;
67 __be16 app_tag;
68 __be32 ref_tag;
69};
70
71static struct lpfc_rport_data *
72lpfc_rport_data_from_scsi_device(struct scsi_device *sdev)
73{
74 struct lpfc_vport *vport = (struct lpfc_vport *)sdev->host->hostdata;
75
76 if (vport->phba->cfg_fof)
77 return ((struct lpfc_device_data *)sdev->hostdata)->rport_data;
78 else
79 return (struct lpfc_rport_data *)sdev->hostdata;
80}
81
82static void
83lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb);
84static void
85lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb);
86static int
87lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc);
88
89static void
90lpfc_debug_save_data(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
91{
92 void *src, *dst;
93 struct scatterlist *sgde = scsi_sglist(cmnd);
94
95 if (!_dump_buf_data) {
96 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
97 "9050 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
98 __func__);
99 return;
100 }
101
102
103 if (!sgde) {
104 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
105 "9051 BLKGRD: ERROR: data scatterlist is null\n");
106 return;
107 }
108
109 dst = (void *) _dump_buf_data;
110 while (sgde) {
111 src = sg_virt(sgde);
112 memcpy(dst, src, sgde->length);
113 dst += sgde->length;
114 sgde = sg_next(sgde);
115 }
116}
117
118static void
119lpfc_debug_save_dif(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
120{
121 void *src, *dst;
122 struct scatterlist *sgde = scsi_prot_sglist(cmnd);
123
124 if (!_dump_buf_dif) {
125 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
126 "9052 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
127 __func__);
128 return;
129 }
130
131 if (!sgde) {
132 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
133 "9053 BLKGRD: ERROR: prot scatterlist is null\n");
134 return;
135 }
136
137 dst = _dump_buf_dif;
138 while (sgde) {
139 src = sg_virt(sgde);
140 memcpy(dst, src, sgde->length);
141 dst += sgde->length;
142 sgde = sg_next(sgde);
143 }
144}
145
146static inline unsigned
147lpfc_cmd_blksize(struct scsi_cmnd *sc)
148{
149 return sc->device->sector_size;
150}
151
152#define LPFC_CHECK_PROTECT_GUARD 1
153#define LPFC_CHECK_PROTECT_REF 2
154static inline unsigned
155lpfc_cmd_protect(struct scsi_cmnd *sc, int flag)
156{
157 return 1;
158}
159
160static inline unsigned
161lpfc_cmd_guard_csum(struct scsi_cmnd *sc)
162{
163 if (lpfc_prot_group_type(NULL, sc) == LPFC_PG_TYPE_NO_DIF)
164 return 0;
165 if (scsi_host_get_guard(sc->device->host) == SHOST_DIX_GUARD_IP)
166 return 1;
167 return 0;
168}
169
170
171
172
173
174
175
176
177
178static void
179lpfc_sli4_set_rsp_sgl_last(struct lpfc_hba *phba,
180 struct lpfc_scsi_buf *lpfc_cmd)
181{
182 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->fcp_bpl;
183 if (sgl) {
184 sgl += 1;
185 sgl->word2 = le32_to_cpu(sgl->word2);
186 bf_set(lpfc_sli4_sge_last, sgl, 1);
187 sgl->word2 = cpu_to_le32(sgl->word2);
188 }
189}
190
191
192
193
194
195
196
197
198
199static void
200lpfc_update_stats(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
201{
202 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
203 struct lpfc_nodelist *pnode = rdata->pnode;
204 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
205 unsigned long flags;
206 struct Scsi_Host *shost = cmd->device->host;
207 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
208 unsigned long latency;
209 int i;
210
211 if (cmd->result)
212 return;
213
214 latency = jiffies_to_msecs((long)jiffies - (long)lpfc_cmd->start_time);
215
216 spin_lock_irqsave(shost->host_lock, flags);
217 if (!vport->stat_data_enabled ||
218 vport->stat_data_blocked ||
219 !pnode ||
220 !pnode->lat_data ||
221 (phba->bucket_type == LPFC_NO_BUCKET)) {
222 spin_unlock_irqrestore(shost->host_lock, flags);
223 return;
224 }
225
226 if (phba->bucket_type == LPFC_LINEAR_BUCKET) {
227 i = (latency + phba->bucket_step - 1 - phba->bucket_base)/
228 phba->bucket_step;
229
230 if (i < 0)
231 i = 0;
232 else if (i >= LPFC_MAX_BUCKET_COUNT)
233 i = LPFC_MAX_BUCKET_COUNT - 1;
234 } else {
235 for (i = 0; i < LPFC_MAX_BUCKET_COUNT-1; i++)
236 if (latency <= (phba->bucket_base +
237 ((1<<i)*phba->bucket_step)))
238 break;
239 }
240
241 pnode->lat_data[i].cmd_count++;
242 spin_unlock_irqrestore(shost->host_lock, flags);
243}
244
245
246
247
248
249
250
251
252
253
254
255
256void
257lpfc_rampdown_queue_depth(struct lpfc_hba *phba)
258{
259 unsigned long flags;
260 uint32_t evt_posted;
261 unsigned long expires;
262
263 spin_lock_irqsave(&phba->hbalock, flags);
264 atomic_inc(&phba->num_rsrc_err);
265 phba->last_rsrc_error_time = jiffies;
266
267 expires = phba->last_ramp_down_time + QUEUE_RAMP_DOWN_INTERVAL;
268 if (time_after(expires, jiffies)) {
269 spin_unlock_irqrestore(&phba->hbalock, flags);
270 return;
271 }
272
273 phba->last_ramp_down_time = jiffies;
274
275 spin_unlock_irqrestore(&phba->hbalock, flags);
276
277 spin_lock_irqsave(&phba->pport->work_port_lock, flags);
278 evt_posted = phba->pport->work_port_events & WORKER_RAMP_DOWN_QUEUE;
279 if (!evt_posted)
280 phba->pport->work_port_events |= WORKER_RAMP_DOWN_QUEUE;
281 spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);
282
283 if (!evt_posted)
284 lpfc_worker_wake_up(phba);
285 return;
286}
287
288
289
290
291
292
293
294
295
296void
297lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
298{
299 struct lpfc_vport **vports;
300 struct Scsi_Host *shost;
301 struct scsi_device *sdev;
302 unsigned long new_queue_depth;
303 unsigned long num_rsrc_err, num_cmd_success;
304 int i;
305
306 num_rsrc_err = atomic_read(&phba->num_rsrc_err);
307 num_cmd_success = atomic_read(&phba->num_cmd_success);
308
309
310
311
312
313
314 if (num_rsrc_err == 0)
315 return;
316
317 vports = lpfc_create_vport_work_array(phba);
318 if (vports != NULL)
319 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
320 shost = lpfc_shost_from_vport(vports[i]);
321 shost_for_each_device(sdev, shost) {
322 new_queue_depth =
323 sdev->queue_depth * num_rsrc_err /
324 (num_rsrc_err + num_cmd_success);
325 if (!new_queue_depth)
326 new_queue_depth = sdev->queue_depth - 1;
327 else
328 new_queue_depth = sdev->queue_depth -
329 new_queue_depth;
330 scsi_change_queue_depth(sdev, new_queue_depth);
331 }
332 }
333 lpfc_destroy_vport_work_array(phba, vports);
334 atomic_set(&phba->num_rsrc_err, 0);
335 atomic_set(&phba->num_cmd_success, 0);
336}
337
338
339
340
341
342
343
344
345
346void
347lpfc_scsi_dev_block(struct lpfc_hba *phba)
348{
349 struct lpfc_vport **vports;
350 struct Scsi_Host *shost;
351 struct scsi_device *sdev;
352 struct fc_rport *rport;
353 int i;
354
355 vports = lpfc_create_vport_work_array(phba);
356 if (vports != NULL)
357 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
358 shost = lpfc_shost_from_vport(vports[i]);
359 shost_for_each_device(sdev, shost) {
360 rport = starget_to_rport(scsi_target(sdev));
361 fc_remote_port_delete(rport);
362 }
363 }
364 lpfc_destroy_vport_work_array(phba, vports);
365}
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383static int
384lpfc_new_scsi_buf_s3(struct lpfc_vport *vport, int num_to_alloc)
385{
386 struct lpfc_hba *phba = vport->phba;
387 struct lpfc_scsi_buf *psb;
388 struct ulp_bde64 *bpl;
389 IOCB_t *iocb;
390 dma_addr_t pdma_phys_fcp_cmd;
391 dma_addr_t pdma_phys_fcp_rsp;
392 dma_addr_t pdma_phys_bpl;
393 uint16_t iotag;
394 int bcnt, bpl_size;
395
396 bpl_size = phba->cfg_sg_dma_buf_size -
397 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
398
399 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
400 "9067 ALLOC %d scsi_bufs: %d (%d + %d + %d)\n",
401 num_to_alloc, phba->cfg_sg_dma_buf_size,
402 (int)sizeof(struct fcp_cmnd),
403 (int)sizeof(struct fcp_rsp), bpl_size);
404
405 for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
406 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
407 if (!psb)
408 break;
409
410
411
412
413
414
415
416 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool,
417 GFP_KERNEL, &psb->dma_handle);
418 if (!psb->data) {
419 kfree(psb);
420 break;
421 }
422
423
424 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
425
426
427 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
428 if (iotag == 0) {
429 pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
430 psb->data, psb->dma_handle);
431 kfree(psb);
432 break;
433 }
434 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
435
436 psb->fcp_cmnd = psb->data;
437 psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd);
438 psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) +
439 sizeof(struct fcp_rsp);
440
441
442 bpl = psb->fcp_bpl;
443 pdma_phys_fcp_cmd = psb->dma_handle;
444 pdma_phys_fcp_rsp = psb->dma_handle + sizeof(struct fcp_cmnd);
445 pdma_phys_bpl = psb->dma_handle + sizeof(struct fcp_cmnd) +
446 sizeof(struct fcp_rsp);
447
448
449
450
451
452
453 bpl[0].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd));
454 bpl[0].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd));
455 bpl[0].tus.f.bdeSize = sizeof(struct fcp_cmnd);
456 bpl[0].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
457 bpl[0].tus.w = le32_to_cpu(bpl[0].tus.w);
458
459
460 bpl[1].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp));
461 bpl[1].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp));
462 bpl[1].tus.f.bdeSize = sizeof(struct fcp_rsp);
463 bpl[1].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
464 bpl[1].tus.w = le32_to_cpu(bpl[1].tus.w);
465
466
467
468
469
470 iocb = &psb->cur_iocbq.iocb;
471 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
472 if ((phba->sli_rev == 3) &&
473 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
474
475 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_IMMED;
476 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
477 iocb->un.fcpi64.bdl.addrLow = offsetof(IOCB_t,
478 unsli3.fcp_ext.icd);
479 iocb->un.fcpi64.bdl.addrHigh = 0;
480 iocb->ulpBdeCount = 0;
481 iocb->ulpLe = 0;
482
483 iocb->unsli3.fcp_ext.rbde.tus.f.bdeFlags =
484 BUFF_TYPE_BDE_64;
485 iocb->unsli3.fcp_ext.rbde.tus.f.bdeSize =
486 sizeof(struct fcp_rsp);
487 iocb->unsli3.fcp_ext.rbde.addrLow =
488 putPaddrLow(pdma_phys_fcp_rsp);
489 iocb->unsli3.fcp_ext.rbde.addrHigh =
490 putPaddrHigh(pdma_phys_fcp_rsp);
491 } else {
492 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
493 iocb->un.fcpi64.bdl.bdeSize =
494 (2 * sizeof(struct ulp_bde64));
495 iocb->un.fcpi64.bdl.addrLow =
496 putPaddrLow(pdma_phys_bpl);
497 iocb->un.fcpi64.bdl.addrHigh =
498 putPaddrHigh(pdma_phys_bpl);
499 iocb->ulpBdeCount = 1;
500 iocb->ulpLe = 1;
501 }
502 iocb->ulpClass = CLASS3;
503 psb->status = IOSTAT_SUCCESS;
504
505 psb->cur_iocbq.context1 = psb;
506 lpfc_release_scsi_buf_s3(phba, psb);
507
508 }
509
510 return bcnt;
511}
512
513
514
515
516
517
518
519
520void
521lpfc_sli4_vport_delete_fcp_xri_aborted(struct lpfc_vport *vport)
522{
523 struct lpfc_hba *phba = vport->phba;
524 struct lpfc_scsi_buf *psb, *next_psb;
525 unsigned long iflag = 0;
526
527 spin_lock_irqsave(&phba->hbalock, iflag);
528 spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
529 list_for_each_entry_safe(psb, next_psb,
530 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) {
531 if (psb->rdata && psb->rdata->pnode
532 && psb->rdata->pnode->vport == vport)
533 psb->rdata = NULL;
534 }
535 spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
536 spin_unlock_irqrestore(&phba->hbalock, iflag);
537}
538
539
540
541
542
543
544
545
546
547void
548lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
549 struct sli4_wcqe_xri_aborted *axri)
550{
551 uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
552 uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);
553 struct lpfc_scsi_buf *psb, *next_psb;
554 unsigned long iflag = 0;
555 struct lpfc_iocbq *iocbq;
556 int i;
557 struct lpfc_nodelist *ndlp;
558 int rrq_empty = 0;
559 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
560
561 spin_lock_irqsave(&phba->hbalock, iflag);
562 spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
563 list_for_each_entry_safe(psb, next_psb,
564 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) {
565 if (psb->cur_iocbq.sli4_xritag == xri) {
566 list_del(&psb->list);
567 psb->exch_busy = 0;
568 psb->status = IOSTAT_SUCCESS;
569 spin_unlock(
570 &phba->sli4_hba.abts_scsi_buf_list_lock);
571 if (psb->rdata && psb->rdata->pnode)
572 ndlp = psb->rdata->pnode;
573 else
574 ndlp = NULL;
575
576 rrq_empty = list_empty(&phba->active_rrq_list);
577 spin_unlock_irqrestore(&phba->hbalock, iflag);
578 if (ndlp) {
579 lpfc_set_rrq_active(phba, ndlp,
580 psb->cur_iocbq.sli4_lxritag, rxid, 1);
581 lpfc_sli4_abts_err_handler(phba, ndlp, axri);
582 }
583 lpfc_release_scsi_buf_s4(phba, psb);
584 if (rrq_empty)
585 lpfc_worker_wake_up(phba);
586 return;
587 }
588 }
589 spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
590 for (i = 1; i <= phba->sli.last_iotag; i++) {
591 iocbq = phba->sli.iocbq_lookup[i];
592
593 if (!(iocbq->iocb_flag & LPFC_IO_FCP) ||
594 (iocbq->iocb_flag & LPFC_IO_LIBDFC))
595 continue;
596 if (iocbq->sli4_xritag != xri)
597 continue;
598 psb = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
599 psb->exch_busy = 0;
600 spin_unlock_irqrestore(&phba->hbalock, iflag);
601 if (!list_empty(&pring->txq))
602 lpfc_worker_wake_up(phba);
603 return;
604
605 }
606 spin_unlock_irqrestore(&phba->hbalock, iflag);
607}
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623static int
624lpfc_sli4_post_scsi_sgl_list(struct lpfc_hba *phba,
625 struct list_head *post_sblist, int sb_count)
626{
627 struct lpfc_scsi_buf *psb, *psb_next;
628 int status, sgl_size;
629 int post_cnt = 0, block_cnt = 0, num_posting = 0, num_posted = 0;
630 dma_addr_t pdma_phys_bpl1;
631 int last_xritag = NO_XRI;
632 LIST_HEAD(prep_sblist);
633 LIST_HEAD(blck_sblist);
634 LIST_HEAD(scsi_sblist);
635
636
637 if (sb_count <= 0)
638 return -EINVAL;
639
640 sgl_size = phba->cfg_sg_dma_buf_size -
641 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
642
643 list_for_each_entry_safe(psb, psb_next, post_sblist, list) {
644 list_del_init(&psb->list);
645 block_cnt++;
646 if ((last_xritag != NO_XRI) &&
647 (psb->cur_iocbq.sli4_xritag != last_xritag + 1)) {
648
649 list_splice_init(&prep_sblist, &blck_sblist);
650 post_cnt = block_cnt - 1;
651
652 list_add_tail(&psb->list, &prep_sblist);
653 block_cnt = 1;
654 } else {
655
656 list_add_tail(&psb->list, &prep_sblist);
657
658 if (block_cnt == LPFC_NEMBED_MBOX_SGL_CNT) {
659 list_splice_init(&prep_sblist, &blck_sblist);
660 post_cnt = block_cnt;
661 block_cnt = 0;
662 }
663 }
664 num_posting++;
665 last_xritag = psb->cur_iocbq.sli4_xritag;
666
667
668 if (num_posting == sb_count) {
669 if (post_cnt == 0) {
670
671 list_splice_init(&prep_sblist, &blck_sblist);
672 post_cnt = block_cnt;
673 } else if (block_cnt == 1) {
674
675 if (sgl_size > SGL_PAGE_SIZE)
676 pdma_phys_bpl1 = psb->dma_phys_bpl +
677 SGL_PAGE_SIZE;
678 else
679 pdma_phys_bpl1 = 0;
680 status = lpfc_sli4_post_sgl(phba,
681 psb->dma_phys_bpl,
682 pdma_phys_bpl1,
683 psb->cur_iocbq.sli4_xritag);
684 if (status) {
685
686 psb->exch_busy = 1;
687 } else {
688
689 psb->exch_busy = 0;
690 psb->status = IOSTAT_SUCCESS;
691 num_posted++;
692 }
693
694 list_add_tail(&psb->list, &scsi_sblist);
695 }
696 }
697
698
699 if (post_cnt == 0)
700 continue;
701
702
703 status = lpfc_sli4_post_scsi_sgl_block(phba, &blck_sblist,
704 post_cnt);
705
706
707 if (block_cnt == 0)
708 last_xritag = NO_XRI;
709
710
711 post_cnt = 0;
712
713
714 while (!list_empty(&blck_sblist)) {
715 list_remove_head(&blck_sblist, psb,
716 struct lpfc_scsi_buf, list);
717 if (status) {
718
719 psb->exch_busy = 1;
720 } else {
721
722 psb->exch_busy = 0;
723 psb->status = IOSTAT_SUCCESS;
724 num_posted++;
725 }
726 list_add_tail(&psb->list, &scsi_sblist);
727 }
728 }
729
730 while (!list_empty(&scsi_sblist)) {
731 list_remove_head(&scsi_sblist, psb,
732 struct lpfc_scsi_buf, list);
733 lpfc_release_scsi_buf_s4(phba, psb);
734 }
735 return num_posted;
736}
737
738
739
740
741
742
743
744
745
746
747
748
749
750int
751lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
752{
753 LIST_HEAD(post_sblist);
754 int num_posted, rc = 0;
755
756
757 spin_lock_irq(&phba->scsi_buf_list_get_lock);
758 spin_lock(&phba->scsi_buf_list_put_lock);
759 list_splice_init(&phba->lpfc_scsi_buf_list_get, &post_sblist);
760 list_splice(&phba->lpfc_scsi_buf_list_put, &post_sblist);
761 spin_unlock(&phba->scsi_buf_list_put_lock);
762 spin_unlock_irq(&phba->scsi_buf_list_get_lock);
763
764
765 if (!list_empty(&post_sblist)) {
766 num_posted = lpfc_sli4_post_scsi_sgl_list(phba, &post_sblist,
767 phba->sli4_hba.scsi_xri_cnt);
768
769 if (num_posted == 0)
770 rc = -EIO;
771 }
772 return rc;
773}
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789static int
790lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
791{
792 struct lpfc_hba *phba = vport->phba;
793 struct lpfc_scsi_buf *psb;
794 struct sli4_sge *sgl;
795 IOCB_t *iocb;
796 dma_addr_t pdma_phys_fcp_cmd;
797 dma_addr_t pdma_phys_fcp_rsp;
798 dma_addr_t pdma_phys_bpl;
799 uint16_t iotag, lxri = 0;
800 int bcnt, num_posted, sgl_size;
801 LIST_HEAD(prep_sblist);
802 LIST_HEAD(post_sblist);
803 LIST_HEAD(scsi_sblist);
804
805 sgl_size = phba->cfg_sg_dma_buf_size -
806 (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
807
808 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
809 "9068 ALLOC %d scsi_bufs: %d (%d + %d + %d)\n",
810 num_to_alloc, phba->cfg_sg_dma_buf_size, sgl_size,
811 (int)sizeof(struct fcp_cmnd),
812 (int)sizeof(struct fcp_rsp));
813
814 for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
815 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
816 if (!psb)
817 break;
818
819
820
821
822
823
824 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool,
825 GFP_KERNEL, &psb->dma_handle);
826 if (!psb->data) {
827 kfree(psb);
828 break;
829 }
830 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
831
832
833
834
835
836 if (phba->cfg_enable_bg && (((unsigned long)(psb->data) &
837 (unsigned long)(SLI4_PAGE_SIZE - 1)) != 0)) {
838 pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
839 psb->data, psb->dma_handle);
840 kfree(psb);
841 break;
842 }
843
844
845 lxri = lpfc_sli4_next_xritag(phba);
846 if (lxri == NO_XRI) {
847 pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
848 psb->data, psb->dma_handle);
849 kfree(psb);
850 break;
851 }
852
853
854 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
855 if (iotag == 0) {
856 pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
857 psb->data, psb->dma_handle);
858 kfree(psb);
859 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
860 "3368 Failed to allocated IOTAG for"
861 " XRI:0x%x\n", lxri);
862 lpfc_sli4_free_xri(phba, lxri);
863 break;
864 }
865 psb->cur_iocbq.sli4_lxritag = lxri;
866 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
867 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
868 psb->fcp_bpl = psb->data;
869 psb->fcp_cmnd = (psb->data + sgl_size);
870 psb->fcp_rsp = (struct fcp_rsp *)((uint8_t *)psb->fcp_cmnd +
871 sizeof(struct fcp_cmnd));
872
873
874 sgl = (struct sli4_sge *)psb->fcp_bpl;
875 pdma_phys_bpl = psb->dma_handle;
876 pdma_phys_fcp_cmd = (psb->dma_handle + sgl_size);
877 pdma_phys_fcp_rsp = pdma_phys_fcp_cmd + sizeof(struct fcp_cmnd);
878
879
880
881
882
883
884 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd));
885 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd));
886 sgl->word2 = le32_to_cpu(sgl->word2);
887 bf_set(lpfc_sli4_sge_last, sgl, 0);
888 sgl->word2 = cpu_to_le32(sgl->word2);
889 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_cmnd));
890 sgl++;
891
892
893 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_rsp));
894 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_rsp));
895 sgl->word2 = le32_to_cpu(sgl->word2);
896 bf_set(lpfc_sli4_sge_last, sgl, 1);
897 sgl->word2 = cpu_to_le32(sgl->word2);
898 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_rsp));
899
900
901
902
903
904 iocb = &psb->cur_iocbq.iocb;
905 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
906 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_64;
907
908
909
910
911 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
912 iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys_fcp_cmd);
913 iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys_fcp_cmd);
914 iocb->ulpBdeCount = 1;
915 iocb->ulpLe = 1;
916 iocb->ulpClass = CLASS3;
917 psb->cur_iocbq.context1 = psb;
918 psb->dma_phys_bpl = pdma_phys_bpl;
919
920
921 list_add_tail(&psb->list, &post_sblist);
922 spin_lock_irq(&phba->scsi_buf_list_get_lock);
923 phba->sli4_hba.scsi_xri_cnt++;
924 spin_unlock_irq(&phba->scsi_buf_list_get_lock);
925 }
926 lpfc_printf_log(phba, KERN_INFO, LOG_BG,
927 "3021 Allocate %d out of %d requested new SCSI "
928 "buffers\n", bcnt, num_to_alloc);
929
930
931 if (!list_empty(&post_sblist))
932 num_posted = lpfc_sli4_post_scsi_sgl_list(phba,
933 &post_sblist, bcnt);
934 else
935 num_posted = 0;
936
937 return num_posted;
938}
939
940
941
942
943
944
945
946
947
948
949
950
951
952static inline int
953lpfc_new_scsi_buf(struct lpfc_vport *vport, int num_to_alloc)
954{
955 return vport->phba->lpfc_new_scsi_buf(vport, num_to_alloc);
956}
957
958
959
960
961
962
963
964
965
966
967
968
969static struct lpfc_scsi_buf*
970lpfc_get_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
971{
972 struct lpfc_scsi_buf * lpfc_cmd = NULL;
973 struct list_head *scsi_buf_list_get = &phba->lpfc_scsi_buf_list_get;
974 unsigned long iflag = 0;
975
976 spin_lock_irqsave(&phba->scsi_buf_list_get_lock, iflag);
977 list_remove_head(scsi_buf_list_get, lpfc_cmd, struct lpfc_scsi_buf,
978 list);
979 if (!lpfc_cmd) {
980 spin_lock(&phba->scsi_buf_list_put_lock);
981 list_splice(&phba->lpfc_scsi_buf_list_put,
982 &phba->lpfc_scsi_buf_list_get);
983 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
984 list_remove_head(scsi_buf_list_get, lpfc_cmd,
985 struct lpfc_scsi_buf, list);
986 spin_unlock(&phba->scsi_buf_list_put_lock);
987 }
988 spin_unlock_irqrestore(&phba->scsi_buf_list_get_lock, iflag);
989 return lpfc_cmd;
990}
991
992
993
994
995
996
997
998
999
1000
1001
1002static struct lpfc_scsi_buf*
1003lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
1004{
1005 struct lpfc_scsi_buf *lpfc_cmd, *lpfc_cmd_next;
1006 unsigned long iflag = 0;
1007 int found = 0;
1008
1009 spin_lock_irqsave(&phba->scsi_buf_list_get_lock, iflag);
1010 list_for_each_entry_safe(lpfc_cmd, lpfc_cmd_next,
1011 &phba->lpfc_scsi_buf_list_get, list) {
1012 if (lpfc_test_rrq_active(phba, ndlp,
1013 lpfc_cmd->cur_iocbq.sli4_lxritag))
1014 continue;
1015 list_del(&lpfc_cmd->list);
1016 found = 1;
1017 break;
1018 }
1019 if (!found) {
1020 spin_lock(&phba->scsi_buf_list_put_lock);
1021 list_splice(&phba->lpfc_scsi_buf_list_put,
1022 &phba->lpfc_scsi_buf_list_get);
1023 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
1024 spin_unlock(&phba->scsi_buf_list_put_lock);
1025 list_for_each_entry_safe(lpfc_cmd, lpfc_cmd_next,
1026 &phba->lpfc_scsi_buf_list_get, list) {
1027 if (lpfc_test_rrq_active(
1028 phba, ndlp, lpfc_cmd->cur_iocbq.sli4_lxritag))
1029 continue;
1030 list_del(&lpfc_cmd->list);
1031 found = 1;
1032 break;
1033 }
1034 }
1035 spin_unlock_irqrestore(&phba->scsi_buf_list_get_lock, iflag);
1036 if (!found)
1037 return NULL;
1038 return lpfc_cmd;
1039}
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051static struct lpfc_scsi_buf*
1052lpfc_get_scsi_buf(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
1053{
1054 return phba->lpfc_get_scsi_buf(phba, ndlp);
1055}
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065static void
1066lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1067{
1068 unsigned long iflag = 0;
1069
1070 psb->seg_cnt = 0;
1071 psb->nonsg_phys = 0;
1072 psb->prot_seg_cnt = 0;
1073
1074 spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
1075 psb->pCmd = NULL;
1076 psb->cur_iocbq.iocb_flag = LPFC_IO_FCP;
1077 list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list_put);
1078 spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
1079}
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091static void
1092lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1093{
1094 unsigned long iflag = 0;
1095
1096 psb->seg_cnt = 0;
1097 psb->nonsg_phys = 0;
1098 psb->prot_seg_cnt = 0;
1099
1100 if (psb->exch_busy) {
1101 spin_lock_irqsave(&phba->sli4_hba.abts_scsi_buf_list_lock,
1102 iflag);
1103 psb->pCmd = NULL;
1104 list_add_tail(&psb->list,
1105 &phba->sli4_hba.lpfc_abts_scsi_buf_list);
1106 spin_unlock_irqrestore(&phba->sli4_hba.abts_scsi_buf_list_lock,
1107 iflag);
1108 } else {
1109 psb->pCmd = NULL;
1110 psb->cur_iocbq.iocb_flag = LPFC_IO_FCP;
1111 spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
1112 list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list_put);
1113 spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
1114 }
1115}
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125static void
1126lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1127{
1128
1129 phba->lpfc_release_scsi_buf(phba, psb);
1130}
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146static int
1147lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
1148{
1149 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
1150 struct scatterlist *sgel = NULL;
1151 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
1152 struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
1153 struct lpfc_iocbq *iocbq = &lpfc_cmd->cur_iocbq;
1154 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
1155 struct ulp_bde64 *data_bde = iocb_cmd->unsli3.fcp_ext.dbde;
1156 dma_addr_t physaddr;
1157 uint32_t num_bde = 0;
1158 int nseg, datadir = scsi_cmnd->sc_data_direction;
1159
1160
1161
1162
1163
1164
1165
1166 bpl += 2;
1167 if (scsi_sg_count(scsi_cmnd)) {
1168
1169
1170
1171
1172
1173
1174
1175 nseg = dma_map_sg(&phba->pcidev->dev, scsi_sglist(scsi_cmnd),
1176 scsi_sg_count(scsi_cmnd), datadir);
1177 if (unlikely(!nseg))
1178 return 1;
1179
1180 lpfc_cmd->seg_cnt = nseg;
1181 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
1182 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1183 "9064 BLKGRD: %s: Too many sg segments from "
1184 "dma_map_sg. Config %d, seg_cnt %d\n",
1185 __func__, phba->cfg_sg_seg_cnt,
1186 lpfc_cmd->seg_cnt);
1187 lpfc_cmd->seg_cnt = 0;
1188 scsi_dma_unmap(scsi_cmnd);
1189 return 1;
1190 }
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
1202 physaddr = sg_dma_address(sgel);
1203 if (phba->sli_rev == 3 &&
1204 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
1205 !(iocbq->iocb_flag & DSS_SECURITY_OP) &&
1206 nseg <= LPFC_EXT_DATA_BDE_COUNT) {
1207 data_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1208 data_bde->tus.f.bdeSize = sg_dma_len(sgel);
1209 data_bde->addrLow = putPaddrLow(physaddr);
1210 data_bde->addrHigh = putPaddrHigh(physaddr);
1211 data_bde++;
1212 } else {
1213 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1214 bpl->tus.f.bdeSize = sg_dma_len(sgel);
1215 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1216 bpl->addrLow =
1217 le32_to_cpu(putPaddrLow(physaddr));
1218 bpl->addrHigh =
1219 le32_to_cpu(putPaddrHigh(physaddr));
1220 bpl++;
1221 }
1222 }
1223 }
1224
1225
1226
1227
1228
1229
1230
1231 if (phba->sli_rev == 3 &&
1232 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
1233 !(iocbq->iocb_flag & DSS_SECURITY_OP)) {
1234 if (num_bde > LPFC_EXT_DATA_BDE_COUNT) {
1235
1236
1237
1238
1239
1240 physaddr = lpfc_cmd->dma_handle;
1241 data_bde->tus.f.bdeFlags = BUFF_TYPE_BLP_64;
1242 data_bde->tus.f.bdeSize = (num_bde *
1243 sizeof(struct ulp_bde64));
1244 physaddr += (sizeof(struct fcp_cmnd) +
1245 sizeof(struct fcp_rsp) +
1246 (2 * sizeof(struct ulp_bde64)));
1247 data_bde->addrHigh = putPaddrHigh(physaddr);
1248 data_bde->addrLow = putPaddrLow(physaddr);
1249
1250 iocb_cmd->unsli3.fcp_ext.ebde_count = 2;
1251 } else {
1252
1253 iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
1254 }
1255 } else {
1256 iocb_cmd->un.fcpi64.bdl.bdeSize =
1257 ((num_bde + 2) * sizeof(struct ulp_bde64));
1258 iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
1259 }
1260 fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
1261
1262
1263
1264
1265
1266 iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
1267 return 0;
1268}
1269
1270#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1271
1272
1273#define BG_ERR_INIT 0x1
1274
1275#define BG_ERR_TGT 0x2
1276
1277#define BG_ERR_SWAP 0x10
1278
1279#define BG_ERR_CHECK 0x20
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291static int
1292lpfc_bg_err_inject(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1293 uint32_t *reftag, uint16_t *apptag, uint32_t new_guard)
1294{
1295 struct scatterlist *sgpe;
1296 struct scatterlist *sgde;
1297 struct lpfc_scsi_buf *lpfc_cmd = NULL;
1298 struct scsi_dif_tuple *src = NULL;
1299 struct lpfc_nodelist *ndlp;
1300 struct lpfc_rport_data *rdata;
1301 uint32_t op = scsi_get_prot_op(sc);
1302 uint32_t blksize;
1303 uint32_t numblks;
1304 sector_t lba;
1305 int rc = 0;
1306 int blockoff = 0;
1307
1308 if (op == SCSI_PROT_NORMAL)
1309 return 0;
1310
1311 sgpe = scsi_prot_sglist(sc);
1312 sgde = scsi_sglist(sc);
1313 lba = scsi_get_lba(sc);
1314
1315
1316 if (phba->lpfc_injerr_lba != LPFC_INJERR_LBA_OFF) {
1317 blksize = lpfc_cmd_blksize(sc);
1318 numblks = (scsi_bufflen(sc) + blksize - 1) / blksize;
1319
1320
1321 if ((phba->lpfc_injerr_lba < lba) ||
1322 (phba->lpfc_injerr_lba >= (lba + numblks)))
1323 return 0;
1324 if (sgpe) {
1325 blockoff = phba->lpfc_injerr_lba - lba;
1326 numblks = sg_dma_len(sgpe) /
1327 sizeof(struct scsi_dif_tuple);
1328 if (numblks < blockoff)
1329 blockoff = numblks;
1330 }
1331 }
1332
1333
1334 rdata = lpfc_rport_data_from_scsi_device(sc->device);
1335 if (rdata && rdata->pnode) {
1336 ndlp = rdata->pnode;
1337
1338
1339 if (phba->lpfc_injerr_nportid &&
1340 (phba->lpfc_injerr_nportid != ndlp->nlp_DID))
1341 return 0;
1342
1343
1344
1345
1346
1347 if (phba->lpfc_injerr_wwpn.u.wwn[0] &&
1348 (memcmp(&ndlp->nlp_portname, &phba->lpfc_injerr_wwpn,
1349 sizeof(struct lpfc_name)) != 0))
1350 return 0;
1351 }
1352
1353
1354 if (sgpe) {
1355 src = (struct scsi_dif_tuple *)sg_virt(sgpe);
1356 src += blockoff;
1357 lpfc_cmd = (struct lpfc_scsi_buf *)sc->host_scribble;
1358 }
1359
1360
1361 if (reftag) {
1362 if (phba->lpfc_injerr_wref_cnt) {
1363 switch (op) {
1364 case SCSI_PROT_WRITE_PASS:
1365 if (src) {
1366
1367
1368
1369
1370
1371
1372
1373
1374 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1375 "9076 BLKGRD: Injecting reftag error: "
1376 "write lba x%lx + x%x oldrefTag x%x\n",
1377 (unsigned long)lba, blockoff,
1378 be32_to_cpu(src->ref_tag));
1379
1380
1381
1382
1383
1384 if (lpfc_cmd) {
1385 lpfc_cmd->prot_data_type =
1386 LPFC_INJERR_REFTAG;
1387 lpfc_cmd->prot_data_segment =
1388 src;
1389 lpfc_cmd->prot_data =
1390 src->ref_tag;
1391 }
1392 src->ref_tag = cpu_to_be32(0xDEADBEEF);
1393 phba->lpfc_injerr_wref_cnt--;
1394 if (phba->lpfc_injerr_wref_cnt == 0) {
1395 phba->lpfc_injerr_nportid = 0;
1396 phba->lpfc_injerr_lba =
1397 LPFC_INJERR_LBA_OFF;
1398 memset(&phba->lpfc_injerr_wwpn,
1399 0, sizeof(struct lpfc_name));
1400 }
1401 rc = BG_ERR_TGT | BG_ERR_CHECK;
1402
1403 break;
1404 }
1405
1406 case SCSI_PROT_WRITE_INSERT:
1407
1408
1409
1410
1411
1412
1413 *reftag = 0xDEADBEEF;
1414 phba->lpfc_injerr_wref_cnt--;
1415 if (phba->lpfc_injerr_wref_cnt == 0) {
1416 phba->lpfc_injerr_nportid = 0;
1417 phba->lpfc_injerr_lba =
1418 LPFC_INJERR_LBA_OFF;
1419 memset(&phba->lpfc_injerr_wwpn,
1420 0, sizeof(struct lpfc_name));
1421 }
1422 rc = BG_ERR_TGT | BG_ERR_CHECK;
1423
1424 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1425 "9078 BLKGRD: Injecting reftag error: "
1426 "write lba x%lx\n", (unsigned long)lba);
1427 break;
1428 case SCSI_PROT_WRITE_STRIP:
1429
1430
1431
1432
1433
1434 *reftag = 0xDEADBEEF;
1435 phba->lpfc_injerr_wref_cnt--;
1436 if (phba->lpfc_injerr_wref_cnt == 0) {
1437 phba->lpfc_injerr_nportid = 0;
1438 phba->lpfc_injerr_lba =
1439 LPFC_INJERR_LBA_OFF;
1440 memset(&phba->lpfc_injerr_wwpn,
1441 0, sizeof(struct lpfc_name));
1442 }
1443 rc = BG_ERR_INIT;
1444
1445 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1446 "9077 BLKGRD: Injecting reftag error: "
1447 "write lba x%lx\n", (unsigned long)lba);
1448 break;
1449 }
1450 }
1451 if (phba->lpfc_injerr_rref_cnt) {
1452 switch (op) {
1453 case SCSI_PROT_READ_INSERT:
1454 case SCSI_PROT_READ_STRIP:
1455 case SCSI_PROT_READ_PASS:
1456
1457
1458
1459
1460
1461 *reftag = 0xDEADBEEF;
1462 phba->lpfc_injerr_rref_cnt--;
1463 if (phba->lpfc_injerr_rref_cnt == 0) {
1464 phba->lpfc_injerr_nportid = 0;
1465 phba->lpfc_injerr_lba =
1466 LPFC_INJERR_LBA_OFF;
1467 memset(&phba->lpfc_injerr_wwpn,
1468 0, sizeof(struct lpfc_name));
1469 }
1470 rc = BG_ERR_INIT;
1471
1472 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1473 "9079 BLKGRD: Injecting reftag error: "
1474 "read lba x%lx\n", (unsigned long)lba);
1475 break;
1476 }
1477 }
1478 }
1479
1480
1481 if (apptag) {
1482 if (phba->lpfc_injerr_wapp_cnt) {
1483 switch (op) {
1484 case SCSI_PROT_WRITE_PASS:
1485 if (src) {
1486
1487
1488
1489
1490
1491
1492
1493
1494 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1495 "9080 BLKGRD: Injecting apptag error: "
1496 "write lba x%lx + x%x oldappTag x%x\n",
1497 (unsigned long)lba, blockoff,
1498 be16_to_cpu(src->app_tag));
1499
1500
1501
1502
1503
1504 if (lpfc_cmd) {
1505 lpfc_cmd->prot_data_type =
1506 LPFC_INJERR_APPTAG;
1507 lpfc_cmd->prot_data_segment =
1508 src;
1509 lpfc_cmd->prot_data =
1510 src->app_tag;
1511 }
1512 src->app_tag = cpu_to_be16(0xDEAD);
1513 phba->lpfc_injerr_wapp_cnt--;
1514 if (phba->lpfc_injerr_wapp_cnt == 0) {
1515 phba->lpfc_injerr_nportid = 0;
1516 phba->lpfc_injerr_lba =
1517 LPFC_INJERR_LBA_OFF;
1518 memset(&phba->lpfc_injerr_wwpn,
1519 0, sizeof(struct lpfc_name));
1520 }
1521 rc = BG_ERR_TGT | BG_ERR_CHECK;
1522 break;
1523 }
1524
1525 case SCSI_PROT_WRITE_INSERT:
1526
1527
1528
1529
1530
1531
1532 *apptag = 0xDEAD;
1533 phba->lpfc_injerr_wapp_cnt--;
1534 if (phba->lpfc_injerr_wapp_cnt == 0) {
1535 phba->lpfc_injerr_nportid = 0;
1536 phba->lpfc_injerr_lba =
1537 LPFC_INJERR_LBA_OFF;
1538 memset(&phba->lpfc_injerr_wwpn,
1539 0, sizeof(struct lpfc_name));
1540 }
1541 rc = BG_ERR_TGT | BG_ERR_CHECK;
1542
1543 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1544 "0813 BLKGRD: Injecting apptag error: "
1545 "write lba x%lx\n", (unsigned long)lba);
1546 break;
1547 case SCSI_PROT_WRITE_STRIP:
1548
1549
1550
1551
1552
1553 *apptag = 0xDEAD;
1554 phba->lpfc_injerr_wapp_cnt--;
1555 if (phba->lpfc_injerr_wapp_cnt == 0) {
1556 phba->lpfc_injerr_nportid = 0;
1557 phba->lpfc_injerr_lba =
1558 LPFC_INJERR_LBA_OFF;
1559 memset(&phba->lpfc_injerr_wwpn,
1560 0, sizeof(struct lpfc_name));
1561 }
1562 rc = BG_ERR_INIT;
1563
1564 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1565 "0812 BLKGRD: Injecting apptag error: "
1566 "write lba x%lx\n", (unsigned long)lba);
1567 break;
1568 }
1569 }
1570 if (phba->lpfc_injerr_rapp_cnt) {
1571 switch (op) {
1572 case SCSI_PROT_READ_INSERT:
1573 case SCSI_PROT_READ_STRIP:
1574 case SCSI_PROT_READ_PASS:
1575
1576
1577
1578
1579
1580 *apptag = 0xDEAD;
1581 phba->lpfc_injerr_rapp_cnt--;
1582 if (phba->lpfc_injerr_rapp_cnt == 0) {
1583 phba->lpfc_injerr_nportid = 0;
1584 phba->lpfc_injerr_lba =
1585 LPFC_INJERR_LBA_OFF;
1586 memset(&phba->lpfc_injerr_wwpn,
1587 0, sizeof(struct lpfc_name));
1588 }
1589 rc = BG_ERR_INIT;
1590
1591 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1592 "0814 BLKGRD: Injecting apptag error: "
1593 "read lba x%lx\n", (unsigned long)lba);
1594 break;
1595 }
1596 }
1597 }
1598
1599
1600
1601 if (new_guard) {
1602 if (phba->lpfc_injerr_wgrd_cnt) {
1603 switch (op) {
1604 case SCSI_PROT_WRITE_PASS:
1605 rc = BG_ERR_CHECK;
1606
1607
1608 case SCSI_PROT_WRITE_INSERT:
1609
1610
1611
1612
1613
1614 phba->lpfc_injerr_wgrd_cnt--;
1615 if (phba->lpfc_injerr_wgrd_cnt == 0) {
1616 phba->lpfc_injerr_nportid = 0;
1617 phba->lpfc_injerr_lba =
1618 LPFC_INJERR_LBA_OFF;
1619 memset(&phba->lpfc_injerr_wwpn,
1620 0, sizeof(struct lpfc_name));
1621 }
1622
1623 rc |= BG_ERR_TGT | BG_ERR_SWAP;
1624
1625
1626 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1627 "0817 BLKGRD: Injecting guard error: "
1628 "write lba x%lx\n", (unsigned long)lba);
1629 break;
1630 case SCSI_PROT_WRITE_STRIP:
1631
1632
1633
1634
1635
1636 phba->lpfc_injerr_wgrd_cnt--;
1637 if (phba->lpfc_injerr_wgrd_cnt == 0) {
1638 phba->lpfc_injerr_nportid = 0;
1639 phba->lpfc_injerr_lba =
1640 LPFC_INJERR_LBA_OFF;
1641 memset(&phba->lpfc_injerr_wwpn,
1642 0, sizeof(struct lpfc_name));
1643 }
1644
1645 rc = BG_ERR_INIT | BG_ERR_SWAP;
1646
1647
1648 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1649 "0816 BLKGRD: Injecting guard error: "
1650 "write lba x%lx\n", (unsigned long)lba);
1651 break;
1652 }
1653 }
1654 if (phba->lpfc_injerr_rgrd_cnt) {
1655 switch (op) {
1656 case SCSI_PROT_READ_INSERT:
1657 case SCSI_PROT_READ_STRIP:
1658 case SCSI_PROT_READ_PASS:
1659
1660
1661
1662
1663
1664 phba->lpfc_injerr_rgrd_cnt--;
1665 if (phba->lpfc_injerr_rgrd_cnt == 0) {
1666 phba->lpfc_injerr_nportid = 0;
1667 phba->lpfc_injerr_lba =
1668 LPFC_INJERR_LBA_OFF;
1669 memset(&phba->lpfc_injerr_wwpn,
1670 0, sizeof(struct lpfc_name));
1671 }
1672
1673 rc = BG_ERR_INIT | BG_ERR_SWAP;
1674
1675
1676 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1677 "0818 BLKGRD: Injecting guard error: "
1678 "read lba x%lx\n", (unsigned long)lba);
1679 }
1680 }
1681 }
1682
1683 return rc;
1684}
1685#endif
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698static int
1699lpfc_sc_to_bg_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1700 uint8_t *txop, uint8_t *rxop)
1701{
1702 uint8_t ret = 0;
1703
1704 if (lpfc_cmd_guard_csum(sc)) {
1705 switch (scsi_get_prot_op(sc)) {
1706 case SCSI_PROT_READ_INSERT:
1707 case SCSI_PROT_WRITE_STRIP:
1708 *rxop = BG_OP_IN_NODIF_OUT_CSUM;
1709 *txop = BG_OP_IN_CSUM_OUT_NODIF;
1710 break;
1711
1712 case SCSI_PROT_READ_STRIP:
1713 case SCSI_PROT_WRITE_INSERT:
1714 *rxop = BG_OP_IN_CRC_OUT_NODIF;
1715 *txop = BG_OP_IN_NODIF_OUT_CRC;
1716 break;
1717
1718 case SCSI_PROT_READ_PASS:
1719 case SCSI_PROT_WRITE_PASS:
1720 *rxop = BG_OP_IN_CRC_OUT_CSUM;
1721 *txop = BG_OP_IN_CSUM_OUT_CRC;
1722 break;
1723
1724 case SCSI_PROT_NORMAL:
1725 default:
1726 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1727 "9063 BLKGRD: Bad op/guard:%d/IP combination\n",
1728 scsi_get_prot_op(sc));
1729 ret = 1;
1730 break;
1731
1732 }
1733 } else {
1734 switch (scsi_get_prot_op(sc)) {
1735 case SCSI_PROT_READ_STRIP:
1736 case SCSI_PROT_WRITE_INSERT:
1737 *rxop = BG_OP_IN_CRC_OUT_NODIF;
1738 *txop = BG_OP_IN_NODIF_OUT_CRC;
1739 break;
1740
1741 case SCSI_PROT_READ_PASS:
1742 case SCSI_PROT_WRITE_PASS:
1743 *rxop = BG_OP_IN_CRC_OUT_CRC;
1744 *txop = BG_OP_IN_CRC_OUT_CRC;
1745 break;
1746
1747 case SCSI_PROT_READ_INSERT:
1748 case SCSI_PROT_WRITE_STRIP:
1749 *rxop = BG_OP_IN_NODIF_OUT_CRC;
1750 *txop = BG_OP_IN_CRC_OUT_NODIF;
1751 break;
1752
1753 case SCSI_PROT_NORMAL:
1754 default:
1755 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
1756 "9075 BLKGRD: Bad op/guard:%d/CRC combination\n",
1757 scsi_get_prot_op(sc));
1758 ret = 1;
1759 break;
1760 }
1761 }
1762
1763 return ret;
1764}
1765
1766#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778static int
1779lpfc_bg_err_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1780 uint8_t *txop, uint8_t *rxop)
1781{
1782 uint8_t ret = 0;
1783
1784 if (lpfc_cmd_guard_csum(sc)) {
1785 switch (scsi_get_prot_op(sc)) {
1786 case SCSI_PROT_READ_INSERT:
1787 case SCSI_PROT_WRITE_STRIP:
1788 *rxop = BG_OP_IN_NODIF_OUT_CRC;
1789 *txop = BG_OP_IN_CRC_OUT_NODIF;
1790 break;
1791
1792 case SCSI_PROT_READ_STRIP:
1793 case SCSI_PROT_WRITE_INSERT:
1794 *rxop = BG_OP_IN_CSUM_OUT_NODIF;
1795 *txop = BG_OP_IN_NODIF_OUT_CSUM;
1796 break;
1797
1798 case SCSI_PROT_READ_PASS:
1799 case SCSI_PROT_WRITE_PASS:
1800 *rxop = BG_OP_IN_CSUM_OUT_CRC;
1801 *txop = BG_OP_IN_CRC_OUT_CSUM;
1802 break;
1803
1804 case SCSI_PROT_NORMAL:
1805 default:
1806 break;
1807
1808 }
1809 } else {
1810 switch (scsi_get_prot_op(sc)) {
1811 case SCSI_PROT_READ_STRIP:
1812 case SCSI_PROT_WRITE_INSERT:
1813 *rxop = BG_OP_IN_CSUM_OUT_NODIF;
1814 *txop = BG_OP_IN_NODIF_OUT_CSUM;
1815 break;
1816
1817 case SCSI_PROT_READ_PASS:
1818 case SCSI_PROT_WRITE_PASS:
1819 *rxop = BG_OP_IN_CSUM_OUT_CSUM;
1820 *txop = BG_OP_IN_CSUM_OUT_CSUM;
1821 break;
1822
1823 case SCSI_PROT_READ_INSERT:
1824 case SCSI_PROT_WRITE_STRIP:
1825 *rxop = BG_OP_IN_NODIF_OUT_CSUM;
1826 *txop = BG_OP_IN_CSUM_OUT_NODIF;
1827 break;
1828
1829 case SCSI_PROT_NORMAL:
1830 default:
1831 break;
1832 }
1833 }
1834
1835 return ret;
1836}
1837#endif
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870static int
1871lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
1872 struct ulp_bde64 *bpl, int datasegcnt)
1873{
1874 struct scatterlist *sgde = NULL;
1875 struct lpfc_pde5 *pde5 = NULL;
1876 struct lpfc_pde6 *pde6 = NULL;
1877 dma_addr_t physaddr;
1878 int i = 0, num_bde = 0, status;
1879 int datadir = sc->sc_data_direction;
1880#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1881 uint32_t rc;
1882#endif
1883 uint32_t checking = 1;
1884 uint32_t reftag;
1885 unsigned blksize;
1886 uint8_t txop, rxop;
1887
1888 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
1889 if (status)
1890 goto out;
1891
1892
1893 blksize = lpfc_cmd_blksize(sc);
1894 reftag = (uint32_t)scsi_get_lba(sc);
1895
1896#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1897 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
1898 if (rc) {
1899 if (rc & BG_ERR_SWAP)
1900 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
1901 if (rc & BG_ERR_CHECK)
1902 checking = 0;
1903 }
1904#endif
1905
1906
1907 pde5 = (struct lpfc_pde5 *) bpl;
1908 memset(pde5, 0, sizeof(struct lpfc_pde5));
1909 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
1910
1911
1912 pde5->word0 = cpu_to_le32(pde5->word0);
1913 pde5->reftag = cpu_to_le32(reftag);
1914
1915
1916 num_bde++;
1917 bpl++;
1918 pde6 = (struct lpfc_pde6 *) bpl;
1919
1920
1921 memset(pde6, 0, sizeof(struct lpfc_pde6));
1922 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
1923 bf_set(pde6_optx, pde6, txop);
1924 bf_set(pde6_oprx, pde6, rxop);
1925
1926
1927
1928
1929
1930 if (datadir == DMA_FROM_DEVICE) {
1931 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD))
1932 bf_set(pde6_ce, pde6, checking);
1933 else
1934 bf_set(pde6_ce, pde6, 0);
1935
1936 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
1937 bf_set(pde6_re, pde6, checking);
1938 else
1939 bf_set(pde6_re, pde6, 0);
1940 }
1941 bf_set(pde6_ai, pde6, 1);
1942 bf_set(pde6_ae, pde6, 0);
1943 bf_set(pde6_apptagval, pde6, 0);
1944
1945
1946 pde6->word0 = cpu_to_le32(pde6->word0);
1947 pde6->word1 = cpu_to_le32(pde6->word1);
1948 pde6->word2 = cpu_to_le32(pde6->word2);
1949
1950
1951 num_bde++;
1952 bpl++;
1953
1954
1955 scsi_for_each_sg(sc, sgde, datasegcnt, i) {
1956 physaddr = sg_dma_address(sgde);
1957 bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr));
1958 bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
1959 bpl->tus.f.bdeSize = sg_dma_len(sgde);
1960 if (datadir == DMA_TO_DEVICE)
1961 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
1962 else
1963 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
1964 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1965 bpl++;
1966 num_bde++;
1967 }
1968
1969out:
1970 return num_bde;
1971}
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012static int
2013lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
2014 struct ulp_bde64 *bpl, int datacnt, int protcnt)
2015{
2016 struct scatterlist *sgde = NULL;
2017 struct scatterlist *sgpe = NULL;
2018 struct lpfc_pde5 *pde5 = NULL;
2019 struct lpfc_pde6 *pde6 = NULL;
2020 struct lpfc_pde7 *pde7 = NULL;
2021 dma_addr_t dataphysaddr, protphysaddr;
2022 unsigned short curr_data = 0, curr_prot = 0;
2023 unsigned int split_offset;
2024 unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder;
2025 unsigned int protgrp_blks, protgrp_bytes;
2026 unsigned int remainder, subtotal;
2027 int status;
2028 int datadir = sc->sc_data_direction;
2029 unsigned char pgdone = 0, alldone = 0;
2030 unsigned blksize;
2031#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2032 uint32_t rc;
2033#endif
2034 uint32_t checking = 1;
2035 uint32_t reftag;
2036 uint8_t txop, rxop;
2037 int num_bde = 0;
2038
2039 sgpe = scsi_prot_sglist(sc);
2040 sgde = scsi_sglist(sc);
2041
2042 if (!sgpe || !sgde) {
2043 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2044 "9020 Invalid s/g entry: data=0x%p prot=0x%p\n",
2045 sgpe, sgde);
2046 return 0;
2047 }
2048
2049 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2050 if (status)
2051 goto out;
2052
2053
2054 blksize = lpfc_cmd_blksize(sc);
2055 reftag = (uint32_t)scsi_get_lba(sc);
2056
2057#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2058 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2059 if (rc) {
2060 if (rc & BG_ERR_SWAP)
2061 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2062 if (rc & BG_ERR_CHECK)
2063 checking = 0;
2064 }
2065#endif
2066
2067 split_offset = 0;
2068 do {
2069
2070 if (num_bde >= (phba->cfg_total_seg_cnt - 2))
2071 return num_bde + 3;
2072
2073
2074 pde5 = (struct lpfc_pde5 *) bpl;
2075 memset(pde5, 0, sizeof(struct lpfc_pde5));
2076 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
2077
2078
2079 pde5->word0 = cpu_to_le32(pde5->word0);
2080 pde5->reftag = cpu_to_le32(reftag);
2081
2082
2083 num_bde++;
2084 bpl++;
2085 pde6 = (struct lpfc_pde6 *) bpl;
2086
2087
2088 memset(pde6, 0, sizeof(struct lpfc_pde6));
2089 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
2090 bf_set(pde6_optx, pde6, txop);
2091 bf_set(pde6_oprx, pde6, rxop);
2092
2093 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD))
2094 bf_set(pde6_ce, pde6, checking);
2095 else
2096 bf_set(pde6_ce, pde6, 0);
2097
2098 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
2099 bf_set(pde6_re, pde6, checking);
2100 else
2101 bf_set(pde6_re, pde6, 0);
2102
2103 bf_set(pde6_ai, pde6, 1);
2104 bf_set(pde6_ae, pde6, 0);
2105 bf_set(pde6_apptagval, pde6, 0);
2106
2107
2108 pde6->word0 = cpu_to_le32(pde6->word0);
2109 pde6->word1 = cpu_to_le32(pde6->word1);
2110 pde6->word2 = cpu_to_le32(pde6->word2);
2111
2112
2113 num_bde++;
2114 bpl++;
2115
2116
2117 protphysaddr = sg_dma_address(sgpe) + protgroup_offset;
2118 protgroup_len = sg_dma_len(sgpe) - protgroup_offset;
2119
2120
2121 BUG_ON(protgroup_len % 8);
2122
2123 pde7 = (struct lpfc_pde7 *) bpl;
2124 memset(pde7, 0, sizeof(struct lpfc_pde7));
2125 bf_set(pde7_type, pde7, LPFC_PDE7_DESCRIPTOR);
2126
2127 pde7->addrHigh = le32_to_cpu(putPaddrHigh(protphysaddr));
2128 pde7->addrLow = le32_to_cpu(putPaddrLow(protphysaddr));
2129
2130 protgrp_blks = protgroup_len / 8;
2131 protgrp_bytes = protgrp_blks * blksize;
2132
2133
2134 if ((pde7->addrLow & 0xfff) + protgroup_len > 0x1000) {
2135 protgroup_remainder = 0x1000 - (pde7->addrLow & 0xfff);
2136 protgroup_offset += protgroup_remainder;
2137 protgrp_blks = protgroup_remainder / 8;
2138 protgrp_bytes = protgrp_blks * blksize;
2139 } else {
2140 protgroup_offset = 0;
2141 curr_prot++;
2142 }
2143
2144 num_bde++;
2145
2146
2147 pgdone = 0;
2148 subtotal = 0;
2149 while (!pgdone) {
2150
2151 if (num_bde >= phba->cfg_total_seg_cnt)
2152 return num_bde + 1;
2153
2154 if (!sgde) {
2155 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2156 "9065 BLKGRD:%s Invalid data segment\n",
2157 __func__);
2158 return 0;
2159 }
2160 bpl++;
2161 dataphysaddr = sg_dma_address(sgde) + split_offset;
2162 bpl->addrLow = le32_to_cpu(putPaddrLow(dataphysaddr));
2163 bpl->addrHigh = le32_to_cpu(putPaddrHigh(dataphysaddr));
2164
2165 remainder = sg_dma_len(sgde) - split_offset;
2166
2167 if ((subtotal + remainder) <= protgrp_bytes) {
2168
2169 bpl->tus.f.bdeSize = remainder;
2170 split_offset = 0;
2171
2172 if ((subtotal + remainder) == protgrp_bytes)
2173 pgdone = 1;
2174 } else {
2175
2176 bpl->tus.f.bdeSize = protgrp_bytes - subtotal;
2177 split_offset += bpl->tus.f.bdeSize;
2178 }
2179
2180 subtotal += bpl->tus.f.bdeSize;
2181
2182 if (datadir == DMA_TO_DEVICE)
2183 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
2184 else
2185 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
2186 bpl->tus.w = le32_to_cpu(bpl->tus.w);
2187
2188 num_bde++;
2189 curr_data++;
2190
2191 if (split_offset)
2192 break;
2193
2194
2195 sgde = sg_next(sgde);
2196
2197 }
2198
2199 if (protgroup_offset) {
2200
2201 reftag += protgrp_blks;
2202 bpl++;
2203 continue;
2204 }
2205
2206
2207 if (curr_prot == protcnt) {
2208 alldone = 1;
2209 } else if (curr_prot < protcnt) {
2210
2211 sgpe = sg_next(sgpe);
2212 bpl++;
2213
2214
2215 reftag += protgrp_blks;
2216 } else {
2217
2218 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2219 "9054 BLKGRD: bug in %s\n", __func__);
2220 }
2221
2222 } while (!alldone);
2223out:
2224
2225 return num_bde;
2226}
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257static int
2258lpfc_bg_setup_sgl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
2259 struct sli4_sge *sgl, int datasegcnt)
2260{
2261 struct scatterlist *sgde = NULL;
2262 struct sli4_sge_diseed *diseed = NULL;
2263 dma_addr_t physaddr;
2264 int i = 0, num_sge = 0, status;
2265 uint32_t reftag;
2266 unsigned blksize;
2267 uint8_t txop, rxop;
2268#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2269 uint32_t rc;
2270#endif
2271 uint32_t checking = 1;
2272 uint32_t dma_len;
2273 uint32_t dma_offset = 0;
2274
2275 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2276 if (status)
2277 goto out;
2278
2279
2280 blksize = lpfc_cmd_blksize(sc);
2281 reftag = (uint32_t)scsi_get_lba(sc);
2282
2283#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2284 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2285 if (rc) {
2286 if (rc & BG_ERR_SWAP)
2287 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2288 if (rc & BG_ERR_CHECK)
2289 checking = 0;
2290 }
2291#endif
2292
2293
2294 diseed = (struct sli4_sge_diseed *) sgl;
2295 memset(diseed, 0, sizeof(struct sli4_sge_diseed));
2296 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED);
2297
2298
2299 diseed->ref_tag = cpu_to_le32(reftag);
2300 diseed->ref_tag_tran = diseed->ref_tag;
2301
2302
2303
2304
2305
2306 if (sc->sc_data_direction == DMA_FROM_DEVICE) {
2307 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD))
2308 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
2309 else
2310 bf_set(lpfc_sli4_sge_dif_ce, diseed, 0);
2311
2312 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
2313 bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
2314 else
2315 bf_set(lpfc_sli4_sge_dif_re, diseed, 0);
2316 }
2317
2318
2319 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
2320 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
2321
2322 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
2323 bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
2324
2325
2326 diseed->word2 = cpu_to_le32(diseed->word2);
2327 diseed->word3 = cpu_to_le32(diseed->word3);
2328
2329
2330 num_sge++;
2331 sgl++;
2332
2333
2334 scsi_for_each_sg(sc, sgde, datasegcnt, i) {
2335 physaddr = sg_dma_address(sgde);
2336 dma_len = sg_dma_len(sgde);
2337 sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
2338 sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
2339 if ((i + 1) == datasegcnt)
2340 bf_set(lpfc_sli4_sge_last, sgl, 1);
2341 else
2342 bf_set(lpfc_sli4_sge_last, sgl, 0);
2343 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
2344 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
2345
2346 sgl->sge_len = cpu_to_le32(dma_len);
2347 dma_offset += dma_len;
2348
2349 sgl++;
2350 num_sge++;
2351 }
2352
2353out:
2354 return num_sge;
2355}
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394static int
2395lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
2396 struct sli4_sge *sgl, int datacnt, int protcnt)
2397{
2398 struct scatterlist *sgde = NULL;
2399 struct scatterlist *sgpe = NULL;
2400 struct sli4_sge_diseed *diseed = NULL;
2401 dma_addr_t dataphysaddr, protphysaddr;
2402 unsigned short curr_data = 0, curr_prot = 0;
2403 unsigned int split_offset;
2404 unsigned int protgroup_len, protgroup_offset = 0, protgroup_remainder;
2405 unsigned int protgrp_blks, protgrp_bytes;
2406 unsigned int remainder, subtotal;
2407 int status;
2408 unsigned char pgdone = 0, alldone = 0;
2409 unsigned blksize;
2410 uint32_t reftag;
2411 uint8_t txop, rxop;
2412 uint32_t dma_len;
2413#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2414 uint32_t rc;
2415#endif
2416 uint32_t checking = 1;
2417 uint32_t dma_offset = 0;
2418 int num_sge = 0;
2419
2420 sgpe = scsi_prot_sglist(sc);
2421 sgde = scsi_sglist(sc);
2422
2423 if (!sgpe || !sgde) {
2424 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2425 "9082 Invalid s/g entry: data=0x%p prot=0x%p\n",
2426 sgpe, sgde);
2427 return 0;
2428 }
2429
2430 status = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
2431 if (status)
2432 goto out;
2433
2434
2435 blksize = lpfc_cmd_blksize(sc);
2436 reftag = (uint32_t)scsi_get_lba(sc);
2437
2438#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
2439 rc = lpfc_bg_err_inject(phba, sc, &reftag, NULL, 1);
2440 if (rc) {
2441 if (rc & BG_ERR_SWAP)
2442 lpfc_bg_err_opcodes(phba, sc, &txop, &rxop);
2443 if (rc & BG_ERR_CHECK)
2444 checking = 0;
2445 }
2446#endif
2447
2448 split_offset = 0;
2449 do {
2450
2451 if (num_sge >= (phba->cfg_total_seg_cnt - 2))
2452 return num_sge + 3;
2453
2454
2455 diseed = (struct sli4_sge_diseed *) sgl;
2456 memset(diseed, 0, sizeof(struct sli4_sge_diseed));
2457 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DISEED);
2458
2459
2460 diseed->ref_tag = cpu_to_le32(reftag);
2461 diseed->ref_tag_tran = diseed->ref_tag;
2462
2463 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_GUARD)) {
2464 bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
2465
2466 } else {
2467 bf_set(lpfc_sli4_sge_dif_ce, diseed, 0);
2468
2469
2470
2471
2472
2473
2474
2475 if (txop == BG_OP_IN_CRC_OUT_CRC) {
2476 txop = BG_OP_RAW_MODE;
2477 rxop = BG_OP_RAW_MODE;
2478 }
2479 }
2480
2481
2482 if (lpfc_cmd_protect(sc, LPFC_CHECK_PROTECT_REF))
2483 bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
2484 else
2485 bf_set(lpfc_sli4_sge_dif_re, diseed, 0);
2486
2487
2488 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
2489 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
2490
2491 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
2492 bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
2493
2494
2495 diseed->word2 = cpu_to_le32(diseed->word2);
2496 diseed->word3 = cpu_to_le32(diseed->word3);
2497
2498
2499 num_sge++;
2500 sgl++;
2501
2502
2503 protphysaddr = sg_dma_address(sgpe) + protgroup_offset;
2504 protgroup_len = sg_dma_len(sgpe) - protgroup_offset;
2505
2506
2507 BUG_ON(protgroup_len % 8);
2508
2509
2510 sgl->word2 = 0;
2511 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DIF);
2512 sgl->addr_hi = le32_to_cpu(putPaddrHigh(protphysaddr));
2513 sgl->addr_lo = le32_to_cpu(putPaddrLow(protphysaddr));
2514 sgl->word2 = cpu_to_le32(sgl->word2);
2515
2516 protgrp_blks = protgroup_len / 8;
2517 protgrp_bytes = protgrp_blks * blksize;
2518
2519
2520 if ((sgl->addr_lo & 0xfff) + protgroup_len > 0x1000) {
2521 protgroup_remainder = 0x1000 - (sgl->addr_lo & 0xfff);
2522 protgroup_offset += protgroup_remainder;
2523 protgrp_blks = protgroup_remainder / 8;
2524 protgrp_bytes = protgrp_blks * blksize;
2525 } else {
2526 protgroup_offset = 0;
2527 curr_prot++;
2528 }
2529
2530 num_sge++;
2531
2532
2533 pgdone = 0;
2534 subtotal = 0;
2535 while (!pgdone) {
2536
2537 if (num_sge >= phba->cfg_total_seg_cnt)
2538 return num_sge + 1;
2539
2540 if (!sgde) {
2541 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2542 "9086 BLKGRD:%s Invalid data segment\n",
2543 __func__);
2544 return 0;
2545 }
2546 sgl++;
2547 dataphysaddr = sg_dma_address(sgde) + split_offset;
2548
2549 remainder = sg_dma_len(sgde) - split_offset;
2550
2551 if ((subtotal + remainder) <= protgrp_bytes) {
2552
2553 dma_len = remainder;
2554 split_offset = 0;
2555
2556 if ((subtotal + remainder) == protgrp_bytes)
2557 pgdone = 1;
2558 } else {
2559
2560 dma_len = protgrp_bytes - subtotal;
2561 split_offset += dma_len;
2562 }
2563
2564 subtotal += dma_len;
2565
2566 sgl->addr_lo = cpu_to_le32(putPaddrLow(dataphysaddr));
2567 sgl->addr_hi = cpu_to_le32(putPaddrHigh(dataphysaddr));
2568 bf_set(lpfc_sli4_sge_last, sgl, 0);
2569 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
2570 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
2571
2572 sgl->sge_len = cpu_to_le32(dma_len);
2573 dma_offset += dma_len;
2574
2575 num_sge++;
2576 curr_data++;
2577
2578 if (split_offset)
2579 break;
2580
2581
2582 sgde = sg_next(sgde);
2583 }
2584
2585 if (protgroup_offset) {
2586
2587 reftag += protgrp_blks;
2588 sgl++;
2589 continue;
2590 }
2591
2592
2593 if (curr_prot == protcnt) {
2594 bf_set(lpfc_sli4_sge_last, sgl, 1);
2595 alldone = 1;
2596 } else if (curr_prot < protcnt) {
2597
2598 sgpe = sg_next(sgpe);
2599 sgl++;
2600
2601
2602 reftag += protgrp_blks;
2603 } else {
2604
2605 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
2606 "9085 BLKGRD: bug in %s\n", __func__);
2607 }
2608
2609 } while (!alldone);
2610
2611out:
2612
2613 return num_sge;
2614}
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627static int
2628lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc)
2629{
2630 int ret = LPFC_PG_TYPE_INVALID;
2631 unsigned char op = scsi_get_prot_op(sc);
2632
2633 switch (op) {
2634 case SCSI_PROT_READ_STRIP:
2635 case SCSI_PROT_WRITE_INSERT:
2636 ret = LPFC_PG_TYPE_NO_DIF;
2637 break;
2638 case SCSI_PROT_READ_INSERT:
2639 case SCSI_PROT_WRITE_STRIP:
2640 case SCSI_PROT_READ_PASS:
2641 case SCSI_PROT_WRITE_PASS:
2642 ret = LPFC_PG_TYPE_DIF_BUF;
2643 break;
2644 default:
2645 if (phba)
2646 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2647 "9021 Unsupported protection op:%d\n",
2648 op);
2649 break;
2650 }
2651 return ret;
2652}
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664static int
2665lpfc_bg_scsi_adjust_dl(struct lpfc_hba *phba,
2666 struct lpfc_scsi_buf *lpfc_cmd)
2667{
2668 struct scsi_cmnd *sc = lpfc_cmd->pCmd;
2669 int fcpdl;
2670
2671 fcpdl = scsi_bufflen(sc);
2672
2673
2674 if (sc->sc_data_direction == DMA_FROM_DEVICE) {
2675
2676 if (scsi_get_prot_op(sc) == SCSI_PROT_READ_INSERT)
2677 return fcpdl;
2678
2679 } else {
2680
2681 if (scsi_get_prot_op(sc) == SCSI_PROT_WRITE_STRIP)
2682 return fcpdl;
2683 }
2684
2685
2686
2687
2688
2689
2690 fcpdl += (fcpdl / lpfc_cmd_blksize(sc)) * 8;
2691
2692 return fcpdl;
2693}
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704static int
2705lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
2706 struct lpfc_scsi_buf *lpfc_cmd)
2707{
2708 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
2709 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
2710 struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
2711 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
2712 uint32_t num_bde = 0;
2713 int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
2714 int prot_group_type = 0;
2715 int fcpdl;
2716
2717
2718
2719
2720
2721 bpl += 2;
2722 if (scsi_sg_count(scsi_cmnd)) {
2723
2724
2725
2726
2727
2728
2729 datasegcnt = dma_map_sg(&phba->pcidev->dev,
2730 scsi_sglist(scsi_cmnd),
2731 scsi_sg_count(scsi_cmnd), datadir);
2732 if (unlikely(!datasegcnt))
2733 return 1;
2734
2735 lpfc_cmd->seg_cnt = datasegcnt;
2736
2737
2738 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt)
2739 goto err;
2740
2741 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
2742
2743 switch (prot_group_type) {
2744 case LPFC_PG_TYPE_NO_DIF:
2745
2746
2747 if ((lpfc_cmd->seg_cnt + 2) > phba->cfg_total_seg_cnt)
2748 goto err;
2749
2750 num_bde = lpfc_bg_setup_bpl(phba, scsi_cmnd, bpl,
2751 datasegcnt);
2752
2753 if (num_bde < 2)
2754 goto err;
2755 break;
2756
2757 case LPFC_PG_TYPE_DIF_BUF:
2758
2759
2760
2761
2762
2763 protsegcnt = dma_map_sg(&phba->pcidev->dev,
2764 scsi_prot_sglist(scsi_cmnd),
2765 scsi_prot_sg_count(scsi_cmnd), datadir);
2766 if (unlikely(!protsegcnt)) {
2767 scsi_dma_unmap(scsi_cmnd);
2768 return 1;
2769 }
2770
2771 lpfc_cmd->prot_seg_cnt = protsegcnt;
2772
2773
2774
2775
2776
2777 if ((lpfc_cmd->prot_seg_cnt * 4) >
2778 (phba->cfg_total_seg_cnt - 2))
2779 goto err;
2780
2781 num_bde = lpfc_bg_setup_bpl_prot(phba, scsi_cmnd, bpl,
2782 datasegcnt, protsegcnt);
2783
2784 if ((num_bde < 3) ||
2785 (num_bde > phba->cfg_total_seg_cnt))
2786 goto err;
2787 break;
2788
2789 case LPFC_PG_TYPE_INVALID:
2790 default:
2791 scsi_dma_unmap(scsi_cmnd);
2792 lpfc_cmd->seg_cnt = 0;
2793
2794 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2795 "9022 Unexpected protection group %i\n",
2796 prot_group_type);
2797 return 1;
2798 }
2799 }
2800
2801
2802
2803
2804
2805
2806
2807 iocb_cmd->un.fcpi64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
2808 iocb_cmd->un.fcpi64.bdl.bdeSize += (num_bde * sizeof(struct ulp_bde64));
2809 iocb_cmd->ulpBdeCount = 1;
2810 iocb_cmd->ulpLe = 1;
2811
2812 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
2813 fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
2814
2815
2816
2817
2818
2819 iocb_cmd->un.fcpi.fcpi_parm = fcpdl;
2820
2821 return 0;
2822err:
2823 if (lpfc_cmd->seg_cnt)
2824 scsi_dma_unmap(scsi_cmnd);
2825 if (lpfc_cmd->prot_seg_cnt)
2826 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd),
2827 scsi_prot_sg_count(scsi_cmnd),
2828 scsi_cmnd->sc_data_direction);
2829
2830 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
2831 "9023 Cannot setup S/G List for HBA"
2832 "IO segs %d/%d BPL %d SCSI %d: %d %d\n",
2833 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
2834 phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt,
2835 prot_group_type, num_bde);
2836
2837 lpfc_cmd->seg_cnt = 0;
2838 lpfc_cmd->prot_seg_cnt = 0;
2839 return 1;
2840}
2841
2842
2843
2844
2845
2846
2847static uint16_t
2848lpfc_bg_crc(uint8_t *data, int count)
2849{
2850 uint16_t crc = 0;
2851 uint16_t x;
2852
2853 crc = crc_t10dif(data, count);
2854 x = cpu_to_be16(crc);
2855 return x;
2856}
2857
2858
2859
2860
2861
2862
2863static uint16_t
2864lpfc_bg_csum(uint8_t *data, int count)
2865{
2866 uint16_t ret;
2867
2868 ret = ip_compute_csum(data, count);
2869 return ret;
2870}
2871
2872
2873
2874
2875
2876static void
2877lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
2878{
2879 struct scatterlist *sgpe;
2880 struct scatterlist *sgde;
2881 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
2882 struct scsi_dif_tuple *src = NULL;
2883 uint8_t *data_src = NULL;
2884 uint16_t guard_tag, guard_type;
2885 uint16_t start_app_tag, app_tag;
2886 uint32_t start_ref_tag, ref_tag;
2887 int prot, protsegcnt;
2888 int err_type, len, data_len;
2889 int chk_ref, chk_app, chk_guard;
2890 uint16_t sum;
2891 unsigned blksize;
2892
2893 err_type = BGS_GUARD_ERR_MASK;
2894 sum = 0;
2895 guard_tag = 0;
2896
2897
2898 prot = scsi_get_prot_op(cmd);
2899 if ((prot == SCSI_PROT_READ_STRIP) ||
2900 (prot == SCSI_PROT_WRITE_INSERT) ||
2901 (prot == SCSI_PROT_NORMAL))
2902 goto out;
2903
2904
2905 chk_ref = 1;
2906 chk_app = 0;
2907 chk_guard = 0;
2908
2909
2910 sgpe = scsi_prot_sglist(cmd);
2911 protsegcnt = lpfc_cmd->prot_seg_cnt;
2912
2913 if (sgpe && protsegcnt) {
2914
2915
2916
2917
2918
2919 sgde = scsi_sglist(cmd);
2920 blksize = lpfc_cmd_blksize(cmd);
2921 data_src = (uint8_t *)sg_virt(sgde);
2922 data_len = sgde->length;
2923 if ((data_len & (blksize - 1)) == 0)
2924 chk_guard = 1;
2925 guard_type = scsi_host_get_guard(cmd->device->host);
2926
2927 src = (struct scsi_dif_tuple *)sg_virt(sgpe);
2928 start_ref_tag = (uint32_t)scsi_get_lba(cmd);
2929 start_app_tag = src->app_tag;
2930 len = sgpe->length;
2931 while (src && protsegcnt) {
2932 while (len) {
2933
2934
2935
2936
2937
2938 if ((src->ref_tag == 0xffffffff) ||
2939 (src->app_tag == 0xffff)) {
2940 start_ref_tag++;
2941 goto skipit;
2942 }
2943
2944
2945 if (chk_guard) {
2946 guard_tag = src->guard_tag;
2947 if (lpfc_cmd_guard_csum(cmd))
2948 sum = lpfc_bg_csum(data_src,
2949 blksize);
2950 else
2951 sum = lpfc_bg_crc(data_src,
2952 blksize);
2953 if ((guard_tag != sum)) {
2954 err_type = BGS_GUARD_ERR_MASK;
2955 goto out;
2956 }
2957 }
2958
2959
2960 ref_tag = be32_to_cpu(src->ref_tag);
2961 if (chk_ref && (ref_tag != start_ref_tag)) {
2962 err_type = BGS_REFTAG_ERR_MASK;
2963 goto out;
2964 }
2965 start_ref_tag++;
2966
2967
2968 app_tag = src->app_tag;
2969 if (chk_app && (app_tag != start_app_tag)) {
2970 err_type = BGS_APPTAG_ERR_MASK;
2971 goto out;
2972 }
2973skipit:
2974 len -= sizeof(struct scsi_dif_tuple);
2975 if (len < 0)
2976 len = 0;
2977 src++;
2978
2979 data_src += blksize;
2980 data_len -= blksize;
2981
2982
2983
2984
2985
2986
2987 if (chk_guard && (data_len == 0)) {
2988 chk_guard = 0;
2989 sgde = sg_next(sgde);
2990 if (!sgde)
2991 goto out;
2992
2993 data_src = (uint8_t *)sg_virt(sgde);
2994 data_len = sgde->length;
2995 if ((data_len & (blksize - 1)) == 0)
2996 chk_guard = 1;
2997 }
2998 }
2999
3000
3001 sgpe = sg_next(sgpe);
3002 if (sgpe) {
3003 src = (struct scsi_dif_tuple *)sg_virt(sgpe);
3004 len = sgpe->length;
3005 } else {
3006 src = NULL;
3007 }
3008 protsegcnt--;
3009 }
3010 }
3011out:
3012 if (err_type == BGS_GUARD_ERR_MASK) {
3013 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
3014 0x10, 0x1);
3015 cmd->result = DRIVER_SENSE << 24
3016 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
3017 phba->bg_guard_err_cnt++;
3018 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3019 "9069 BLKGRD: LBA %lx grd_tag error %x != %x\n",
3020 (unsigned long)scsi_get_lba(cmd),
3021 sum, guard_tag);
3022
3023 } else if (err_type == BGS_REFTAG_ERR_MASK) {
3024 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
3025 0x10, 0x3);
3026 cmd->result = DRIVER_SENSE << 24
3027 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
3028
3029 phba->bg_reftag_err_cnt++;
3030 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3031 "9066 BLKGRD: LBA %lx ref_tag error %x != %x\n",
3032 (unsigned long)scsi_get_lba(cmd),
3033 ref_tag, start_ref_tag);
3034
3035 } else if (err_type == BGS_APPTAG_ERR_MASK) {
3036 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
3037 0x10, 0x2);
3038 cmd->result = DRIVER_SENSE << 24
3039 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
3040
3041 phba->bg_apptag_err_cnt++;
3042 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3043 "9041 BLKGRD: LBA %lx app_tag error %x != %x\n",
3044 (unsigned long)scsi_get_lba(cmd),
3045 app_tag, start_app_tag);
3046 }
3047}
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062static int
3063lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
3064 struct lpfc_iocbq *pIocbOut)
3065{
3066 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
3067 struct sli3_bg_fields *bgf = &pIocbOut->iocb.unsli3.sli3_bg;
3068 int ret = 0;
3069 uint32_t bghm = bgf->bghm;
3070 uint32_t bgstat = bgf->bgstat;
3071 uint64_t failing_sector = 0;
3072
3073 spin_lock(&_dump_buf_lock);
3074 if (!_dump_buf_done) {
3075 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9070 BLKGRD: Saving"
3076 " Data for %u blocks to debugfs\n",
3077 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
3078 lpfc_debug_save_data(phba, cmd);
3079
3080
3081 if (lpfc_prot_group_type(phba, cmd) ==
3082 LPFC_PG_TYPE_DIF_BUF) {
3083 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9071 BLKGRD: "
3084 "Saving DIF for %u blocks to debugfs\n",
3085 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
3086 lpfc_debug_save_dif(phba, cmd);
3087 }
3088
3089 _dump_buf_done = 1;
3090 }
3091 spin_unlock(&_dump_buf_lock);
3092
3093 if (lpfc_bgs_get_invalid_prof(bgstat)) {
3094 cmd->result = ScsiResult(DID_ERROR, 0);
3095 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3096 "9072 BLKGRD: Invalid BG Profile in cmd"
3097 " 0x%x lba 0x%llx blk cnt 0x%x "
3098 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
3099 (unsigned long long)scsi_get_lba(cmd),
3100 blk_rq_sectors(cmd->request), bgstat, bghm);
3101 ret = (-1);
3102 goto out;
3103 }
3104
3105 if (lpfc_bgs_get_uninit_dif_block(bgstat)) {
3106 cmd->result = ScsiResult(DID_ERROR, 0);
3107 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3108 "9073 BLKGRD: Invalid BG PDIF Block in cmd"
3109 " 0x%x lba 0x%llx blk cnt 0x%x "
3110 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
3111 (unsigned long long)scsi_get_lba(cmd),
3112 blk_rq_sectors(cmd->request), bgstat, bghm);
3113 ret = (-1);
3114 goto out;
3115 }
3116
3117 if (lpfc_bgs_get_guard_err(bgstat)) {
3118 ret = 1;
3119
3120 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
3121 0x10, 0x1);
3122 cmd->result = DRIVER_SENSE << 24
3123 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
3124 phba->bg_guard_err_cnt++;
3125 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3126 "9055 BLKGRD: Guard Tag error in cmd"
3127 " 0x%x lba 0x%llx blk cnt 0x%x "
3128 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
3129 (unsigned long long)scsi_get_lba(cmd),
3130 blk_rq_sectors(cmd->request), bgstat, bghm);
3131 }
3132
3133 if (lpfc_bgs_get_reftag_err(bgstat)) {
3134 ret = 1;
3135
3136 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
3137 0x10, 0x3);
3138 cmd->result = DRIVER_SENSE << 24
3139 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
3140
3141 phba->bg_reftag_err_cnt++;
3142 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3143 "9056 BLKGRD: Ref Tag error in cmd"
3144 " 0x%x lba 0x%llx blk cnt 0x%x "
3145 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
3146 (unsigned long long)scsi_get_lba(cmd),
3147 blk_rq_sectors(cmd->request), bgstat, bghm);
3148 }
3149
3150 if (lpfc_bgs_get_apptag_err(bgstat)) {
3151 ret = 1;
3152
3153 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
3154 0x10, 0x2);
3155 cmd->result = DRIVER_SENSE << 24
3156 | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
3157
3158 phba->bg_apptag_err_cnt++;
3159 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3160 "9061 BLKGRD: App Tag error in cmd"
3161 " 0x%x lba 0x%llx blk cnt 0x%x "
3162 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
3163 (unsigned long long)scsi_get_lba(cmd),
3164 blk_rq_sectors(cmd->request), bgstat, bghm);
3165 }
3166
3167 if (lpfc_bgs_get_hi_water_mark_present(bgstat)) {
3168
3169
3170
3171
3172
3173
3174 cmd->sense_buffer[7] = 0xc;
3175 cmd->sense_buffer[8] = 0;
3176 cmd->sense_buffer[9] = 0xa;
3177 cmd->sense_buffer[10] = 0x80;
3178
3179
3180 switch (scsi_get_prot_op(cmd)) {
3181 case SCSI_PROT_READ_INSERT:
3182 case SCSI_PROT_WRITE_STRIP:
3183 bghm /= cmd->device->sector_size;
3184 break;
3185 case SCSI_PROT_READ_STRIP:
3186 case SCSI_PROT_WRITE_INSERT:
3187 case SCSI_PROT_READ_PASS:
3188 case SCSI_PROT_WRITE_PASS:
3189 bghm /= (cmd->device->sector_size +
3190 sizeof(struct scsi_dif_tuple));
3191 break;
3192 }
3193
3194 failing_sector = scsi_get_lba(cmd);
3195 failing_sector += bghm;
3196
3197
3198 put_unaligned_be64(failing_sector, &cmd->sense_buffer[12]);
3199 }
3200
3201 if (!ret) {
3202
3203 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
3204 "9057 BLKGRD: Unknown error in cmd"
3205 " 0x%x lba 0x%llx blk cnt 0x%x "
3206 "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
3207 (unsigned long long)scsi_get_lba(cmd),
3208 blk_rq_sectors(cmd->request), bgstat, bghm);
3209
3210
3211 lpfc_calc_bg_err(phba, lpfc_cmd);
3212 }
3213out:
3214 return ret;
3215}
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229static int
3230lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
3231{
3232 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3233 struct scatterlist *sgel = NULL;
3234 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3235 struct sli4_sge *sgl = (struct sli4_sge *)lpfc_cmd->fcp_bpl;
3236 struct sli4_sge *first_data_sgl;
3237 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3238 dma_addr_t physaddr;
3239 uint32_t num_bde = 0;
3240 uint32_t dma_len;
3241 uint32_t dma_offset = 0;
3242 int nseg;
3243 struct ulp_bde64 *bde;
3244
3245
3246
3247
3248
3249
3250
3251 if (scsi_sg_count(scsi_cmnd)) {
3252
3253
3254
3255
3256
3257
3258
3259 nseg = scsi_dma_map(scsi_cmnd);
3260 if (unlikely(!nseg))
3261 return 1;
3262 sgl += 1;
3263
3264 sgl->word2 = le32_to_cpu(sgl->word2);
3265 bf_set(lpfc_sli4_sge_last, sgl, 0);
3266 sgl->word2 = cpu_to_le32(sgl->word2);
3267 sgl += 1;
3268 first_data_sgl = sgl;
3269 lpfc_cmd->seg_cnt = nseg;
3270 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
3271 lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9074 BLKGRD:"
3272 " %s: Too many sg segments from "
3273 "dma_map_sg. Config %d, seg_cnt %d\n",
3274 __func__, phba->cfg_sg_seg_cnt,
3275 lpfc_cmd->seg_cnt);
3276 lpfc_cmd->seg_cnt = 0;
3277 scsi_dma_unmap(scsi_cmnd);
3278 return 1;
3279 }
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
3291 physaddr = sg_dma_address(sgel);
3292 dma_len = sg_dma_len(sgel);
3293 sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
3294 sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
3295 sgl->word2 = le32_to_cpu(sgl->word2);
3296 if ((num_bde + 1) == nseg)
3297 bf_set(lpfc_sli4_sge_last, sgl, 1);
3298 else
3299 bf_set(lpfc_sli4_sge_last, sgl, 0);
3300 bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
3301 bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA);
3302 sgl->word2 = cpu_to_le32(sgl->word2);
3303 sgl->sge_len = cpu_to_le32(dma_len);
3304 dma_offset += dma_len;
3305 sgl++;
3306 }
3307
3308 if (phba->sli3_options & LPFC_SLI4_PERFH_ENABLED) {
3309 bde = (struct ulp_bde64 *)
3310 &(iocb_cmd->unsli3.sli3Words[5]);
3311 bde->addrLow = first_data_sgl->addr_lo;
3312 bde->addrHigh = first_data_sgl->addr_hi;
3313 bde->tus.f.bdeSize =
3314 le32_to_cpu(first_data_sgl->sge_len);
3315 bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
3316 bde->tus.w = cpu_to_le32(bde->tus.w);
3317 }
3318 } else {
3319 sgl += 1;
3320
3321 sgl->word2 = le32_to_cpu(sgl->word2);
3322 bf_set(lpfc_sli4_sge_last, sgl, 1);
3323 sgl->word2 = cpu_to_le32(sgl->word2);
3324 }
3325
3326
3327
3328
3329
3330
3331
3332 fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
3333
3334
3335
3336
3337
3338 iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
3339
3340
3341
3342
3343
3344 if ((phba->cfg_fof) && ((struct lpfc_device_data *)
3345 scsi_cmnd->device->hostdata)->oas_enabled)
3346 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF);
3347 return 0;
3348}
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359static int
3360lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
3361 struct lpfc_scsi_buf *lpfc_cmd)
3362{
3363 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
3364 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
3365 struct sli4_sge *sgl = (struct sli4_sge *)(lpfc_cmd->fcp_bpl);
3366 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
3367 uint32_t num_sge = 0;
3368 int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
3369 int prot_group_type = 0;
3370 int fcpdl;
3371
3372
3373
3374
3375
3376 if (scsi_sg_count(scsi_cmnd)) {
3377
3378
3379
3380
3381
3382
3383 datasegcnt = dma_map_sg(&phba->pcidev->dev,
3384 scsi_sglist(scsi_cmnd),
3385 scsi_sg_count(scsi_cmnd), datadir);
3386 if (unlikely(!datasegcnt))
3387 return 1;
3388
3389 sgl += 1;
3390
3391 sgl->word2 = le32_to_cpu(sgl->word2);
3392 bf_set(lpfc_sli4_sge_last, sgl, 0);
3393 sgl->word2 = cpu_to_le32(sgl->word2);
3394
3395 sgl += 1;
3396 lpfc_cmd->seg_cnt = datasegcnt;
3397
3398
3399 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt)
3400 goto err;
3401
3402 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
3403
3404 switch (prot_group_type) {
3405 case LPFC_PG_TYPE_NO_DIF:
3406
3407 if ((lpfc_cmd->seg_cnt + 1) > phba->cfg_total_seg_cnt)
3408 goto err;
3409
3410 num_sge = lpfc_bg_setup_sgl(phba, scsi_cmnd, sgl,
3411 datasegcnt);
3412
3413
3414 if (num_sge < 2)
3415 goto err;
3416 break;
3417
3418 case LPFC_PG_TYPE_DIF_BUF:
3419
3420
3421
3422
3423
3424 protsegcnt = dma_map_sg(&phba->pcidev->dev,
3425 scsi_prot_sglist(scsi_cmnd),
3426 scsi_prot_sg_count(scsi_cmnd), datadir);
3427 if (unlikely(!protsegcnt)) {
3428 scsi_dma_unmap(scsi_cmnd);
3429 return 1;
3430 }
3431
3432 lpfc_cmd->prot_seg_cnt = protsegcnt;
3433
3434
3435
3436
3437 if ((lpfc_cmd->prot_seg_cnt * 3) >
3438 (phba->cfg_total_seg_cnt - 2))
3439 goto err;
3440
3441 num_sge = lpfc_bg_setup_sgl_prot(phba, scsi_cmnd, sgl,
3442 datasegcnt, protsegcnt);
3443
3444
3445 if ((num_sge < 3) ||
3446 (num_sge > phba->cfg_total_seg_cnt))
3447 goto err;
3448 break;
3449
3450 case LPFC_PG_TYPE_INVALID:
3451 default:
3452 scsi_dma_unmap(scsi_cmnd);
3453 lpfc_cmd->seg_cnt = 0;
3454
3455 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
3456 "9083 Unexpected protection group %i\n",
3457 prot_group_type);
3458 return 1;
3459 }
3460 }
3461
3462 switch (scsi_get_prot_op(scsi_cmnd)) {
3463 case SCSI_PROT_WRITE_STRIP:
3464 case SCSI_PROT_READ_STRIP:
3465 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_STRIP;
3466 break;
3467 case SCSI_PROT_WRITE_INSERT:
3468 case SCSI_PROT_READ_INSERT:
3469 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_INSERT;
3470 break;
3471 case SCSI_PROT_WRITE_PASS:
3472 case SCSI_PROT_READ_PASS:
3473 lpfc_cmd->cur_iocbq.iocb_flag |= LPFC_IO_DIF_PASS;
3474 break;
3475 }
3476
3477 fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
3478 fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
3479
3480
3481
3482
3483
3484 iocb_cmd->un.fcpi.fcpi_parm = fcpdl;
3485
3486
3487
3488
3489
3490 if ((phba->cfg_fof) && ((struct lpfc_device_data *)
3491 scsi_cmnd->device->hostdata)->oas_enabled)
3492 lpfc_cmd->cur_iocbq.iocb_flag |= (LPFC_IO_OAS | LPFC_IO_FOF);
3493
3494 return 0;
3495err:
3496 if (lpfc_cmd->seg_cnt)
3497 scsi_dma_unmap(scsi_cmnd);
3498 if (lpfc_cmd->prot_seg_cnt)
3499 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd),
3500 scsi_prot_sg_count(scsi_cmnd),
3501 scsi_cmnd->sc_data_direction);
3502
3503 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
3504 "9084 Cannot setup S/G List for HBA"
3505 "IO segs %d/%d SGL %d SCSI %d: %d %d\n",
3506 lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
3507 phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt,
3508 prot_group_type, num_sge);
3509
3510 lpfc_cmd->seg_cnt = 0;
3511 lpfc_cmd->prot_seg_cnt = 0;
3512 return 1;
3513}
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527static inline int
3528lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
3529{
3530 return phba->lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
3531}
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546static inline int
3547lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
3548{
3549 return phba->lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
3550}
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562static void
3563lpfc_send_scsi_error_event(struct lpfc_hba *phba, struct lpfc_vport *vport,
3564 struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_iocbq *rsp_iocb) {
3565 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3566 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3567 uint32_t resp_info = fcprsp->rspStatus2;
3568 uint32_t scsi_status = fcprsp->rspStatus3;
3569 uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
3570 struct lpfc_fast_path_event *fast_path_evt = NULL;
3571 struct lpfc_nodelist *pnode = lpfc_cmd->rdata->pnode;
3572 unsigned long flags;
3573
3574 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
3575 return;
3576
3577
3578 if ((cmnd->result == SAM_STAT_TASK_SET_FULL) ||
3579 (cmnd->result == SAM_STAT_BUSY)) {
3580 fast_path_evt = lpfc_alloc_fast_evt(phba);
3581 if (!fast_path_evt)
3582 return;
3583 fast_path_evt->un.scsi_evt.event_type =
3584 FC_REG_SCSI_EVENT;
3585 fast_path_evt->un.scsi_evt.subcategory =
3586 (cmnd->result == SAM_STAT_TASK_SET_FULL) ?
3587 LPFC_EVENT_QFULL : LPFC_EVENT_DEVBSY;
3588 fast_path_evt->un.scsi_evt.lun = cmnd->device->lun;
3589 memcpy(&fast_path_evt->un.scsi_evt.wwpn,
3590 &pnode->nlp_portname, sizeof(struct lpfc_name));
3591 memcpy(&fast_path_evt->un.scsi_evt.wwnn,
3592 &pnode->nlp_nodename, sizeof(struct lpfc_name));
3593 } else if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen &&
3594 ((cmnd->cmnd[0] == READ_10) || (cmnd->cmnd[0] == WRITE_10))) {
3595 fast_path_evt = lpfc_alloc_fast_evt(phba);
3596 if (!fast_path_evt)
3597 return;
3598 fast_path_evt->un.check_cond_evt.scsi_event.event_type =
3599 FC_REG_SCSI_EVENT;
3600 fast_path_evt->un.check_cond_evt.scsi_event.subcategory =
3601 LPFC_EVENT_CHECK_COND;
3602 fast_path_evt->un.check_cond_evt.scsi_event.lun =
3603 cmnd->device->lun;
3604 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwpn,
3605 &pnode->nlp_portname, sizeof(struct lpfc_name));
3606 memcpy(&fast_path_evt->un.check_cond_evt.scsi_event.wwnn,
3607 &pnode->nlp_nodename, sizeof(struct lpfc_name));
3608 fast_path_evt->un.check_cond_evt.sense_key =
3609 cmnd->sense_buffer[2] & 0xf;
3610 fast_path_evt->un.check_cond_evt.asc = cmnd->sense_buffer[12];
3611 fast_path_evt->un.check_cond_evt.ascq = cmnd->sense_buffer[13];
3612 } else if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
3613 fcpi_parm &&
3614 ((be32_to_cpu(fcprsp->rspResId) != fcpi_parm) ||
3615 ((scsi_status == SAM_STAT_GOOD) &&
3616 !(resp_info & (RESID_UNDER | RESID_OVER))))) {
3617
3618
3619
3620
3621 fast_path_evt = lpfc_alloc_fast_evt(phba);
3622 if (!fast_path_evt)
3623 return;
3624 fast_path_evt->un.read_check_error.header.event_type =
3625 FC_REG_FABRIC_EVENT;
3626 fast_path_evt->un.read_check_error.header.subcategory =
3627 LPFC_EVENT_FCPRDCHKERR;
3628 memcpy(&fast_path_evt->un.read_check_error.header.wwpn,
3629 &pnode->nlp_portname, sizeof(struct lpfc_name));
3630 memcpy(&fast_path_evt->un.read_check_error.header.wwnn,
3631 &pnode->nlp_nodename, sizeof(struct lpfc_name));
3632 fast_path_evt->un.read_check_error.lun = cmnd->device->lun;
3633 fast_path_evt->un.read_check_error.opcode = cmnd->cmnd[0];
3634 fast_path_evt->un.read_check_error.fcpiparam =
3635 fcpi_parm;
3636 } else
3637 return;
3638
3639 fast_path_evt->vport = vport;
3640 spin_lock_irqsave(&phba->hbalock, flags);
3641 list_add_tail(&fast_path_evt->work_evt.evt_listp, &phba->work_list);
3642 spin_unlock_irqrestore(&phba->hbalock, flags);
3643 lpfc_worker_wake_up(phba);
3644 return;
3645}
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655static void
3656lpfc_scsi_unprep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
3657{
3658
3659
3660
3661
3662
3663
3664 if (psb->seg_cnt > 0)
3665 scsi_dma_unmap(psb->pCmd);
3666 if (psb->prot_seg_cnt > 0)
3667 dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(psb->pCmd),
3668 scsi_prot_sg_count(psb->pCmd),
3669 psb->pCmd->sc_data_direction);
3670}
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682static void
3683lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
3684 struct lpfc_iocbq *rsp_iocb)
3685{
3686 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
3687 struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
3688 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
3689 uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
3690 uint32_t resp_info = fcprsp->rspStatus2;
3691 uint32_t scsi_status = fcprsp->rspStatus3;
3692 uint32_t *lp;
3693 uint32_t host_status = DID_OK;
3694 uint32_t rsplen = 0;
3695 uint32_t logit = LOG_FCP | LOG_FCP_ERROR;
3696
3697
3698
3699
3700
3701
3702
3703 if (fcpcmd->fcpCntl2) {
3704 scsi_status = 0;
3705 goto out;
3706 }
3707
3708 if (resp_info & RSP_LEN_VALID) {
3709 rsplen = be32_to_cpu(fcprsp->rspRspLen);
3710 if (rsplen != 0 && rsplen != 4 && rsplen != 8) {
3711 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
3712 "2719 Invalid response length: "
3713 "tgt x%x lun x%llx cmnd x%x rsplen x%x\n",
3714 cmnd->device->id,
3715 cmnd->device->lun, cmnd->cmnd[0],
3716 rsplen);
3717 host_status = DID_ERROR;
3718 goto out;
3719 }
3720 if (fcprsp->rspInfo3 != RSP_NO_FAILURE) {
3721 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
3722 "2757 Protocol failure detected during "
3723 "processing of FCP I/O op: "
3724 "tgt x%x lun x%llx cmnd x%x rspInfo3 x%x\n",
3725 cmnd->device->id,
3726 cmnd->device->lun, cmnd->cmnd[0],
3727 fcprsp->rspInfo3);
3728 host_status = DID_ERROR;
3729 goto out;
3730 }
3731 }
3732
3733 if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) {
3734 uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen);
3735 if (snslen > SCSI_SENSE_BUFFERSIZE)
3736 snslen = SCSI_SENSE_BUFFERSIZE;
3737
3738 if (resp_info & RSP_LEN_VALID)
3739 rsplen = be32_to_cpu(fcprsp->rspRspLen);
3740 memcpy(cmnd->sense_buffer, &fcprsp->rspInfo0 + rsplen, snslen);
3741 }
3742 lp = (uint32_t *)cmnd->sense_buffer;
3743
3744
3745 if (!scsi_status && (resp_info & RESID_UNDER)) {
3746
3747 if (vport->cfg_log_verbose & LOG_FCP)
3748 logit = LOG_FCP_ERROR;
3749
3750 if (vport->cfg_log_verbose & LOG_FCP_UNDER)
3751 logit = LOG_FCP_UNDER;
3752 }
3753
3754 lpfc_printf_vlog(vport, KERN_WARNING, logit,
3755 "9024 FCP command x%x failed: x%x SNS x%x x%x "
3756 "Data: x%x x%x x%x x%x x%x\n",
3757 cmnd->cmnd[0], scsi_status,
3758 be32_to_cpu(*lp), be32_to_cpu(*(lp + 3)), resp_info,
3759 be32_to_cpu(fcprsp->rspResId),
3760 be32_to_cpu(fcprsp->rspSnsLen),
3761 be32_to_cpu(fcprsp->rspRspLen),
3762 fcprsp->rspInfo3);
3763
3764 scsi_set_resid(cmnd, 0);
3765 if (resp_info & RESID_UNDER) {
3766 scsi_set_resid(cmnd, be32_to_cpu(fcprsp->rspResId));
3767
3768 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP_UNDER,
3769 "9025 FCP Read Underrun, expected %d, "
3770 "residual %d Data: x%x x%x x%x\n",
3771 be32_to_cpu(fcpcmd->fcpDl),
3772 scsi_get_resid(cmnd), fcpi_parm, cmnd->cmnd[0],
3773 cmnd->underflow);
3774
3775
3776
3777
3778
3779
3780 if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
3781 fcpi_parm &&
3782 (scsi_get_resid(cmnd) != fcpi_parm)) {
3783 lpfc_printf_vlog(vport, KERN_WARNING,
3784 LOG_FCP | LOG_FCP_ERROR,
3785 "9026 FCP Read Check Error "
3786 "and Underrun Data: x%x x%x x%x x%x\n",
3787 be32_to_cpu(fcpcmd->fcpDl),
3788 scsi_get_resid(cmnd), fcpi_parm,
3789 cmnd->cmnd[0]);
3790 scsi_set_resid(cmnd, scsi_bufflen(cmnd));
3791 host_status = DID_ERROR;
3792 }
3793
3794
3795
3796
3797
3798
3799 if (!(resp_info & SNS_LEN_VALID) &&
3800 (scsi_status == SAM_STAT_GOOD) &&
3801 (scsi_bufflen(cmnd) - scsi_get_resid(cmnd)
3802 < cmnd->underflow)) {
3803 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
3804 "9027 FCP command x%x residual "
3805 "underrun converted to error "
3806 "Data: x%x x%x x%x\n",
3807 cmnd->cmnd[0], scsi_bufflen(cmnd),
3808 scsi_get_resid(cmnd), cmnd->underflow);
3809 host_status = DID_ERROR;
3810 }
3811 } else if (resp_info & RESID_OVER) {
3812 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
3813 "9028 FCP command x%x residual overrun error. "
3814 "Data: x%x x%x\n", cmnd->cmnd[0],
3815 scsi_bufflen(cmnd), scsi_get_resid(cmnd));
3816 host_status = DID_ERROR;
3817
3818
3819
3820
3821
3822 } else if (fcpi_parm && (cmnd->sc_data_direction == DMA_FROM_DEVICE)) {
3823 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP | LOG_FCP_ERROR,
3824 "9029 FCP Read Check Error Data: "
3825 "x%x x%x x%x x%x x%x\n",
3826 be32_to_cpu(fcpcmd->fcpDl),
3827 be32_to_cpu(fcprsp->rspResId),
3828 fcpi_parm, cmnd->cmnd[0], scsi_status);
3829 switch (scsi_status) {
3830 case SAM_STAT_GOOD:
3831 case SAM_STAT_CHECK_CONDITION:
3832
3833
3834
3835
3836
3837 host_status = DID_ERROR;
3838 break;
3839 }
3840 scsi_set_resid(cmnd, scsi_bufflen(cmnd));
3841 }
3842
3843 out:
3844 cmnd->result = ScsiResult(host_status, scsi_status);
3845 lpfc_send_scsi_error_event(vport->phba, vport, lpfc_cmd, rsp_iocb);
3846}
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858static void
3859lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
3860 struct lpfc_iocbq *pIocbOut)
3861{
3862 struct lpfc_scsi_buf *lpfc_cmd =
3863 (struct lpfc_scsi_buf *) pIocbIn->context1;
3864 struct lpfc_vport *vport = pIocbIn->vport;
3865 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
3866 struct lpfc_nodelist *pnode = rdata->pnode;
3867 struct scsi_cmnd *cmd;
3868 int result;
3869 int depth;
3870 unsigned long flags;
3871 struct lpfc_fast_path_event *fast_path_evt;
3872 struct Scsi_Host *shost;
3873 uint32_t queue_depth, scsi_id;
3874 uint32_t logit = LOG_FCP;
3875
3876
3877 if (!(lpfc_cmd->pCmd))
3878 return;
3879 cmd = lpfc_cmd->pCmd;
3880 shost = cmd->device->host;
3881
3882 lpfc_cmd->result = (pIocbOut->iocb.un.ulpWord[4] & IOERR_PARAM_MASK);
3883 lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
3884
3885 lpfc_cmd->exch_busy = pIocbOut->iocb_flag & LPFC_EXCHANGE_BUSY;
3886
3887#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
3888 if (lpfc_cmd->prot_data_type) {
3889 struct scsi_dif_tuple *src = NULL;
3890
3891 src = (struct scsi_dif_tuple *)lpfc_cmd->prot_data_segment;
3892
3893
3894
3895
3896 switch (lpfc_cmd->prot_data_type) {
3897 case LPFC_INJERR_REFTAG:
3898 src->ref_tag =
3899 lpfc_cmd->prot_data;
3900 break;
3901 case LPFC_INJERR_APPTAG:
3902 src->app_tag =
3903 (uint16_t)lpfc_cmd->prot_data;
3904 break;
3905 case LPFC_INJERR_GUARD:
3906 src->guard_tag =
3907 (uint16_t)lpfc_cmd->prot_data;
3908 break;
3909 default:
3910 break;
3911 }
3912
3913 lpfc_cmd->prot_data = 0;
3914 lpfc_cmd->prot_data_type = 0;
3915 lpfc_cmd->prot_data_segment = NULL;
3916 }
3917#endif
3918 if (pnode && NLP_CHK_NODE_ACT(pnode))
3919 atomic_dec(&pnode->cmd_pending);
3920
3921 if (lpfc_cmd->status) {
3922 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
3923 (lpfc_cmd->result & IOERR_DRVR_MASK))
3924 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
3925 else if (lpfc_cmd->status >= IOSTAT_CNT)
3926 lpfc_cmd->status = IOSTAT_DEFAULT;
3927 if (lpfc_cmd->status == IOSTAT_FCP_RSP_ERROR &&
3928 !lpfc_cmd->fcp_rsp->rspStatus3 &&
3929 (lpfc_cmd->fcp_rsp->rspStatus2 & RESID_UNDER) &&
3930 !(vport->cfg_log_verbose & LOG_FCP_UNDER))
3931 logit = 0;
3932 else
3933 logit = LOG_FCP | LOG_FCP_UNDER;
3934 lpfc_printf_vlog(vport, KERN_WARNING, logit,
3935 "9030 FCP cmd x%x failed <%d/%lld> "
3936 "status: x%x result: x%x "
3937 "sid: x%x did: x%x oxid: x%x "
3938 "Data: x%x x%x\n",
3939 cmd->cmnd[0],
3940 cmd->device ? cmd->device->id : 0xffff,
3941 cmd->device ? cmd->device->lun : 0xffff,
3942 lpfc_cmd->status, lpfc_cmd->result,
3943 vport->fc_myDID,
3944 (pnode) ? pnode->nlp_DID : 0,
3945 phba->sli_rev == LPFC_SLI_REV4 ?
3946 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
3947 pIocbOut->iocb.ulpContext,
3948 lpfc_cmd->cur_iocbq.iocb.ulpIoTag);
3949
3950 switch (lpfc_cmd->status) {
3951 case IOSTAT_FCP_RSP_ERROR:
3952
3953 lpfc_handle_fcp_err(vport, lpfc_cmd, pIocbOut);
3954 break;
3955 case IOSTAT_NPORT_BSY:
3956 case IOSTAT_FABRIC_BSY:
3957 cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED, 0);
3958 fast_path_evt = lpfc_alloc_fast_evt(phba);
3959 if (!fast_path_evt)
3960 break;
3961 fast_path_evt->un.fabric_evt.event_type =
3962 FC_REG_FABRIC_EVENT;
3963 fast_path_evt->un.fabric_evt.subcategory =
3964 (lpfc_cmd->status == IOSTAT_NPORT_BSY) ?
3965 LPFC_EVENT_PORT_BUSY : LPFC_EVENT_FABRIC_BUSY;
3966 if (pnode && NLP_CHK_NODE_ACT(pnode)) {
3967 memcpy(&fast_path_evt->un.fabric_evt.wwpn,
3968 &pnode->nlp_portname,
3969 sizeof(struct lpfc_name));
3970 memcpy(&fast_path_evt->un.fabric_evt.wwnn,
3971 &pnode->nlp_nodename,
3972 sizeof(struct lpfc_name));
3973 }
3974 fast_path_evt->vport = vport;
3975 fast_path_evt->work_evt.evt =
3976 LPFC_EVT_FASTPATH_MGMT_EVT;
3977 spin_lock_irqsave(&phba->hbalock, flags);
3978 list_add_tail(&fast_path_evt->work_evt.evt_listp,
3979 &phba->work_list);
3980 spin_unlock_irqrestore(&phba->hbalock, flags);
3981 lpfc_worker_wake_up(phba);
3982 break;
3983 case IOSTAT_LOCAL_REJECT:
3984 case IOSTAT_REMOTE_STOP:
3985 if (lpfc_cmd->result == IOERR_ELXSEC_KEY_UNWRAP_ERROR ||
3986 lpfc_cmd->result ==
3987 IOERR_ELXSEC_KEY_UNWRAP_COMPARE_ERROR ||
3988 lpfc_cmd->result == IOERR_ELXSEC_CRYPTO_ERROR ||
3989 lpfc_cmd->result ==
3990 IOERR_ELXSEC_CRYPTO_COMPARE_ERROR) {
3991 cmd->result = ScsiResult(DID_NO_CONNECT, 0);
3992 break;
3993 }
3994 if (lpfc_cmd->result == IOERR_INVALID_RPI ||
3995 lpfc_cmd->result == IOERR_NO_RESOURCES ||
3996 lpfc_cmd->result == IOERR_ABORT_REQUESTED ||
3997 lpfc_cmd->result == IOERR_SLER_CMD_RCV_FAILURE) {
3998 cmd->result = ScsiResult(DID_REQUEUE, 0);
3999 break;
4000 }
4001 if ((lpfc_cmd->result == IOERR_RX_DMA_FAILED ||
4002 lpfc_cmd->result == IOERR_TX_DMA_FAILED) &&
4003 pIocbOut->iocb.unsli3.sli3_bg.bgstat) {
4004 if (scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
4005
4006
4007
4008
4009 lpfc_parse_bg_err(phba, lpfc_cmd,
4010 pIocbOut);
4011 break;
4012 } else {
4013 lpfc_printf_vlog(vport, KERN_WARNING,
4014 LOG_BG,
4015 "9031 non-zero BGSTAT "
4016 "on unprotected cmd\n");
4017 }
4018 }
4019 if ((lpfc_cmd->status == IOSTAT_REMOTE_STOP)
4020 && (phba->sli_rev == LPFC_SLI_REV4)
4021 && (pnode && NLP_CHK_NODE_ACT(pnode))) {
4022
4023
4024
4025
4026 lpfc_set_rrq_active(phba, pnode,
4027 lpfc_cmd->cur_iocbq.sli4_lxritag,
4028 0, 0);
4029 }
4030
4031 default:
4032 cmd->result = ScsiResult(DID_ERROR, 0);
4033 break;
4034 }
4035
4036 if (!pnode || !NLP_CHK_NODE_ACT(pnode)
4037 || (pnode->nlp_state != NLP_STE_MAPPED_NODE))
4038 cmd->result = ScsiResult(DID_TRANSPORT_DISRUPTED,
4039 SAM_STAT_BUSY);
4040 } else
4041 cmd->result = ScsiResult(DID_OK, 0);
4042
4043 if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) {
4044 uint32_t *lp = (uint32_t *)cmd->sense_buffer;
4045
4046 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4047 "0710 Iodone <%d/%llu> cmd %p, error "
4048 "x%x SNS x%x x%x Data: x%x x%x\n",
4049 cmd->device->id, cmd->device->lun, cmd,
4050 cmd->result, *lp, *(lp + 3), cmd->retries,
4051 scsi_get_resid(cmd));
4052 }
4053
4054 lpfc_update_stats(phba, lpfc_cmd);
4055 result = cmd->result;
4056 if (vport->cfg_max_scsicmpl_time &&
4057 time_after(jiffies, lpfc_cmd->start_time +
4058 msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) {
4059 spin_lock_irqsave(shost->host_lock, flags);
4060 if (pnode && NLP_CHK_NODE_ACT(pnode)) {
4061 if (pnode->cmd_qdepth >
4062 atomic_read(&pnode->cmd_pending) &&
4063 (atomic_read(&pnode->cmd_pending) >
4064 LPFC_MIN_TGT_QDEPTH) &&
4065 ((cmd->cmnd[0] == READ_10) ||
4066 (cmd->cmnd[0] == WRITE_10)))
4067 pnode->cmd_qdepth =
4068 atomic_read(&pnode->cmd_pending);
4069
4070 pnode->last_change_time = jiffies;
4071 }
4072 spin_unlock_irqrestore(shost->host_lock, flags);
4073 } else if (pnode && NLP_CHK_NODE_ACT(pnode)) {
4074 if ((pnode->cmd_qdepth < vport->cfg_tgt_queue_depth) &&
4075 time_after(jiffies, pnode->last_change_time +
4076 msecs_to_jiffies(LPFC_TGTQ_INTERVAL))) {
4077 spin_lock_irqsave(shost->host_lock, flags);
4078 depth = pnode->cmd_qdepth * LPFC_TGTQ_RAMPUP_PCENT
4079 / 100;
4080 depth = depth ? depth : 1;
4081 pnode->cmd_qdepth += depth;
4082 if (pnode->cmd_qdepth > vport->cfg_tgt_queue_depth)
4083 pnode->cmd_qdepth = vport->cfg_tgt_queue_depth;
4084 pnode->last_change_time = jiffies;
4085 spin_unlock_irqrestore(shost->host_lock, flags);
4086 }
4087 }
4088
4089 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
4090
4091
4092 queue_depth = cmd->device->queue_depth;
4093 scsi_id = cmd->device->id;
4094 cmd->scsi_done(cmd);
4095
4096 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
4097 spin_lock_irqsave(&phba->hbalock, flags);
4098 lpfc_cmd->pCmd = NULL;
4099 spin_unlock_irqrestore(&phba->hbalock, flags);
4100
4101
4102
4103
4104
4105 spin_lock_irqsave(shost->host_lock, flags);
4106 if (lpfc_cmd->waitq)
4107 wake_up(lpfc_cmd->waitq);
4108 spin_unlock_irqrestore(shost->host_lock, flags);
4109 lpfc_release_scsi_buf(phba, lpfc_cmd);
4110 return;
4111 }
4112
4113 spin_lock_irqsave(&phba->hbalock, flags);
4114 lpfc_cmd->pCmd = NULL;
4115 spin_unlock_irqrestore(&phba->hbalock, flags);
4116
4117
4118
4119
4120
4121 spin_lock_irqsave(shost->host_lock, flags);
4122 if (lpfc_cmd->waitq)
4123 wake_up(lpfc_cmd->waitq);
4124 spin_unlock_irqrestore(shost->host_lock, flags);
4125
4126 lpfc_release_scsi_buf(phba, lpfc_cmd);
4127}
4128
4129
4130
4131
4132
4133
4134
4135
4136
4137static void
4138lpfc_fcpcmd_to_iocb(uint8_t *data, struct fcp_cmnd *fcp_cmnd)
4139{
4140 int i, j;
4141 for (i = 0, j = 0; i < sizeof(struct fcp_cmnd);
4142 i += sizeof(uint32_t), j++) {
4143 ((uint32_t *)data)[j] = cpu_to_be32(((uint32_t *)fcp_cmnd)[j]);
4144 }
4145}
4146
4147
4148
4149
4150
4151
4152
4153
4154
4155
4156static void
4157lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
4158 struct lpfc_nodelist *pnode)
4159{
4160 struct lpfc_hba *phba = vport->phba;
4161 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
4162 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
4163 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
4164 struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
4165 int datadir = scsi_cmnd->sc_data_direction;
4166 uint8_t *ptr;
4167 bool sli4;
4168 uint32_t fcpdl;
4169
4170 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
4171 return;
4172
4173 lpfc_cmd->fcp_rsp->rspSnsLen = 0;
4174
4175 lpfc_cmd->fcp_cmnd->fcpCntl2 = 0;
4176
4177 int_to_scsilun(lpfc_cmd->pCmd->device->lun,
4178 &lpfc_cmd->fcp_cmnd->fcp_lun);
4179
4180 ptr = &fcp_cmnd->fcpCdb[0];
4181 memcpy(ptr, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
4182 if (scsi_cmnd->cmd_len < LPFC_FCP_CDB_LEN) {
4183 ptr += scsi_cmnd->cmd_len;
4184 memset(ptr, 0, (LPFC_FCP_CDB_LEN - scsi_cmnd->cmd_len));
4185 }
4186
4187 fcp_cmnd->fcpCntl1 = SIMPLE_Q;
4188
4189 sli4 = (phba->sli_rev == LPFC_SLI_REV4);
4190 piocbq->iocb.un.fcpi.fcpi_XRdy = 0;
4191
4192
4193
4194
4195
4196
4197
4198 if (scsi_sg_count(scsi_cmnd)) {
4199 if (datadir == DMA_TO_DEVICE) {
4200 iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
4201 iocb_cmd->ulpPU = PARM_READ_CHECK;
4202 if (vport->cfg_first_burst_size &&
4203 (pnode->nlp_flag & NLP_FIRSTBURST)) {
4204 fcpdl = scsi_bufflen(scsi_cmnd);
4205 if (fcpdl < vport->cfg_first_burst_size)
4206 piocbq->iocb.un.fcpi.fcpi_XRdy = fcpdl;
4207 else
4208 piocbq->iocb.un.fcpi.fcpi_XRdy =
4209 vport->cfg_first_burst_size;
4210 }
4211 fcp_cmnd->fcpCntl3 = WRITE_DATA;
4212 phba->fc4OutputRequests++;
4213 } else {
4214 iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR;
4215 iocb_cmd->ulpPU = PARM_READ_CHECK;
4216 fcp_cmnd->fcpCntl3 = READ_DATA;
4217 phba->fc4InputRequests++;
4218 }
4219 } else {
4220 iocb_cmd->ulpCommand = CMD_FCP_ICMND64_CR;
4221 iocb_cmd->un.fcpi.fcpi_parm = 0;
4222 iocb_cmd->ulpPU = 0;
4223 fcp_cmnd->fcpCntl3 = 0;
4224 phba->fc4ControlRequests++;
4225 }
4226 if (phba->sli_rev == 3 &&
4227 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED))
4228 lpfc_fcpcmd_to_iocb(iocb_cmd->unsli3.fcp_ext.icd, fcp_cmnd);
4229
4230
4231
4232
4233 piocbq->iocb.ulpContext = pnode->nlp_rpi;
4234 if (sli4)
4235 piocbq->iocb.ulpContext =
4236 phba->sli4_hba.rpi_ids[pnode->nlp_rpi];
4237 if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE)
4238 piocbq->iocb.ulpFCP2Rcvy = 1;
4239 else
4240 piocbq->iocb.ulpFCP2Rcvy = 0;
4241
4242 piocbq->iocb.ulpClass = (pnode->nlp_fcp_info & 0x0f);
4243 piocbq->context1 = lpfc_cmd;
4244 piocbq->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
4245 piocbq->iocb.ulpTimeout = lpfc_cmd->timeout;
4246 piocbq->vport = vport;
4247}
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261
4262
4263static int
4264lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
4265 struct lpfc_scsi_buf *lpfc_cmd,
4266 uint64_t lun,
4267 uint8_t task_mgmt_cmd)
4268{
4269 struct lpfc_iocbq *piocbq;
4270 IOCB_t *piocb;
4271 struct fcp_cmnd *fcp_cmnd;
4272 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
4273 struct lpfc_nodelist *ndlp = rdata->pnode;
4274
4275 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) ||
4276 ndlp->nlp_state != NLP_STE_MAPPED_NODE)
4277 return 0;
4278
4279 piocbq = &(lpfc_cmd->cur_iocbq);
4280 piocbq->vport = vport;
4281
4282 piocb = &piocbq->iocb;
4283
4284 fcp_cmnd = lpfc_cmd->fcp_cmnd;
4285
4286 memset(fcp_cmnd, 0, sizeof(struct fcp_cmnd));
4287 int_to_scsilun(lun, &fcp_cmnd->fcp_lun);
4288 fcp_cmnd->fcpCntl2 = task_mgmt_cmd;
4289 if (vport->phba->sli_rev == 3 &&
4290 !(vport->phba->sli3_options & LPFC_SLI3_BG_ENABLED))
4291 lpfc_fcpcmd_to_iocb(piocb->unsli3.fcp_ext.icd, fcp_cmnd);
4292 piocb->ulpCommand = CMD_FCP_ICMND64_CR;
4293 piocb->ulpContext = ndlp->nlp_rpi;
4294 if (vport->phba->sli_rev == LPFC_SLI_REV4) {
4295 piocb->ulpContext =
4296 vport->phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
4297 }
4298 piocb->ulpFCP2Rcvy = (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) ? 1 : 0;
4299 piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f);
4300 piocb->ulpPU = 0;
4301 piocb->un.fcpi.fcpi_parm = 0;
4302
4303
4304 if (lpfc_cmd->timeout > 0xff) {
4305
4306
4307
4308
4309 piocb->ulpTimeout = 0;
4310 } else
4311 piocb->ulpTimeout = lpfc_cmd->timeout;
4312
4313 if (vport->phba->sli_rev == LPFC_SLI_REV4)
4314 lpfc_sli4_set_rsp_sgl_last(vport->phba, lpfc_cmd);
4315
4316 return 1;
4317}
4318
4319
4320
4321
4322
4323
4324
4325
4326
4327
4328int
4329lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
4330{
4331
4332 phba->lpfc_scsi_unprep_dma_buf = lpfc_scsi_unprep_dma_buf;
4333 phba->lpfc_scsi_prep_cmnd = lpfc_scsi_prep_cmnd;
4334
4335 switch (dev_grp) {
4336 case LPFC_PCI_DEV_LP:
4337 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s3;
4338 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s3;
4339 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s3;
4340 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s3;
4341 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s3;
4342 break;
4343 case LPFC_PCI_DEV_OC:
4344 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s4;
4345 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s4;
4346 phba->lpfc_bg_scsi_prep_dma_buf = lpfc_bg_scsi_prep_dma_buf_s4;
4347 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s4;
4348 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s4;
4349 break;
4350 default:
4351 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4352 "1418 Invalid HBA PCI-device group: 0x%x\n",
4353 dev_grp);
4354 return -ENODEV;
4355 break;
4356 }
4357 phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth;
4358 phba->lpfc_scsi_cmd_iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
4359 return 0;
4360}
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371static void
4372lpfc_tskmgmt_def_cmpl(struct lpfc_hba *phba,
4373 struct lpfc_iocbq *cmdiocbq,
4374 struct lpfc_iocbq *rspiocbq)
4375{
4376 struct lpfc_scsi_buf *lpfc_cmd =
4377 (struct lpfc_scsi_buf *) cmdiocbq->context1;
4378 if (lpfc_cmd)
4379 lpfc_release_scsi_buf(phba, lpfc_cmd);
4380 return;
4381}
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392const char *
4393lpfc_info(struct Scsi_Host *host)
4394{
4395 struct lpfc_vport *vport = (struct lpfc_vport *) host->hostdata;
4396 struct lpfc_hba *phba = vport->phba;
4397 int len, link_speed = 0;
4398 static char lpfcinfobuf[384];
4399
4400 memset(lpfcinfobuf,0,384);
4401 if (phba && phba->pcidev){
4402 strncpy(lpfcinfobuf, phba->ModelDesc, 256);
4403 len = strlen(lpfcinfobuf);
4404 snprintf(lpfcinfobuf + len,
4405 384-len,
4406 " on PCI bus %02x device %02x irq %d",
4407 phba->pcidev->bus->number,
4408 phba->pcidev->devfn,
4409 phba->pcidev->irq);
4410 len = strlen(lpfcinfobuf);
4411 if (phba->Port[0]) {
4412 snprintf(lpfcinfobuf + len,
4413 384-len,
4414 " port %s",
4415 phba->Port);
4416 }
4417 len = strlen(lpfcinfobuf);
4418 if (phba->sli_rev <= LPFC_SLI_REV3) {
4419 link_speed = lpfc_sli_port_speed_get(phba);
4420 } else {
4421 if (phba->sli4_hba.link_state.logical_speed)
4422 link_speed =
4423 phba->sli4_hba.link_state.logical_speed;
4424 else
4425 link_speed = phba->sli4_hba.link_state.speed;
4426 }
4427 if (link_speed != 0)
4428 snprintf(lpfcinfobuf + len, 384-len,
4429 " Logical Link Speed: %d Mbps", link_speed);
4430 }
4431 return lpfcinfobuf;
4432}
4433
4434
4435
4436
4437
4438
4439
4440
4441static __inline__ void lpfc_poll_rearm_timer(struct lpfc_hba * phba)
4442{
4443 unsigned long poll_tmo_expires =
4444 (jiffies + msecs_to_jiffies(phba->cfg_poll_tmo));
4445
4446 if (!list_empty(&phba->sli.ring[LPFC_FCP_RING].txcmplq))
4447 mod_timer(&phba->fcp_poll_timer,
4448 poll_tmo_expires);
4449}
4450
4451
4452
4453
4454
4455
4456
4457void lpfc_poll_start_timer(struct lpfc_hba * phba)
4458{
4459 lpfc_poll_rearm_timer(phba);
4460}
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470void lpfc_poll_timeout(unsigned long ptr)
4471{
4472 struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
4473
4474 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
4475 lpfc_sli_handle_fast_ring_event(phba,
4476 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
4477
4478 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4479 lpfc_poll_rearm_timer(phba);
4480 }
4481}
4482
4483
4484
4485
4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496static int
4497lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
4498{
4499 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4500 struct lpfc_hba *phba = vport->phba;
4501 struct lpfc_rport_data *rdata;
4502 struct lpfc_nodelist *ndlp;
4503 struct lpfc_scsi_buf *lpfc_cmd;
4504 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
4505 int err;
4506
4507 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
4508 err = fc_remote_port_chkready(rport);
4509 if (err) {
4510 cmnd->result = err;
4511 goto out_fail_command;
4512 }
4513 ndlp = rdata->pnode;
4514
4515 if ((scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) &&
4516 (!(phba->sli3_options & LPFC_SLI3_BG_ENABLED))) {
4517
4518 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4519 "9058 BLKGRD: ERROR: rcvd protected cmd:%02x"
4520 " op:%02x str=%s without registering for"
4521 " BlockGuard - Rejecting command\n",
4522 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
4523 dif_op_str[scsi_get_prot_op(cmnd)]);
4524 goto out_fail_command;
4525 }
4526
4527
4528
4529
4530
4531 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
4532 goto out_tgt_busy;
4533 if (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth)
4534 goto out_tgt_busy;
4535
4536 lpfc_cmd = lpfc_get_scsi_buf(phba, ndlp);
4537 if (lpfc_cmd == NULL) {
4538 lpfc_rampdown_queue_depth(phba);
4539
4540 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4541 "0707 driver's buffer pool is empty, "
4542 "IO busied\n");
4543 goto out_host_busy;
4544 }
4545
4546
4547
4548
4549
4550 lpfc_cmd->pCmd = cmnd;
4551 lpfc_cmd->rdata = rdata;
4552 lpfc_cmd->timeout = 0;
4553 lpfc_cmd->start_time = jiffies;
4554 cmnd->host_scribble = (unsigned char *)lpfc_cmd;
4555
4556 if (scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
4557 if (vport->phba->cfg_enable_bg) {
4558 lpfc_printf_vlog(vport,
4559 KERN_INFO, LOG_SCSI_CMD,
4560 "9033 BLKGRD: rcvd %s cmd:x%x "
4561 "sector x%llx cnt %u pt %x\n",
4562 dif_op_str[scsi_get_prot_op(cmnd)],
4563 cmnd->cmnd[0],
4564 (unsigned long long)scsi_get_lba(cmnd),
4565 blk_rq_sectors(cmnd->request),
4566 (cmnd->cmnd[1]>>5));
4567 }
4568 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
4569 } else {
4570 if (vport->phba->cfg_enable_bg) {
4571 lpfc_printf_vlog(vport,
4572 KERN_INFO, LOG_SCSI_CMD,
4573 "9038 BLKGRD: rcvd PROT_NORMAL cmd: "
4574 "x%x sector x%llx cnt %u pt %x\n",
4575 cmnd->cmnd[0],
4576 (unsigned long long)scsi_get_lba(cmnd),
4577 blk_rq_sectors(cmnd->request),
4578 (cmnd->cmnd[1]>>5));
4579 }
4580 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
4581 }
4582
4583 if (err)
4584 goto out_host_busy_free_buf;
4585
4586 lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp);
4587
4588 atomic_inc(&ndlp->cmd_pending);
4589 err = lpfc_sli_issue_iocb(phba, LPFC_FCP_RING,
4590 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
4591 if (err) {
4592 atomic_dec(&ndlp->cmd_pending);
4593 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4594 "3376 FCP could not issue IOCB err %x"
4595 "FCP cmd x%x <%d/%llu> "
4596 "sid: x%x did: x%x oxid: x%x "
4597 "Data: x%x x%x x%x x%x\n",
4598 err, cmnd->cmnd[0],
4599 cmnd->device ? cmnd->device->id : 0xffff,
4600 cmnd->device ? cmnd->device->lun : (u64) -1,
4601 vport->fc_myDID, ndlp->nlp_DID,
4602 phba->sli_rev == LPFC_SLI_REV4 ?
4603 lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
4604 lpfc_cmd->cur_iocbq.iocb.ulpContext,
4605 lpfc_cmd->cur_iocbq.iocb.ulpIoTag,
4606 lpfc_cmd->cur_iocbq.iocb.ulpTimeout,
4607 (uint32_t)
4608 (cmnd->request->timeout / 1000));
4609
4610
4611 goto out_host_busy_free_buf;
4612 }
4613 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
4614 lpfc_sli_handle_fast_ring_event(phba,
4615 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
4616
4617 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4618 lpfc_poll_rearm_timer(phba);
4619 }
4620
4621 return 0;
4622
4623 out_host_busy_free_buf:
4624 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
4625 lpfc_release_scsi_buf(phba, lpfc_cmd);
4626 out_host_busy:
4627 return SCSI_MLQUEUE_HOST_BUSY;
4628
4629 out_tgt_busy:
4630 return SCSI_MLQUEUE_TARGET_BUSY;
4631
4632 out_fail_command:
4633 cmnd->scsi_done(cmnd);
4634 return 0;
4635}
4636
4637
4638
4639
4640
4641
4642
4643
4644
4645
4646
4647
4648static int
4649lpfc_abort_handler(struct scsi_cmnd *cmnd)
4650{
4651 struct Scsi_Host *shost = cmnd->device->host;
4652 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4653 struct lpfc_hba *phba = vport->phba;
4654 struct lpfc_iocbq *iocb;
4655 struct lpfc_iocbq *abtsiocb;
4656 struct lpfc_scsi_buf *lpfc_cmd;
4657 IOCB_t *cmd, *icmd;
4658 int ret = SUCCESS, status = 0;
4659 struct lpfc_sli_ring *pring_s4;
4660 int ring_number, ret_val;
4661 unsigned long flags, iflags;
4662 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq);
4663
4664 status = fc_block_scsi_eh(cmnd);
4665 if (status != 0 && status != SUCCESS)
4666 return status;
4667
4668 spin_lock_irqsave(&phba->hbalock, flags);
4669
4670 if (phba->hba_flag & HBA_FCP_IOQ_FLUSH) {
4671 spin_unlock_irqrestore(&phba->hbalock, flags);
4672 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4673 "3168 SCSI Layer abort requested I/O has been "
4674 "flushed by LLD.\n");
4675 return FAILED;
4676 }
4677
4678 lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble;
4679 if (!lpfc_cmd || !lpfc_cmd->pCmd) {
4680 spin_unlock_irqrestore(&phba->hbalock, flags);
4681 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4682 "2873 SCSI Layer I/O Abort Request IO CMPL Status "
4683 "x%x ID %d LUN %llu\n",
4684 SUCCESS, cmnd->device->id, cmnd->device->lun);
4685 return SUCCESS;
4686 }
4687
4688 iocb = &lpfc_cmd->cur_iocbq;
4689
4690 if (!(iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ)) {
4691 spin_unlock_irqrestore(&phba->hbalock, flags);
4692 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4693 "3169 SCSI Layer abort requested I/O has been "
4694 "cancelled by LLD.\n");
4695 return FAILED;
4696 }
4697
4698
4699
4700
4701
4702
4703 if (lpfc_cmd->pCmd != cmnd) {
4704 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4705 "3170 SCSI Layer abort requested I/O has been "
4706 "completed by LLD.\n");
4707 goto out_unlock;
4708 }
4709
4710 BUG_ON(iocb->context1 != lpfc_cmd);
4711
4712
4713 if (iocb->iocb_flag & LPFC_DRIVER_ABORTED) {
4714 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4715 "3389 SCSI Layer I/O Abort Request is pending\n");
4716 spin_unlock_irqrestore(&phba->hbalock, flags);
4717 goto wait_for_cmpl;
4718 }
4719
4720 abtsiocb = __lpfc_sli_get_iocbq(phba);
4721 if (abtsiocb == NULL) {
4722 ret = FAILED;
4723 goto out_unlock;
4724 }
4725
4726
4727 iocb->iocb_flag |= LPFC_DRIVER_ABORTED;
4728
4729
4730
4731
4732
4733
4734
4735 cmd = &iocb->iocb;
4736 icmd = &abtsiocb->iocb;
4737 icmd->un.acxri.abortType = ABORT_TYPE_ABTS;
4738 icmd->un.acxri.abortContextTag = cmd->ulpContext;
4739 if (phba->sli_rev == LPFC_SLI_REV4)
4740 icmd->un.acxri.abortIoTag = iocb->sli4_xritag;
4741 else
4742 icmd->un.acxri.abortIoTag = cmd->ulpIoTag;
4743
4744 icmd->ulpLe = 1;
4745 icmd->ulpClass = cmd->ulpClass;
4746
4747
4748 abtsiocb->fcp_wqidx = iocb->fcp_wqidx;
4749 abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
4750 if (iocb->iocb_flag & LPFC_IO_FOF)
4751 abtsiocb->iocb_flag |= LPFC_IO_FOF;
4752
4753 if (lpfc_is_link_up(phba))
4754 icmd->ulpCommand = CMD_ABORT_XRI_CN;
4755 else
4756 icmd->ulpCommand = CMD_CLOSE_XRI_CN;
4757
4758 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
4759 abtsiocb->vport = vport;
4760 if (phba->sli_rev == LPFC_SLI_REV4) {
4761 ring_number = MAX_SLI3_CONFIGURED_RINGS + iocb->fcp_wqidx;
4762 pring_s4 = &phba->sli.ring[ring_number];
4763
4764 spin_lock_irqsave(&pring_s4->ring_lock, iflags);
4765 ret_val = __lpfc_sli_issue_iocb(phba, pring_s4->ringno,
4766 abtsiocb, 0);
4767 spin_unlock_irqrestore(&pring_s4->ring_lock, iflags);
4768 } else {
4769 ret_val = __lpfc_sli_issue_iocb(phba, LPFC_FCP_RING,
4770 abtsiocb, 0);
4771 }
4772
4773 spin_unlock_irqrestore(&phba->hbalock, flags);
4774
4775
4776 if (ret_val == IOCB_ERROR) {
4777 lpfc_sli_release_iocbq(phba, abtsiocb);
4778 ret = FAILED;
4779 goto out;
4780 }
4781
4782 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
4783 lpfc_sli_handle_fast_ring_event(phba,
4784 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
4785
4786wait_for_cmpl:
4787 lpfc_cmd->waitq = &waitq;
4788
4789 wait_event_timeout(waitq,
4790 (lpfc_cmd->pCmd != cmnd),
4791 msecs_to_jiffies(2*vport->cfg_devloss_tmo*1000));
4792
4793 spin_lock_irqsave(shost->host_lock, flags);
4794 lpfc_cmd->waitq = NULL;
4795 spin_unlock_irqrestore(shost->host_lock, flags);
4796
4797 if (lpfc_cmd->pCmd == cmnd) {
4798 ret = FAILED;
4799 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4800 "0748 abort handler timed out waiting "
4801 "for abortng I/O (xri:x%x) to complete: "
4802 "ret %#x, ID %d, LUN %llu\n",
4803 iocb->sli4_xritag, ret,
4804 cmnd->device->id, cmnd->device->lun);
4805 }
4806 goto out;
4807
4808out_unlock:
4809 spin_unlock_irqrestore(&phba->hbalock, flags);
4810out:
4811 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
4812 "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
4813 "LUN %llu\n", ret, cmnd->device->id,
4814 cmnd->device->lun);
4815 return ret;
4816}
4817
4818static char *
4819lpfc_taskmgmt_name(uint8_t task_mgmt_cmd)
4820{
4821 switch (task_mgmt_cmd) {
4822 case FCP_ABORT_TASK_SET:
4823 return "ABORT_TASK_SET";
4824 case FCP_CLEAR_TASK_SET:
4825 return "FCP_CLEAR_TASK_SET";
4826 case FCP_BUS_RESET:
4827 return "FCP_BUS_RESET";
4828 case FCP_LUN_RESET:
4829 return "FCP_LUN_RESET";
4830 case FCP_TARGET_RESET:
4831 return "FCP_TARGET_RESET";
4832 case FCP_CLEAR_ACA:
4833 return "FCP_CLEAR_ACA";
4834 case FCP_TERMINATE_TASK:
4835 return "FCP_TERMINATE_TASK";
4836 default:
4837 return "unknown";
4838 }
4839}
4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
4850
4851
4852
4853static int
4854lpfc_check_fcp_rsp(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd)
4855{
4856 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
4857 uint32_t rsp_info;
4858 uint32_t rsp_len;
4859 uint8_t rsp_info_code;
4860 int ret = FAILED;
4861
4862
4863 if (fcprsp == NULL)
4864 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4865 "0703 fcp_rsp is missing\n");
4866 else {
4867 rsp_info = fcprsp->rspStatus2;
4868 rsp_len = be32_to_cpu(fcprsp->rspRspLen);
4869 rsp_info_code = fcprsp->rspInfo3;
4870
4871
4872 lpfc_printf_vlog(vport, KERN_INFO,
4873 LOG_FCP,
4874 "0706 fcp_rsp valid 0x%x,"
4875 " rsp len=%d code 0x%x\n",
4876 rsp_info,
4877 rsp_len, rsp_info_code);
4878
4879 if ((fcprsp->rspStatus2&RSP_LEN_VALID) && (rsp_len == 8)) {
4880 switch (rsp_info_code) {
4881 case RSP_NO_FAILURE:
4882 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4883 "0715 Task Mgmt No Failure\n");
4884 ret = SUCCESS;
4885 break;
4886 case RSP_TM_NOT_SUPPORTED:
4887 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4888 "0716 Task Mgmt Target "
4889 "reject\n");
4890 break;
4891 case RSP_TM_NOT_COMPLETED:
4892 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4893 "0717 Task Mgmt Target "
4894 "failed TM\n");
4895 break;
4896 case RSP_TM_INVALID_LU:
4897 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4898 "0718 Task Mgmt to invalid "
4899 "LUN\n");
4900 break;
4901 }
4902 }
4903 }
4904 return ret;
4905}
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918
4919
4920
4921
4922
4923static int
4924lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata,
4925 unsigned tgt_id, uint64_t lun_id,
4926 uint8_t task_mgmt_cmd)
4927{
4928 struct lpfc_hba *phba = vport->phba;
4929 struct lpfc_scsi_buf *lpfc_cmd;
4930 struct lpfc_iocbq *iocbq;
4931 struct lpfc_iocbq *iocbqrsp;
4932 struct lpfc_nodelist *pnode = rdata->pnode;
4933 int ret;
4934 int status;
4935
4936 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
4937 return FAILED;
4938
4939 lpfc_cmd = lpfc_get_scsi_buf(phba, rdata->pnode);
4940 if (lpfc_cmd == NULL)
4941 return FAILED;
4942 lpfc_cmd->timeout = phba->cfg_task_mgmt_tmo;
4943 lpfc_cmd->rdata = rdata;
4944
4945 status = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun_id,
4946 task_mgmt_cmd);
4947 if (!status) {
4948 lpfc_release_scsi_buf(phba, lpfc_cmd);
4949 return FAILED;
4950 }
4951
4952 iocbq = &lpfc_cmd->cur_iocbq;
4953 iocbqrsp = lpfc_sli_get_iocbq(phba);
4954 if (iocbqrsp == NULL) {
4955 lpfc_release_scsi_buf(phba, lpfc_cmd);
4956 return FAILED;
4957 }
4958 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
4959
4960 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
4961 "0702 Issue %s to TGT %d LUN %llu "
4962 "rpi x%x nlp_flag x%x Data: x%x x%x\n",
4963 lpfc_taskmgmt_name(task_mgmt_cmd), tgt_id, lun_id,
4964 pnode->nlp_rpi, pnode->nlp_flag, iocbq->sli4_xritag,
4965 iocbq->iocb_flag);
4966
4967 status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING,
4968 iocbq, iocbqrsp, lpfc_cmd->timeout);
4969 if ((status != IOCB_SUCCESS) ||
4970 (iocbqrsp->iocb.ulpStatus != IOSTAT_SUCCESS)) {
4971 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
4972 "0727 TMF %s to TGT %d LUN %llu failed (%d, %d) "
4973 "iocb_flag x%x\n",
4974 lpfc_taskmgmt_name(task_mgmt_cmd),
4975 tgt_id, lun_id, iocbqrsp->iocb.ulpStatus,
4976 iocbqrsp->iocb.un.ulpWord[4],
4977 iocbq->iocb_flag);
4978
4979 if (status == IOCB_SUCCESS) {
4980 if (iocbqrsp->iocb.ulpStatus == IOSTAT_FCP_RSP_ERROR)
4981
4982
4983 ret = lpfc_check_fcp_rsp(vport, lpfc_cmd);
4984 else
4985 ret = FAILED;
4986 } else if (status == IOCB_TIMEDOUT) {
4987 ret = TIMEOUT_ERROR;
4988 } else {
4989 ret = FAILED;
4990 }
4991 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
4992 } else
4993 ret = SUCCESS;
4994
4995 lpfc_sli_release_iocbq(phba, iocbqrsp);
4996
4997 if (ret != TIMEOUT_ERROR)
4998 lpfc_release_scsi_buf(phba, lpfc_cmd);
4999
5000 return ret;
5001}
5002
5003
5004
5005
5006
5007
5008
5009
5010
5011
5012
5013
5014
5015static int
5016lpfc_chk_tgt_mapped(struct lpfc_vport *vport, struct scsi_cmnd *cmnd)
5017{
5018 struct lpfc_rport_data *rdata;
5019 struct lpfc_nodelist *pnode;
5020 unsigned long later;
5021
5022 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
5023 if (!rdata) {
5024 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
5025 "0797 Tgt Map rport failure: rdata x%p\n", rdata);
5026 return FAILED;
5027 }
5028 pnode = rdata->pnode;
5029
5030
5031
5032
5033 later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
5034 while (time_after(later, jiffies)) {
5035 if (!pnode || !NLP_CHK_NODE_ACT(pnode))
5036 return FAILED;
5037 if (pnode->nlp_state == NLP_STE_MAPPED_NODE)
5038 return SUCCESS;
5039 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
5040 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
5041 if (!rdata)
5042 return FAILED;
5043 pnode = rdata->pnode;
5044 }
5045 if (!pnode || !NLP_CHK_NODE_ACT(pnode) ||
5046 (pnode->nlp_state != NLP_STE_MAPPED_NODE))
5047 return FAILED;
5048 return SUCCESS;
5049}
5050
5051
5052
5053
5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067static int
5068lpfc_reset_flush_io_context(struct lpfc_vport *vport, uint16_t tgt_id,
5069 uint64_t lun_id, lpfc_ctx_cmd context)
5070{
5071 struct lpfc_hba *phba = vport->phba;
5072 unsigned long later;
5073 int cnt;
5074
5075 cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context);
5076 if (cnt)
5077 lpfc_sli_abort_taskmgmt(vport,
5078 &phba->sli.ring[phba->sli.fcp_ring],
5079 tgt_id, lun_id, context);
5080 later = msecs_to_jiffies(2 * vport->cfg_devloss_tmo * 1000) + jiffies;
5081 while (time_after(later, jiffies) && cnt) {
5082 schedule_timeout_uninterruptible(msecs_to_jiffies(20));
5083 cnt = lpfc_sli_sum_iocb(vport, tgt_id, lun_id, context);
5084 }
5085 if (cnt) {
5086 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5087 "0724 I/O flush failure for context %s : cnt x%x\n",
5088 ((context == LPFC_CTX_LUN) ? "LUN" :
5089 ((context == LPFC_CTX_TGT) ? "TGT" :
5090 ((context == LPFC_CTX_HOST) ? "HOST" : "Unknown"))),
5091 cnt);
5092 return FAILED;
5093 }
5094 return SUCCESS;
5095}
5096
5097
5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108static int
5109lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
5110{
5111 struct Scsi_Host *shost = cmnd->device->host;
5112 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5113 struct lpfc_rport_data *rdata;
5114 struct lpfc_nodelist *pnode;
5115 unsigned tgt_id = cmnd->device->id;
5116 uint64_t lun_id = cmnd->device->lun;
5117 struct lpfc_scsi_event_header scsi_event;
5118 int status;
5119
5120 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
5121 if (!rdata || !rdata->pnode) {
5122 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5123 "0798 Device Reset rport failure: rdata x%p\n",
5124 rdata);
5125 return FAILED;
5126 }
5127 pnode = rdata->pnode;
5128 status = fc_block_scsi_eh(cmnd);
5129 if (status != 0 && status != SUCCESS)
5130 return status;
5131
5132 status = lpfc_chk_tgt_mapped(vport, cmnd);
5133 if (status == FAILED) {
5134 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5135 "0721 Device Reset rport failure: rdata x%p\n", rdata);
5136 return FAILED;
5137 }
5138
5139 scsi_event.event_type = FC_REG_SCSI_EVENT;
5140 scsi_event.subcategory = LPFC_EVENT_LUNRESET;
5141 scsi_event.lun = lun_id;
5142 memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name));
5143 memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name));
5144
5145 fc_host_post_vendor_event(shost, fc_get_event_number(),
5146 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
5147
5148 status = lpfc_send_taskmgmt(vport, rdata, tgt_id, lun_id,
5149 FCP_LUN_RESET);
5150
5151 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5152 "0713 SCSI layer issued Device Reset (%d, %llu) "
5153 "return x%x\n", tgt_id, lun_id, status);
5154
5155
5156
5157
5158
5159
5160
5161 if (status == SUCCESS)
5162 status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
5163 LPFC_CTX_LUN);
5164
5165 return status;
5166}
5167
5168
5169
5170
5171
5172
5173
5174
5175
5176
5177
5178
5179static int
5180lpfc_target_reset_handler(struct scsi_cmnd *cmnd)
5181{
5182 struct Scsi_Host *shost = cmnd->device->host;
5183 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5184 struct lpfc_rport_data *rdata;
5185 struct lpfc_nodelist *pnode;
5186 unsigned tgt_id = cmnd->device->id;
5187 uint64_t lun_id = cmnd->device->lun;
5188 struct lpfc_scsi_event_header scsi_event;
5189 int status;
5190
5191 rdata = lpfc_rport_data_from_scsi_device(cmnd->device);
5192 if (!rdata) {
5193 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5194 "0799 Target Reset rport failure: rdata x%p\n", rdata);
5195 return FAILED;
5196 }
5197 pnode = rdata->pnode;
5198 status = fc_block_scsi_eh(cmnd);
5199 if (status != 0 && status != SUCCESS)
5200 return status;
5201
5202 status = lpfc_chk_tgt_mapped(vport, cmnd);
5203 if (status == FAILED) {
5204 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5205 "0722 Target Reset rport failure: rdata x%p\n", rdata);
5206 if (pnode) {
5207 spin_lock_irq(shost->host_lock);
5208 pnode->nlp_flag &= ~NLP_NPR_ADISC;
5209 pnode->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
5210 spin_unlock_irq(shost->host_lock);
5211 }
5212 lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
5213 LPFC_CTX_TGT);
5214 return FAST_IO_FAIL;
5215 }
5216
5217 scsi_event.event_type = FC_REG_SCSI_EVENT;
5218 scsi_event.subcategory = LPFC_EVENT_TGTRESET;
5219 scsi_event.lun = 0;
5220 memcpy(scsi_event.wwpn, &pnode->nlp_portname, sizeof(struct lpfc_name));
5221 memcpy(scsi_event.wwnn, &pnode->nlp_nodename, sizeof(struct lpfc_name));
5222
5223 fc_host_post_vendor_event(shost, fc_get_event_number(),
5224 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
5225
5226 status = lpfc_send_taskmgmt(vport, rdata, tgt_id, lun_id,
5227 FCP_TARGET_RESET);
5228
5229 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5230 "0723 SCSI layer issued Target Reset (%d, %llu) "
5231 "return x%x\n", tgt_id, lun_id, status);
5232
5233
5234
5235
5236
5237
5238
5239 if (status == SUCCESS)
5240 status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
5241 LPFC_CTX_TGT);
5242 return status;
5243}
5244
5245
5246
5247
5248
5249
5250
5251
5252
5253
5254
5255
5256static int
5257lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
5258{
5259 struct Scsi_Host *shost = cmnd->device->host;
5260 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5261 struct lpfc_nodelist *ndlp = NULL;
5262 struct lpfc_scsi_event_header scsi_event;
5263 int match;
5264 int ret = SUCCESS, status, i;
5265
5266 scsi_event.event_type = FC_REG_SCSI_EVENT;
5267 scsi_event.subcategory = LPFC_EVENT_BUSRESET;
5268 scsi_event.lun = 0;
5269 memcpy(scsi_event.wwpn, &vport->fc_portname, sizeof(struct lpfc_name));
5270 memcpy(scsi_event.wwnn, &vport->fc_nodename, sizeof(struct lpfc_name));
5271
5272 fc_host_post_vendor_event(shost, fc_get_event_number(),
5273 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
5274
5275 status = fc_block_scsi_eh(cmnd);
5276 if (status != 0 && status != SUCCESS)
5277 return status;
5278
5279
5280
5281
5282
5283
5284 for (i = 0; i < LPFC_MAX_TARGET; i++) {
5285
5286 match = 0;
5287 spin_lock_irq(shost->host_lock);
5288 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
5289 if (!NLP_CHK_NODE_ACT(ndlp))
5290 continue;
5291 if (vport->phba->cfg_fcp2_no_tgt_reset &&
5292 (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE))
5293 continue;
5294 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
5295 ndlp->nlp_sid == i &&
5296 ndlp->rport) {
5297 match = 1;
5298 break;
5299 }
5300 }
5301 spin_unlock_irq(shost->host_lock);
5302 if (!match)
5303 continue;
5304
5305 status = lpfc_send_taskmgmt(vport, ndlp->rport->dd_data,
5306 i, 0, FCP_TARGET_RESET);
5307
5308 if (status != SUCCESS) {
5309 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5310 "0700 Bus Reset on target %d failed\n",
5311 i);
5312 ret = FAILED;
5313 }
5314 }
5315
5316
5317
5318
5319
5320
5321
5322 status = lpfc_reset_flush_io_context(vport, 0, 0, LPFC_CTX_HOST);
5323 if (status != SUCCESS)
5324 ret = FAILED;
5325
5326 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5327 "0714 SCSI layer issued Bus Reset Data: x%x\n", ret);
5328 return ret;
5329}
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344
5345
5346
5347static int
5348lpfc_host_reset_handler(struct scsi_cmnd *cmnd)
5349{
5350 struct Scsi_Host *shost = cmnd->device->host;
5351 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5352 struct lpfc_hba *phba = vport->phba;
5353 int rc, ret = SUCCESS;
5354
5355 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5356 "3172 SCSI layer issued Host Reset Data:\n");
5357
5358 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
5359 lpfc_offline(phba);
5360 rc = lpfc_sli_brdrestart(phba);
5361 if (rc)
5362 ret = FAILED;
5363 rc = lpfc_online(phba);
5364 if (rc)
5365 ret = FAILED;
5366 lpfc_unblock_mgmt_io(phba);
5367
5368 if (ret == FAILED) {
5369 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5370 "3323 Failed host reset, bring it offline\n");
5371 lpfc_sli4_offline_eratt(phba);
5372 }
5373 return ret;
5374}
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389static int
5390lpfc_slave_alloc(struct scsi_device *sdev)
5391{
5392 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5393 struct lpfc_hba *phba = vport->phba;
5394 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
5395 uint32_t total = 0;
5396 uint32_t num_to_alloc = 0;
5397 int num_allocated = 0;
5398 uint32_t sdev_cnt;
5399 struct lpfc_device_data *device_data;
5400 unsigned long flags;
5401 struct lpfc_name target_wwpn;
5402
5403 if (!rport || fc_remote_port_chkready(rport))
5404 return -ENXIO;
5405
5406 if (phba->cfg_fof) {
5407
5408
5409
5410
5411
5412
5413 u64_to_wwn(rport->port_name, target_wwpn.u.wwn);
5414 spin_lock_irqsave(&phba->devicelock, flags);
5415 device_data = __lpfc_get_device_data(phba,
5416 &phba->luns,
5417 &vport->fc_portname,
5418 &target_wwpn,
5419 sdev->lun);
5420 if (!device_data) {
5421 spin_unlock_irqrestore(&phba->devicelock, flags);
5422 device_data = lpfc_create_device_data(phba,
5423 &vport->fc_portname,
5424 &target_wwpn,
5425 sdev->lun, true);
5426 if (!device_data)
5427 return -ENOMEM;
5428 spin_lock_irqsave(&phba->devicelock, flags);
5429 list_add_tail(&device_data->listentry, &phba->luns);
5430 }
5431 device_data->rport_data = rport->dd_data;
5432 device_data->available = true;
5433 spin_unlock_irqrestore(&phba->devicelock, flags);
5434 sdev->hostdata = device_data;
5435 } else {
5436 sdev->hostdata = rport->dd_data;
5437 }
5438 sdev_cnt = atomic_inc_return(&phba->sdev_cnt);
5439
5440
5441
5442
5443
5444
5445
5446
5447 total = phba->total_scsi_bufs;
5448 num_to_alloc = vport->cfg_lun_queue_depth + 2;
5449
5450
5451 if ((sdev_cnt * (vport->cfg_lun_queue_depth + 2)) < total)
5452 return 0;
5453
5454
5455 if (total >= phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
5456 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
5457 "0704 At limitation of %d preallocated "
5458 "command buffers\n", total);
5459 return 0;
5460
5461 } else if (total + num_to_alloc >
5462 phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
5463 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
5464 "0705 Allocation request of %d "
5465 "command buffers will exceed max of %d. "
5466 "Reducing allocation request to %d.\n",
5467 num_to_alloc, phba->cfg_hba_queue_depth,
5468 (phba->cfg_hba_queue_depth - total));
5469 num_to_alloc = phba->cfg_hba_queue_depth - total;
5470 }
5471 num_allocated = lpfc_new_scsi_buf(vport, num_to_alloc);
5472 if (num_to_alloc != num_allocated) {
5473 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
5474 "0708 Allocation request of %d "
5475 "command buffers did not succeed. "
5476 "Allocated %d buffers.\n",
5477 num_to_alloc, num_allocated);
5478 }
5479 if (num_allocated > 0)
5480 phba->total_scsi_bufs += num_allocated;
5481 return 0;
5482}
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
5494
5495static int
5496lpfc_slave_configure(struct scsi_device *sdev)
5497{
5498 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5499 struct lpfc_hba *phba = vport->phba;
5500
5501 scsi_change_queue_depth(sdev, vport->cfg_lun_queue_depth);
5502
5503 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
5504 lpfc_sli_handle_fast_ring_event(phba,
5505 &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
5506 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
5507 lpfc_poll_rearm_timer(phba);
5508 }
5509
5510 return 0;
5511}
5512
5513
5514
5515
5516
5517
5518
5519static void
5520lpfc_slave_destroy(struct scsi_device *sdev)
5521{
5522 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
5523 struct lpfc_hba *phba = vport->phba;
5524 unsigned long flags;
5525 struct lpfc_device_data *device_data = sdev->hostdata;
5526
5527 atomic_dec(&phba->sdev_cnt);
5528 if ((phba->cfg_fof) && (device_data)) {
5529 spin_lock_irqsave(&phba->devicelock, flags);
5530 device_data->available = false;
5531 if (!device_data->oas_enabled)
5532 lpfc_delete_device_data(phba, device_data);
5533 spin_unlock_irqrestore(&phba->devicelock, flags);
5534 }
5535 sdev->hostdata = NULL;
5536 return;
5537}
5538
5539
5540
5541
5542
5543
5544
5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
5555
5556
5557struct lpfc_device_data*
5558lpfc_create_device_data(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5559 struct lpfc_name *target_wwpn, uint64_t lun,
5560 bool atomic_create)
5561{
5562
5563 struct lpfc_device_data *lun_info;
5564 int memory_flags;
5565
5566 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5567 !(phba->cfg_fof))
5568 return NULL;
5569
5570
5571
5572 if (atomic_create)
5573 memory_flags = GFP_ATOMIC;
5574 else
5575 memory_flags = GFP_KERNEL;
5576 lun_info = mempool_alloc(phba->device_data_mem_pool, memory_flags);
5577 if (!lun_info)
5578 return NULL;
5579 INIT_LIST_HEAD(&lun_info->listentry);
5580 lun_info->rport_data = NULL;
5581 memcpy(&lun_info->device_id.vport_wwpn, vport_wwpn,
5582 sizeof(struct lpfc_name));
5583 memcpy(&lun_info->device_id.target_wwpn, target_wwpn,
5584 sizeof(struct lpfc_name));
5585 lun_info->device_id.lun = lun;
5586 lun_info->oas_enabled = false;
5587 lun_info->available = false;
5588 return lun_info;
5589}
5590
5591
5592
5593
5594
5595
5596
5597
5598
5599void
5600lpfc_delete_device_data(struct lpfc_hba *phba,
5601 struct lpfc_device_data *lun_info)
5602{
5603
5604 if (unlikely(!phba) || !lun_info ||
5605 !(phba->cfg_fof))
5606 return;
5607
5608 if (!list_empty(&lun_info->listentry))
5609 list_del(&lun_info->listentry);
5610 mempool_free(lun_info, phba->device_data_mem_pool);
5611 return;
5612}
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628
5629
5630struct lpfc_device_data*
5631__lpfc_get_device_data(struct lpfc_hba *phba, struct list_head *list,
5632 struct lpfc_name *vport_wwpn,
5633 struct lpfc_name *target_wwpn, uint64_t lun)
5634{
5635
5636 struct lpfc_device_data *lun_info;
5637
5638 if (unlikely(!phba) || !list || !vport_wwpn || !target_wwpn ||
5639 !phba->cfg_fof)
5640 return NULL;
5641
5642
5643
5644 list_for_each_entry(lun_info, list, listentry) {
5645 if ((memcmp(&lun_info->device_id.vport_wwpn, vport_wwpn,
5646 sizeof(struct lpfc_name)) == 0) &&
5647 (memcmp(&lun_info->device_id.target_wwpn, target_wwpn,
5648 sizeof(struct lpfc_name)) == 0) &&
5649 (lun_info->device_id.lun == lun))
5650 return lun_info;
5651 }
5652
5653 return NULL;
5654}
5655
5656
5657
5658
5659
5660
5661
5662
5663
5664
5665
5666
5667
5668
5669
5670
5671
5672
5673
5674
5675
5676
5677
5678
5679
5680
5681
5682bool
5683lpfc_find_next_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5684 struct lpfc_name *target_wwpn, uint64_t *starting_lun,
5685 struct lpfc_name *found_vport_wwpn,
5686 struct lpfc_name *found_target_wwpn,
5687 uint64_t *found_lun,
5688 uint32_t *found_lun_status)
5689{
5690
5691 unsigned long flags;
5692 struct lpfc_device_data *lun_info;
5693 struct lpfc_device_id *device_id;
5694 uint64_t lun;
5695 bool found = false;
5696
5697 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5698 !starting_lun || !found_vport_wwpn ||
5699 !found_target_wwpn || !found_lun || !found_lun_status ||
5700 (*starting_lun == NO_MORE_OAS_LUN) ||
5701 !phba->cfg_fof)
5702 return false;
5703
5704 lun = *starting_lun;
5705 *found_lun = NO_MORE_OAS_LUN;
5706 *starting_lun = NO_MORE_OAS_LUN;
5707
5708
5709
5710 spin_lock_irqsave(&phba->devicelock, flags);
5711 list_for_each_entry(lun_info, &phba->luns, listentry) {
5712 if (((wwn_to_u64(vport_wwpn->u.wwn) == 0) ||
5713 (memcmp(&lun_info->device_id.vport_wwpn, vport_wwpn,
5714 sizeof(struct lpfc_name)) == 0)) &&
5715 ((wwn_to_u64(target_wwpn->u.wwn) == 0) ||
5716 (memcmp(&lun_info->device_id.target_wwpn, target_wwpn,
5717 sizeof(struct lpfc_name)) == 0)) &&
5718 (lun_info->oas_enabled)) {
5719 device_id = &lun_info->device_id;
5720 if ((!found) &&
5721 ((lun == FIND_FIRST_OAS_LUN) ||
5722 (device_id->lun == lun))) {
5723 *found_lun = device_id->lun;
5724 memcpy(found_vport_wwpn,
5725 &device_id->vport_wwpn,
5726 sizeof(struct lpfc_name));
5727 memcpy(found_target_wwpn,
5728 &device_id->target_wwpn,
5729 sizeof(struct lpfc_name));
5730 if (lun_info->available)
5731 *found_lun_status =
5732 OAS_LUN_STATUS_EXISTS;
5733 else
5734 *found_lun_status = 0;
5735 if (phba->cfg_oas_flags & OAS_FIND_ANY_VPORT)
5736 memset(vport_wwpn, 0x0,
5737 sizeof(struct lpfc_name));
5738 if (phba->cfg_oas_flags & OAS_FIND_ANY_TARGET)
5739 memset(target_wwpn, 0x0,
5740 sizeof(struct lpfc_name));
5741 found = true;
5742 } else if (found) {
5743 *starting_lun = device_id->lun;
5744 memcpy(vport_wwpn, &device_id->vport_wwpn,
5745 sizeof(struct lpfc_name));
5746 memcpy(target_wwpn, &device_id->target_wwpn,
5747 sizeof(struct lpfc_name));
5748 break;
5749 }
5750 }
5751 }
5752 spin_unlock_irqrestore(&phba->devicelock, flags);
5753 return found;
5754}
5755
5756
5757
5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773
5774
5775
5776bool
5777lpfc_enable_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5778 struct lpfc_name *target_wwpn, uint64_t lun)
5779{
5780
5781 struct lpfc_device_data *lun_info;
5782 unsigned long flags;
5783
5784 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5785 !phba->cfg_fof)
5786 return false;
5787
5788 spin_lock_irqsave(&phba->devicelock, flags);
5789
5790
5791 lun_info = __lpfc_get_device_data(phba, &phba->luns, vport_wwpn,
5792 target_wwpn, lun);
5793 if (lun_info) {
5794 if (!lun_info->oas_enabled)
5795 lun_info->oas_enabled = true;
5796 spin_unlock_irqrestore(&phba->devicelock, flags);
5797 return true;
5798 }
5799
5800
5801 lun_info = lpfc_create_device_data(phba, vport_wwpn, target_wwpn, lun,
5802 false);
5803 if (lun_info) {
5804 lun_info->oas_enabled = true;
5805 lun_info->available = false;
5806 list_add_tail(&lun_info->listentry, &phba->luns);
5807 spin_unlock_irqrestore(&phba->devicelock, flags);
5808 return true;
5809 }
5810 spin_unlock_irqrestore(&phba->devicelock, flags);
5811 return false;
5812}
5813
5814
5815
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826
5827
5828
5829
5830
5831
5832
5833bool
5834lpfc_disable_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
5835 struct lpfc_name *target_wwpn, uint64_t lun)
5836{
5837
5838 struct lpfc_device_data *lun_info;
5839 unsigned long flags;
5840
5841 if (unlikely(!phba) || !vport_wwpn || !target_wwpn ||
5842 !phba->cfg_fof)
5843 return false;
5844
5845 spin_lock_irqsave(&phba->devicelock, flags);
5846
5847
5848 lun_info = __lpfc_get_device_data(phba,
5849 &phba->luns, vport_wwpn,
5850 target_wwpn, lun);
5851 if (lun_info) {
5852 lun_info->oas_enabled = false;
5853 if (!lun_info->available)
5854 lpfc_delete_device_data(phba, lun_info);
5855 spin_unlock_irqrestore(&phba->devicelock, flags);
5856 return true;
5857 }
5858
5859 spin_unlock_irqrestore(&phba->devicelock, flags);
5860 return false;
5861}
5862
5863struct scsi_host_template lpfc_template_s3 = {
5864 .module = THIS_MODULE,
5865 .name = LPFC_DRIVER_NAME,
5866 .info = lpfc_info,
5867 .queuecommand = lpfc_queuecommand,
5868 .eh_abort_handler = lpfc_abort_handler,
5869 .eh_device_reset_handler = lpfc_device_reset_handler,
5870 .eh_target_reset_handler = lpfc_target_reset_handler,
5871 .eh_bus_reset_handler = lpfc_bus_reset_handler,
5872 .slave_alloc = lpfc_slave_alloc,
5873 .slave_configure = lpfc_slave_configure,
5874 .slave_destroy = lpfc_slave_destroy,
5875 .scan_finished = lpfc_scan_finished,
5876 .this_id = -1,
5877 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT,
5878 .cmd_per_lun = LPFC_CMD_PER_LUN,
5879 .use_clustering = ENABLE_CLUSTERING,
5880 .shost_attrs = lpfc_hba_attrs,
5881 .max_sectors = 0xFFFF,
5882 .vendor_id = LPFC_NL_VENDOR_ID,
5883 .change_queue_depth = scsi_change_queue_depth,
5884 .use_blk_tags = 1,
5885 .track_queue_depth = 1,
5886};
5887
5888struct scsi_host_template lpfc_template = {
5889 .module = THIS_MODULE,
5890 .name = LPFC_DRIVER_NAME,
5891 .info = lpfc_info,
5892 .queuecommand = lpfc_queuecommand,
5893 .eh_abort_handler = lpfc_abort_handler,
5894 .eh_device_reset_handler = lpfc_device_reset_handler,
5895 .eh_target_reset_handler = lpfc_target_reset_handler,
5896 .eh_bus_reset_handler = lpfc_bus_reset_handler,
5897 .eh_host_reset_handler = lpfc_host_reset_handler,
5898 .slave_alloc = lpfc_slave_alloc,
5899 .slave_configure = lpfc_slave_configure,
5900 .slave_destroy = lpfc_slave_destroy,
5901 .scan_finished = lpfc_scan_finished,
5902 .this_id = -1,
5903 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT,
5904 .cmd_per_lun = LPFC_CMD_PER_LUN,
5905 .use_clustering = ENABLE_CLUSTERING,
5906 .shost_attrs = lpfc_hba_attrs,
5907 .max_sectors = 0xFFFF,
5908 .vendor_id = LPFC_NL_VENDOR_ID,
5909 .change_queue_depth = scsi_change_queue_depth,
5910 .use_blk_tags = 1,
5911 .track_queue_depth = 1,
5912};
5913
5914struct scsi_host_template lpfc_vport_template = {
5915 .module = THIS_MODULE,
5916 .name = LPFC_DRIVER_NAME,
5917 .info = lpfc_info,
5918 .queuecommand = lpfc_queuecommand,
5919 .eh_abort_handler = lpfc_abort_handler,
5920 .eh_device_reset_handler = lpfc_device_reset_handler,
5921 .eh_target_reset_handler = lpfc_target_reset_handler,
5922 .eh_bus_reset_handler = lpfc_bus_reset_handler,
5923 .slave_alloc = lpfc_slave_alloc,
5924 .slave_configure = lpfc_slave_configure,
5925 .slave_destroy = lpfc_slave_destroy,
5926 .scan_finished = lpfc_scan_finished,
5927 .this_id = -1,
5928 .sg_tablesize = LPFC_DEFAULT_SG_SEG_CNT,
5929 .cmd_per_lun = LPFC_CMD_PER_LUN,
5930 .use_clustering = ENABLE_CLUSTERING,
5931 .shost_attrs = lpfc_vport_attrs,
5932 .max_sectors = 0xFFFF,
5933 .change_queue_depth = scsi_change_queue_depth,
5934 .use_blk_tags = 1,
5935 .track_queue_depth = 1,
5936};
5937