2 * qla_target.c SCSI LLD infrastructure for QLogic 22xx/23xx/24xx/25xx
4 * based on qla2x00t.c code:
6 * Copyright (C) 2004 - 2010 Vladislav Bolkhovitin <vst@vlnb.net>
7 * Copyright (C) 2004 - 2005 Leonid Stoljar
8 * Copyright (C) 2006 Nathaniel Clark <nate@misrule.us>
9 * Copyright (C) 2006 - 2010 ID7 Ltd.
11 * Forward port and refactoring to modern qla2xxx and target/configfs
13 * Copyright (C) 2010-2013 Nicholas A. Bellinger <nab@kernel.org>
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation, version 2
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/types.h>
29 #include <linux/blkdev.h>
30 #include <linux/interrupt.h>
31 #include <linux/pci.h>
32 #include <linux/delay.h>
33 #include <linux/list.h>
34 #include <linux/workqueue.h>
35 #include <asm/unaligned.h>
36 #include <scsi/scsi.h>
37 #include <scsi/scsi_host.h>
38 #include <scsi/scsi_tcq.h>
39 #include <target/target_core_base.h>
40 #include <target/target_core_fabric.h>
43 #include "qla_target.h"
45 static int ql2xtgt_tape_enable
;
46 module_param(ql2xtgt_tape_enable
, int, S_IRUGO
|S_IWUSR
);
47 MODULE_PARM_DESC(ql2xtgt_tape_enable
,
48 "Enables Sequence level error recovery (aka FC Tape). Default is 0 - no SLER. 1 - Enable SLER.");
50 static char *qlini_mode
= QLA2XXX_INI_MODE_STR_ENABLED
;
51 module_param(qlini_mode
, charp
, S_IRUGO
);
52 MODULE_PARM_DESC(qlini_mode
,
53 "Determines when initiator mode will be enabled. Possible values: "
54 "\"exclusive\" - initiator mode will be enabled on load, "
55 "disabled on enabling target mode and then on disabling target mode "
57 "\"disabled\" - initiator mode will never be enabled; "
58 "\"enabled\" (default) - initiator mode will always stay enabled.");
60 int ql2x_ini_mode
= QLA2XXX_INI_MODE_EXCLUSIVE
;
62 static int temp_sam_status
= SAM_STAT_BUSY
;
65 * From scsi/fc/fc_fcp.h
67 enum fcp_resp_rsp_codes
{
69 FCP_DATA_LEN_INVALID
= 1,
70 FCP_CMND_FIELDS_INVALID
= 2,
71 FCP_DATA_PARAM_MISMATCH
= 3,
74 FCP_TMF_INVALID_LUN
= 9,
78 * fc_pri_ta from scsi/fc/fc_fcp.h
80 #define FCP_PTA_SIMPLE 0 /* simple task attribute */
81 #define FCP_PTA_HEADQ 1 /* head of queue task attribute */
82 #define FCP_PTA_ORDERED 2 /* ordered task attribute */
83 #define FCP_PTA_ACA 4 /* auto. contingent allegiance */
84 #define FCP_PTA_MASK 7 /* mask for task attribute field */
85 #define FCP_PRI_SHIFT 3 /* priority field starts in bit 3 */
86 #define FCP_PRI_RESVD_MASK 0x80 /* reserved bits in priority field */
89 * This driver calls qla2x00_alloc_iocbs() and qla2x00_issue_marker(), which
90 * must be called under HW lock and could unlock/lock it inside.
91 * It isn't an issue, since in the current implementation on the time when
92 * those functions are called:
94 * - Either context is IRQ and only IRQ handler can modify HW data,
95 * including rings related fields,
97 * - Or access to target mode variables from struct qla_tgt doesn't
98 * cross those functions boundaries, except tgt_stop, which
99 * additionally protected by irq_cmd_count.
101 /* Predefs for callbacks handed to qla2xxx LLD */
102 static void qlt_24xx_atio_pkt(struct scsi_qla_host
*ha
,
103 struct atio_from_isp
*pkt
);
104 static void qlt_response_pkt(struct scsi_qla_host
*ha
, response_t
*pkt
);
105 static int qlt_issue_task_mgmt(struct qla_tgt_sess
*sess
, uint32_t lun
,
106 int fn
, void *iocb
, int flags
);
107 static void qlt_send_term_exchange(struct scsi_qla_host
*ha
, struct qla_tgt_cmd
108 *cmd
, struct atio_from_isp
*atio
, int ha_locked
);
109 static void qlt_reject_free_srr_imm(struct scsi_qla_host
*ha
,
110 struct qla_tgt_srr_imm
*imm
, int ha_lock
);
111 static void qlt_abort_cmd_on_host_reset(struct scsi_qla_host
*vha
,
112 struct qla_tgt_cmd
*cmd
);
113 static void qlt_alloc_qfull_cmd(struct scsi_qla_host
*vha
,
114 struct atio_from_isp
*atio
, uint16_t status
, int qfull
);
115 static void qlt_disable_vha(struct scsi_qla_host
*vha
);
116 static void qlt_clear_tgt_db(struct qla_tgt
*tgt
);
117 static void qlt_send_notify_ack(struct scsi_qla_host
*vha
,
118 struct imm_ntfy_from_isp
*ntfy
,
119 uint32_t add_flags
, uint16_t resp_code
, int resp_code_valid
,
120 uint16_t srr_flags
, uint16_t srr_reject_code
, uint8_t srr_explan
);
124 static struct kmem_cache
*qla_tgt_mgmt_cmd_cachep
;
125 static mempool_t
*qla_tgt_mgmt_cmd_mempool
;
126 static struct workqueue_struct
*qla_tgt_wq
;
127 static DEFINE_MUTEX(qla_tgt_mutex
);
128 static LIST_HEAD(qla_tgt_glist
);
130 /* This API intentionally takes dest as a parameter, rather than returning
131 * int value to avoid caller forgetting to issue wmb() after the store */
132 void qlt_do_generation_tick(struct scsi_qla_host
*vha
, int *dest
)
134 scsi_qla_host_t
*base_vha
= pci_get_drvdata(vha
->hw
->pdev
);
135 *dest
= atomic_inc_return(&base_vha
->generation_tick
);
140 /* ha->hardware_lock supposed to be held on entry (to protect tgt->sess_list) */
141 static struct qla_tgt_sess
*qlt_find_sess_by_port_name(
143 const uint8_t *port_name
)
145 struct qla_tgt_sess
*sess
;
147 list_for_each_entry(sess
, &tgt
->sess_list
, sess_list_entry
) {
148 if (!memcmp(sess
->port_name
, port_name
, WWN_SIZE
))
155 /* Might release hw lock, then reaquire!! */
156 static inline int qlt_issue_marker(struct scsi_qla_host
*vha
, int vha_locked
)
158 /* Send marker if required */
159 if (unlikely(vha
->marker_needed
!= 0)) {
160 int rc
= qla2x00_issue_marker(vha
, vha_locked
);
161 if (rc
!= QLA_SUCCESS
) {
162 ql_dbg(ql_dbg_tgt
, vha
, 0xe03d,
163 "qla_target(%d): issue_marker() failed\n",
172 struct scsi_qla_host
*qlt_find_host_by_d_id(struct scsi_qla_host
*vha
,
175 struct qla_hw_data
*ha
= vha
->hw
;
178 if ((vha
->d_id
.b
.area
!= d_id
[1]) || (vha
->d_id
.b
.domain
!= d_id
[0]))
181 if (vha
->d_id
.b
.al_pa
== d_id
[2])
184 BUG_ON(ha
->tgt
.tgt_vp_map
== NULL
);
185 vp_idx
= ha
->tgt
.tgt_vp_map
[d_id
[2]].idx
;
186 if (likely(test_bit(vp_idx
, ha
->vp_idx_map
)))
187 return ha
->tgt
.tgt_vp_map
[vp_idx
].vha
;
193 struct scsi_qla_host
*qlt_find_host_by_vp_idx(struct scsi_qla_host
*vha
,
196 struct qla_hw_data
*ha
= vha
->hw
;
198 if (vha
->vp_idx
== vp_idx
)
201 BUG_ON(ha
->tgt
.tgt_vp_map
== NULL
);
202 if (likely(test_bit(vp_idx
, ha
->vp_idx_map
)))
203 return ha
->tgt
.tgt_vp_map
[vp_idx
].vha
;
208 static inline void qlt_incr_num_pend_cmds(struct scsi_qla_host
*vha
)
212 spin_lock_irqsave(&vha
->hw
->tgt
.q_full_lock
, flags
);
214 vha
->hw
->tgt
.num_pend_cmds
++;
215 if (vha
->hw
->tgt
.num_pend_cmds
> vha
->hw
->qla_stats
.stat_max_pend_cmds
)
216 vha
->hw
->qla_stats
.stat_max_pend_cmds
=
217 vha
->hw
->tgt
.num_pend_cmds
;
218 spin_unlock_irqrestore(&vha
->hw
->tgt
.q_full_lock
, flags
);
220 static inline void qlt_decr_num_pend_cmds(struct scsi_qla_host
*vha
)
224 spin_lock_irqsave(&vha
->hw
->tgt
.q_full_lock
, flags
);
225 vha
->hw
->tgt
.num_pend_cmds
--;
226 spin_unlock_irqrestore(&vha
->hw
->tgt
.q_full_lock
, flags
);
229 static void qlt_24xx_atio_pkt_all_vps(struct scsi_qla_host
*vha
,
230 struct atio_from_isp
*atio
)
232 ql_dbg(ql_dbg_tgt
, vha
, 0xe072,
233 "%s: qla_target(%d): type %x ox_id %04x\n",
234 __func__
, vha
->vp_idx
, atio
->u
.raw
.entry_type
,
235 be16_to_cpu(atio
->u
.isp24
.fcp_hdr
.ox_id
));
237 switch (atio
->u
.raw
.entry_type
) {
240 struct scsi_qla_host
*host
= qlt_find_host_by_d_id(vha
,
241 atio
->u
.isp24
.fcp_hdr
.d_id
);
242 if (unlikely(NULL
== host
)) {
243 ql_dbg(ql_dbg_tgt
, vha
, 0xe03e,
244 "qla_target(%d): Received ATIO_TYPE7 "
245 "with unknown d_id %x:%x:%x\n", vha
->vp_idx
,
246 atio
->u
.isp24
.fcp_hdr
.d_id
[0],
247 atio
->u
.isp24
.fcp_hdr
.d_id
[1],
248 atio
->u
.isp24
.fcp_hdr
.d_id
[2]);
251 qlt_24xx_atio_pkt(host
, atio
);
255 case IMMED_NOTIFY_TYPE
:
257 struct scsi_qla_host
*host
= vha
;
258 struct imm_ntfy_from_isp
*entry
=
259 (struct imm_ntfy_from_isp
*)atio
;
261 if ((entry
->u
.isp24
.vp_index
!= 0xFF) &&
262 (entry
->u
.isp24
.nport_handle
!= 0xFFFF)) {
263 host
= qlt_find_host_by_vp_idx(vha
,
264 entry
->u
.isp24
.vp_index
);
265 if (unlikely(!host
)) {
266 ql_dbg(ql_dbg_tgt
, vha
, 0xe03f,
267 "qla_target(%d): Received "
268 "ATIO (IMMED_NOTIFY_TYPE) "
269 "with unknown vp_index %d\n",
270 vha
->vp_idx
, entry
->u
.isp24
.vp_index
);
274 qlt_24xx_atio_pkt(host
, atio
);
279 ql_dbg(ql_dbg_tgt
, vha
, 0xe040,
280 "qla_target(%d): Received unknown ATIO atio "
281 "type %x\n", vha
->vp_idx
, atio
->u
.raw
.entry_type
);
288 void qlt_response_pkt_all_vps(struct scsi_qla_host
*vha
, response_t
*pkt
)
290 switch (pkt
->entry_type
) {
292 ql_dbg(ql_dbg_tgt
, vha
, 0xe073,
293 "qla_target(%d):%s: CRC2 Response pkt\n",
294 vha
->vp_idx
, __func__
);
297 struct ctio7_from_24xx
*entry
= (struct ctio7_from_24xx
*)pkt
;
298 struct scsi_qla_host
*host
= qlt_find_host_by_vp_idx(vha
,
300 if (unlikely(!host
)) {
301 ql_dbg(ql_dbg_tgt
, vha
, 0xe041,
302 "qla_target(%d): Response pkt (CTIO_TYPE7) "
303 "received, with unknown vp_index %d\n",
304 vha
->vp_idx
, entry
->vp_index
);
307 qlt_response_pkt(host
, pkt
);
311 case IMMED_NOTIFY_TYPE
:
313 struct scsi_qla_host
*host
= vha
;
314 struct imm_ntfy_from_isp
*entry
=
315 (struct imm_ntfy_from_isp
*)pkt
;
317 host
= qlt_find_host_by_vp_idx(vha
, entry
->u
.isp24
.vp_index
);
318 if (unlikely(!host
)) {
319 ql_dbg(ql_dbg_tgt
, vha
, 0xe042,
320 "qla_target(%d): Response pkt (IMMED_NOTIFY_TYPE) "
321 "received, with unknown vp_index %d\n",
322 vha
->vp_idx
, entry
->u
.isp24
.vp_index
);
325 qlt_response_pkt(host
, pkt
);
329 case NOTIFY_ACK_TYPE
:
331 struct scsi_qla_host
*host
= vha
;
332 struct nack_to_isp
*entry
= (struct nack_to_isp
*)pkt
;
334 if (0xFF != entry
->u
.isp24
.vp_index
) {
335 host
= qlt_find_host_by_vp_idx(vha
,
336 entry
->u
.isp24
.vp_index
);
337 if (unlikely(!host
)) {
338 ql_dbg(ql_dbg_tgt
, vha
, 0xe043,
339 "qla_target(%d): Response "
340 "pkt (NOTIFY_ACK_TYPE) "
341 "received, with unknown "
342 "vp_index %d\n", vha
->vp_idx
,
343 entry
->u
.isp24
.vp_index
);
347 qlt_response_pkt(host
, pkt
);
353 struct abts_recv_from_24xx
*entry
=
354 (struct abts_recv_from_24xx
*)pkt
;
355 struct scsi_qla_host
*host
= qlt_find_host_by_vp_idx(vha
,
357 if (unlikely(!host
)) {
358 ql_dbg(ql_dbg_tgt
, vha
, 0xe044,
359 "qla_target(%d): Response pkt "
360 "(ABTS_RECV_24XX) received, with unknown "
361 "vp_index %d\n", vha
->vp_idx
, entry
->vp_index
);
364 qlt_response_pkt(host
, pkt
);
370 struct abts_resp_to_24xx
*entry
=
371 (struct abts_resp_to_24xx
*)pkt
;
372 struct scsi_qla_host
*host
= qlt_find_host_by_vp_idx(vha
,
374 if (unlikely(!host
)) {
375 ql_dbg(ql_dbg_tgt
, vha
, 0xe045,
376 "qla_target(%d): Response pkt "
377 "(ABTS_RECV_24XX) received, with unknown "
378 "vp_index %d\n", vha
->vp_idx
, entry
->vp_index
);
381 qlt_response_pkt(host
, pkt
);
386 qlt_response_pkt(vha
, pkt
);
392 static void qlt_free_session_done(struct work_struct
*work
)
394 struct qla_tgt_sess
*sess
= container_of(work
, struct qla_tgt_sess
,
396 struct qla_tgt
*tgt
= sess
->tgt
;
397 struct scsi_qla_host
*vha
= sess
->vha
;
398 struct qla_hw_data
*ha
= vha
->hw
;
400 bool logout_started
= false;
403 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf084,
404 "%s: se_sess %p / sess %p from port %8phC loop_id %#04x"
405 " s_id %02x:%02x:%02x logout %d keep %d plogi %d\n",
406 __func__
, sess
->se_sess
, sess
, sess
->port_name
, sess
->loop_id
,
407 sess
->s_id
.b
.domain
, sess
->s_id
.b
.area
, sess
->s_id
.b
.al_pa
,
408 sess
->logout_on_delete
, sess
->keep_nport_handle
,
409 sess
->plogi_ack_needed
);
413 if (sess
->logout_on_delete
) {
416 memset(&fcport
, 0, sizeof(fcport
));
417 fcport
.loop_id
= sess
->loop_id
;
418 fcport
.d_id
= sess
->s_id
;
419 memcpy(fcport
.port_name
, sess
->port_name
, WWN_SIZE
);
421 fcport
.tgt_session
= sess
;
423 rc
= qla2x00_post_async_logout_work(vha
, &fcport
, NULL
);
424 if (rc
!= QLA_SUCCESS
)
425 ql_log(ql_log_warn
, vha
, 0xf085,
426 "Schedule logo failed sess %p rc %d\n",
429 logout_started
= true;
433 * Release the target session for FC Nexus from fabric module code.
435 if (sess
->se_sess
!= NULL
)
436 ha
->tgt
.tgt_ops
->free_session(sess
);
438 if (logout_started
) {
441 while (!ACCESS_ONCE(sess
->logout_completed
)) {
443 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf086,
444 "%s: waiting for sess %p logout\n",
451 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf087,
452 "%s: sess %p logout completed\n",
456 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
458 if (sess
->plogi_ack_needed
)
459 qlt_send_notify_ack(vha
, &sess
->tm_iocb
,
462 list_del(&sess
->sess_list_entry
);
464 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
466 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf001,
467 "Unregistration of sess %p finished\n", sess
);
471 * We need to protect against race, when tgt is freed before or
475 if (tgt
->sess_count
== 0)
476 wake_up_all(&tgt
->waitQ
);
479 /* ha->hardware_lock supposed to be held on entry */
480 void qlt_unreg_sess(struct qla_tgt_sess
*sess
)
482 struct scsi_qla_host
*vha
= sess
->vha
;
484 vha
->hw
->tgt
.tgt_ops
->clear_nacl_from_fcport_map(sess
);
486 if (!list_empty(&sess
->del_list_entry
))
487 list_del_init(&sess
->del_list_entry
);
488 sess
->deleted
= QLA_SESS_DELETION_IN_PROGRESS
;
490 INIT_WORK(&sess
->free_work
, qlt_free_session_done
);
491 schedule_work(&sess
->free_work
);
493 EXPORT_SYMBOL(qlt_unreg_sess
);
495 /* ha->hardware_lock supposed to be held on entry */
496 static int qlt_reset(struct scsi_qla_host
*vha
, void *iocb
, int mcmd
)
498 struct qla_hw_data
*ha
= vha
->hw
;
499 struct qla_tgt_sess
*sess
= NULL
;
500 uint32_t unpacked_lun
, lun
= 0;
503 struct imm_ntfy_from_isp
*n
= (struct imm_ntfy_from_isp
*)iocb
;
504 struct atio_from_isp
*a
= (struct atio_from_isp
*)iocb
;
506 loop_id
= le16_to_cpu(n
->u
.isp24
.nport_handle
);
507 if (loop_id
== 0xFFFF) {
509 atomic_inc(&vha
->vha_tgt
.qla_tgt
->tgt_global_resets_count
);
510 qlt_clear_tgt_db(vha
->vha_tgt
.qla_tgt
);
511 #if 0 /* FIXME: do we need to choose a session here? */
512 if (!list_empty(&ha
->tgt
.qla_tgt
->sess_list
)) {
513 sess
= list_entry(ha
->tgt
.qla_tgt
->sess_list
.next
,
514 typeof(*sess
), sess_list_entry
);
516 case QLA_TGT_NEXUS_LOSS_SESS
:
517 mcmd
= QLA_TGT_NEXUS_LOSS
;
519 case QLA_TGT_ABORT_ALL_SESS
:
520 mcmd
= QLA_TGT_ABORT_ALL
;
522 case QLA_TGT_NEXUS_LOSS
:
523 case QLA_TGT_ABORT_ALL
:
526 ql_dbg(ql_dbg_tgt
, vha
, 0xe046,
527 "qla_target(%d): Not allowed "
528 "command %x in %s", vha
->vp_idx
,
537 sess
= ha
->tgt
.tgt_ops
->find_sess_by_loop_id(vha
, loop_id
);
540 ql_dbg(ql_dbg_tgt
, vha
, 0xe000,
541 "Using sess for qla_tgt_reset: %p\n", sess
);
547 ql_dbg(ql_dbg_tgt
, vha
, 0xe047,
548 "scsi(%ld): resetting (session %p from port %8phC mcmd %x, "
549 "loop_id %d)\n", vha
->host_no
, sess
, sess
->port_name
,
552 lun
= a
->u
.isp24
.fcp_cmnd
.lun
;
553 unpacked_lun
= scsilun_to_int((struct scsi_lun
*)&lun
);
555 return qlt_issue_task_mgmt(sess
, unpacked_lun
, mcmd
,
556 iocb
, QLA24XX_MGMT_SEND_NACK
);
559 /* ha->hardware_lock supposed to be held on entry */
560 static void qlt_schedule_sess_for_deletion(struct qla_tgt_sess
*sess
,
563 struct qla_tgt
*tgt
= sess
->tgt
;
564 uint32_t dev_loss_tmo
= tgt
->ha
->port_down_retry_count
+ 5;
567 /* Upgrade to unconditional deletion in case it was temporary */
568 if (immediate
&& sess
->deleted
== QLA_SESS_DELETION_PENDING
)
569 list_del(&sess
->del_list_entry
);
574 ql_dbg(ql_dbg_tgt
, sess
->vha
, 0xe001,
575 "Scheduling sess %p for deletion\n", sess
);
579 sess
->deleted
= QLA_SESS_DELETION_IN_PROGRESS
;
580 list_add(&sess
->del_list_entry
, &tgt
->del_sess_list
);
582 sess
->deleted
= QLA_SESS_DELETION_PENDING
;
583 list_add_tail(&sess
->del_list_entry
, &tgt
->del_sess_list
);
586 sess
->expires
= jiffies
+ dev_loss_tmo
* HZ
;
588 ql_dbg(ql_dbg_tgt
, sess
->vha
, 0xe048,
589 "qla_target(%d): session for port %8phC (loop ID %d s_id %02x:%02x:%02x)"
590 " scheduled for deletion in %u secs (expires: %lu) immed: %d, logout: %d, gen: %#x\n",
591 sess
->vha
->vp_idx
, sess
->port_name
, sess
->loop_id
,
592 sess
->s_id
.b
.domain
, sess
->s_id
.b
.area
, sess
->s_id
.b
.al_pa
,
593 dev_loss_tmo
, sess
->expires
, immediate
, sess
->logout_on_delete
,
597 mod_delayed_work(system_wq
, &tgt
->sess_del_work
, 0);
599 schedule_delayed_work(&tgt
->sess_del_work
,
600 sess
->expires
- jiffies
);
603 /* ha->hardware_lock supposed to be held on entry */
604 static void qlt_clear_tgt_db(struct qla_tgt
*tgt
)
606 struct qla_tgt_sess
*sess
;
608 list_for_each_entry(sess
, &tgt
->sess_list
, sess_list_entry
)
609 qlt_schedule_sess_for_deletion(sess
, true);
611 /* At this point tgt could be already dead */
614 static int qla24xx_get_loop_id(struct scsi_qla_host
*vha
, const uint8_t *s_id
,
617 struct qla_hw_data
*ha
= vha
->hw
;
618 dma_addr_t gid_list_dma
;
619 struct gid_list_info
*gid_list
;
624 gid_list
= dma_alloc_coherent(&ha
->pdev
->dev
, qla2x00_gid_list_size(ha
),
625 &gid_list_dma
, GFP_KERNEL
);
627 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf044,
628 "qla_target(%d): DMA Alloc failed of %u\n",
629 vha
->vp_idx
, qla2x00_gid_list_size(ha
));
633 /* Get list of logged in devices */
634 rc
= qla2x00_get_id_list(vha
, gid_list
, gid_list_dma
, &entries
);
635 if (rc
!= QLA_SUCCESS
) {
636 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf045,
637 "qla_target(%d): get_id_list() failed: %x\n",
640 goto out_free_id_list
;
643 id_iter
= (char *)gid_list
;
645 for (i
= 0; i
< entries
; i
++) {
646 struct gid_list_info
*gid
= (struct gid_list_info
*)id_iter
;
647 if ((gid
->al_pa
== s_id
[2]) &&
648 (gid
->area
== s_id
[1]) &&
649 (gid
->domain
== s_id
[0])) {
650 *loop_id
= le16_to_cpu(gid
->loop_id
);
654 id_iter
+= ha
->gid_list_info_size
;
658 dma_free_coherent(&ha
->pdev
->dev
, qla2x00_gid_list_size(ha
),
659 gid_list
, gid_list_dma
);
663 /* ha->hardware_lock supposed to be held on entry */
664 static void qlt_undelete_sess(struct qla_tgt_sess
*sess
)
666 BUG_ON(sess
->deleted
!= QLA_SESS_DELETION_PENDING
);
668 list_del_init(&sess
->del_list_entry
);
672 static void qlt_del_sess_work_fn(struct delayed_work
*work
)
674 struct qla_tgt
*tgt
= container_of(work
, struct qla_tgt
,
676 struct scsi_qla_host
*vha
= tgt
->vha
;
677 struct qla_hw_data
*ha
= vha
->hw
;
678 struct qla_tgt_sess
*sess
;
679 unsigned long flags
, elapsed
;
681 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
682 while (!list_empty(&tgt
->del_sess_list
)) {
683 sess
= list_entry(tgt
->del_sess_list
.next
, typeof(*sess
),
686 if (time_after_eq(elapsed
, sess
->expires
)) {
687 /* No turning back */
688 list_del_init(&sess
->del_list_entry
);
689 sess
->deleted
= QLA_SESS_DELETION_IN_PROGRESS
;
691 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf004,
692 "Timeout: sess %p about to be deleted\n",
694 ha
->tgt
.tgt_ops
->shutdown_sess(sess
);
695 ha
->tgt
.tgt_ops
->put_sess(sess
);
697 schedule_delayed_work(&tgt
->sess_del_work
,
698 sess
->expires
- elapsed
);
702 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
706 * Adds an extra ref to allow to drop hw lock after adding sess to the list.
707 * Caller must put it.
709 static struct qla_tgt_sess
*qlt_create_sess(
710 struct scsi_qla_host
*vha
,
714 struct qla_hw_data
*ha
= vha
->hw
;
715 struct qla_tgt_sess
*sess
;
717 unsigned char be_sid
[3];
719 /* Check to avoid double sessions */
720 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
721 list_for_each_entry(sess
, &vha
->vha_tgt
.qla_tgt
->sess_list
,
723 if (!memcmp(sess
->port_name
, fcport
->port_name
, WWN_SIZE
)) {
724 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf005,
725 "Double sess %p found (s_id %x:%x:%x, "
726 "loop_id %d), updating to d_id %x:%x:%x, "
727 "loop_id %d", sess
, sess
->s_id
.b
.domain
,
728 sess
->s_id
.b
.al_pa
, sess
->s_id
.b
.area
,
729 sess
->loop_id
, fcport
->d_id
.b
.domain
,
730 fcport
->d_id
.b
.al_pa
, fcport
->d_id
.b
.area
,
733 /* Cannot undelete at this point */
734 if (sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
) {
735 spin_unlock_irqrestore(&ha
->hardware_lock
,
741 qlt_undelete_sess(sess
);
743 kref_get(&sess
->se_sess
->sess_kref
);
744 ha
->tgt
.tgt_ops
->update_sess(sess
, fcport
->d_id
, fcport
->loop_id
,
745 (fcport
->flags
& FCF_CONF_COMP_SUPPORTED
));
747 if (sess
->local
&& !local
)
750 qlt_do_generation_tick(vha
, &sess
->generation
);
752 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
757 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
759 sess
= kzalloc(sizeof(*sess
), GFP_KERNEL
);
761 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf04a,
762 "qla_target(%u): session allocation failed, all commands "
763 "from port %8phC will be refused", vha
->vp_idx
,
768 sess
->tgt
= vha
->vha_tgt
.qla_tgt
;
770 sess
->s_id
= fcport
->d_id
;
771 sess
->loop_id
= fcport
->loop_id
;
773 INIT_LIST_HEAD(&sess
->del_list_entry
);
775 /* Under normal circumstances we want to logout from firmware when
776 * session eventually ends and release corresponding nport handle.
777 * In the exception cases (e.g. when new PLOGI is waiting) corresponding
778 * code will adjust these flags as necessary. */
779 sess
->logout_on_delete
= 1;
780 sess
->keep_nport_handle
= 0;
782 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf006,
783 "Adding sess %p to tgt %p via ->check_initiator_node_acl()\n",
784 sess
, vha
->vha_tgt
.qla_tgt
);
786 be_sid
[0] = sess
->s_id
.b
.domain
;
787 be_sid
[1] = sess
->s_id
.b
.area
;
788 be_sid
[2] = sess
->s_id
.b
.al_pa
;
790 * Determine if this fc_port->port_name is allowed to access
791 * target mode using explict NodeACLs+MappedLUNs, or using
792 * TPG demo mode. If this is successful a target mode FC nexus
795 if (ha
->tgt
.tgt_ops
->check_initiator_node_acl(vha
,
796 &fcport
->port_name
[0], sess
, &be_sid
[0], fcport
->loop_id
) < 0) {
801 * Take an extra reference to ->sess_kref here to handle qla_tgt_sess
802 * access across ->hardware_lock reaquire.
804 kref_get(&sess
->se_sess
->sess_kref
);
806 sess
->conf_compl_supported
= (fcport
->flags
& FCF_CONF_COMP_SUPPORTED
);
807 BUILD_BUG_ON(sizeof(sess
->port_name
) != sizeof(fcport
->port_name
));
808 memcpy(sess
->port_name
, fcport
->port_name
, sizeof(sess
->port_name
));
810 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
811 list_add_tail(&sess
->sess_list_entry
, &vha
->vha_tgt
.qla_tgt
->sess_list
);
812 vha
->vha_tgt
.qla_tgt
->sess_count
++;
813 qlt_do_generation_tick(vha
, &sess
->generation
);
814 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
816 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf04b,
817 "qla_target(%d): %ssession for wwn %8phC (loop_id %d, "
818 "s_id %x:%x:%x, confirmed completion %ssupported) added\n",
819 vha
->vp_idx
, local
? "local " : "", fcport
->port_name
,
820 fcport
->loop_id
, sess
->s_id
.b
.domain
, sess
->s_id
.b
.area
,
821 sess
->s_id
.b
.al_pa
, sess
->conf_compl_supported
? "" : "not ");
827 * Called from qla2x00_reg_remote_port()
829 void qlt_fc_port_added(struct scsi_qla_host
*vha
, fc_port_t
*fcport
)
831 struct qla_hw_data
*ha
= vha
->hw
;
832 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
833 struct qla_tgt_sess
*sess
;
836 if (!vha
->hw
->tgt
.tgt_ops
)
839 if (!tgt
|| (fcport
->port_type
!= FCT_INITIATOR
))
842 if (qla_ini_mode_enabled(vha
))
845 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
847 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
850 sess
= qlt_find_sess_by_port_name(tgt
, fcport
->port_name
);
852 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
854 mutex_lock(&vha
->vha_tgt
.tgt_mutex
);
855 sess
= qlt_create_sess(vha
, fcport
, false);
856 mutex_unlock(&vha
->vha_tgt
.tgt_mutex
);
858 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
859 } else if (sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
) {
860 /* Point of no return */
861 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
864 kref_get(&sess
->se_sess
->sess_kref
);
867 qlt_undelete_sess(sess
);
869 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf04c,
870 "qla_target(%u): %ssession for port %8phC "
871 "(loop ID %d) reappeared\n", vha
->vp_idx
,
872 sess
->local
? "local " : "", sess
->port_name
,
875 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf007,
876 "Reappeared sess %p\n", sess
);
878 ha
->tgt
.tgt_ops
->update_sess(sess
, fcport
->d_id
, fcport
->loop_id
,
879 (fcport
->flags
& FCF_CONF_COMP_SUPPORTED
));
882 if (sess
&& sess
->local
) {
883 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf04d,
884 "qla_target(%u): local session for "
885 "port %8phC (loop ID %d) became global\n", vha
->vp_idx
,
886 fcport
->port_name
, sess
->loop_id
);
889 ha
->tgt
.tgt_ops
->put_sess(sess
);
890 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
894 * max_gen - specifies maximum session generation
895 * at which this deletion requestion is still valid
898 qlt_fc_port_deleted(struct scsi_qla_host
*vha
, fc_port_t
*fcport
, int max_gen
)
900 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
901 struct qla_tgt_sess
*sess
;
903 if (!vha
->hw
->tgt
.tgt_ops
)
912 sess
= qlt_find_sess_by_port_name(tgt
, fcport
->port_name
);
917 if (max_gen
- sess
->generation
< 0) {
918 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf092,
919 "Ignoring stale deletion request for se_sess %p / sess %p"
920 " for port %8phC, req_gen %d, sess_gen %d\n",
921 sess
->se_sess
, sess
, sess
->port_name
, max_gen
,
926 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf008, "qla_tgt_fc_port_deleted %p", sess
);
929 qlt_schedule_sess_for_deletion(sess
, false);
932 static inline int test_tgt_sess_count(struct qla_tgt
*tgt
)
934 struct qla_hw_data
*ha
= tgt
->ha
;
938 * We need to protect against race, when tgt is freed before or
941 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
942 ql_dbg(ql_dbg_tgt
, tgt
->vha
, 0xe002,
943 "tgt %p, empty(sess_list)=%d sess_count=%d\n",
944 tgt
, list_empty(&tgt
->sess_list
), tgt
->sess_count
);
945 res
= (tgt
->sess_count
== 0);
946 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
951 /* Called by tcm_qla2xxx configfs code */
952 int qlt_stop_phase1(struct qla_tgt
*tgt
)
954 struct scsi_qla_host
*vha
= tgt
->vha
;
955 struct qla_hw_data
*ha
= tgt
->ha
;
958 mutex_lock(&qla_tgt_mutex
);
959 if (!vha
->fc_vport
) {
960 struct Scsi_Host
*sh
= vha
->host
;
961 struct fc_host_attrs
*fc_host
= shost_to_fc_host(sh
);
964 spin_lock_irqsave(sh
->host_lock
, flags
);
965 npiv_vports
= (fc_host
->npiv_vports_inuse
);
966 spin_unlock_irqrestore(sh
->host_lock
, flags
);
969 mutex_unlock(&qla_tgt_mutex
);
973 if (tgt
->tgt_stop
|| tgt
->tgt_stopped
) {
974 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf04e,
975 "Already in tgt->tgt_stop or tgt_stopped state\n");
976 mutex_unlock(&qla_tgt_mutex
);
980 ql_dbg(ql_dbg_tgt
, vha
, 0xe003, "Stopping target for host %ld(%p)\n",
983 * Mutex needed to sync with qla_tgt_fc_port_[added,deleted].
984 * Lock is needed, because we still can get an incoming packet.
986 mutex_lock(&vha
->vha_tgt
.tgt_mutex
);
987 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
989 qlt_clear_tgt_db(tgt
);
990 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
991 mutex_unlock(&vha
->vha_tgt
.tgt_mutex
);
992 mutex_unlock(&qla_tgt_mutex
);
994 flush_delayed_work(&tgt
->sess_del_work
);
996 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf009,
997 "Waiting for sess works (tgt %p)", tgt
);
998 spin_lock_irqsave(&tgt
->sess_work_lock
, flags
);
999 while (!list_empty(&tgt
->sess_works_list
)) {
1000 spin_unlock_irqrestore(&tgt
->sess_work_lock
, flags
);
1001 flush_scheduled_work();
1002 spin_lock_irqsave(&tgt
->sess_work_lock
, flags
);
1004 spin_unlock_irqrestore(&tgt
->sess_work_lock
, flags
);
1006 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf00a,
1007 "Waiting for tgt %p: list_empty(sess_list)=%d "
1008 "sess_count=%d\n", tgt
, list_empty(&tgt
->sess_list
),
1011 wait_event(tgt
->waitQ
, test_tgt_sess_count(tgt
));
1014 if (!ha
->flags
.host_shutting_down
&& qla_tgt_mode_enabled(vha
))
1015 qlt_disable_vha(vha
);
1017 /* Wait for sessions to clear out (just in case) */
1018 wait_event(tgt
->waitQ
, test_tgt_sess_count(tgt
));
1021 EXPORT_SYMBOL(qlt_stop_phase1
);
1023 /* Called by tcm_qla2xxx configfs code */
1024 void qlt_stop_phase2(struct qla_tgt
*tgt
)
1026 struct qla_hw_data
*ha
= tgt
->ha
;
1027 scsi_qla_host_t
*vha
= pci_get_drvdata(ha
->pdev
);
1028 unsigned long flags
;
1030 if (tgt
->tgt_stopped
) {
1031 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf04f,
1032 "Already in tgt->tgt_stopped state\n");
1037 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf00b,
1038 "Waiting for %d IRQ commands to complete (tgt %p)",
1039 tgt
->irq_cmd_count
, tgt
);
1041 mutex_lock(&vha
->vha_tgt
.tgt_mutex
);
1042 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1043 while (tgt
->irq_cmd_count
!= 0) {
1044 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1046 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1049 tgt
->tgt_stopped
= 1;
1050 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1051 mutex_unlock(&vha
->vha_tgt
.tgt_mutex
);
1053 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf00c, "Stop of tgt %p finished",
1056 EXPORT_SYMBOL(qlt_stop_phase2
);
1058 /* Called from qlt_remove_target() -> qla2x00_remove_one() */
1059 static void qlt_release(struct qla_tgt
*tgt
)
1061 scsi_qla_host_t
*vha
= tgt
->vha
;
1063 if ((vha
->vha_tgt
.qla_tgt
!= NULL
) && !tgt
->tgt_stopped
)
1064 qlt_stop_phase2(tgt
);
1066 vha
->vha_tgt
.qla_tgt
= NULL
;
1068 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf00d,
1069 "Release of tgt %p finished\n", tgt
);
1074 /* ha->hardware_lock supposed to be held on entry */
1075 static int qlt_sched_sess_work(struct qla_tgt
*tgt
, int type
,
1076 const void *param
, unsigned int param_size
)
1078 struct qla_tgt_sess_work_param
*prm
;
1079 unsigned long flags
;
1081 prm
= kzalloc(sizeof(*prm
), GFP_ATOMIC
);
1083 ql_dbg(ql_dbg_tgt_mgt
, tgt
->vha
, 0xf050,
1084 "qla_target(%d): Unable to create session "
1085 "work, command will be refused", 0);
1089 ql_dbg(ql_dbg_tgt_mgt
, tgt
->vha
, 0xf00e,
1090 "Scheduling work (type %d, prm %p)"
1091 " to find session for param %p (size %d, tgt %p)\n",
1092 type
, prm
, param
, param_size
, tgt
);
1095 memcpy(&prm
->tm_iocb
, param
, param_size
);
1097 spin_lock_irqsave(&tgt
->sess_work_lock
, flags
);
1098 list_add_tail(&prm
->sess_works_list_entry
, &tgt
->sess_works_list
);
1099 spin_unlock_irqrestore(&tgt
->sess_work_lock
, flags
);
1101 schedule_work(&tgt
->sess_work
);
1107 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1109 static void qlt_send_notify_ack(struct scsi_qla_host
*vha
,
1110 struct imm_ntfy_from_isp
*ntfy
,
1111 uint32_t add_flags
, uint16_t resp_code
, int resp_code_valid
,
1112 uint16_t srr_flags
, uint16_t srr_reject_code
, uint8_t srr_explan
)
1114 struct qla_hw_data
*ha
= vha
->hw
;
1116 struct nack_to_isp
*nack
;
1118 ql_dbg(ql_dbg_tgt
, vha
, 0xe004, "Sending NOTIFY_ACK (ha=%p)\n", ha
);
1120 /* Send marker if required */
1121 if (qlt_issue_marker(vha
, 1) != QLA_SUCCESS
)
1124 pkt
= (request_t
*)qla2x00_alloc_iocbs(vha
, NULL
);
1126 ql_dbg(ql_dbg_tgt
, vha
, 0xe049,
1127 "qla_target(%d): %s failed: unable to allocate "
1128 "request packet\n", vha
->vp_idx
, __func__
);
1132 if (vha
->vha_tgt
.qla_tgt
!= NULL
)
1133 vha
->vha_tgt
.qla_tgt
->notify_ack_expected
++;
1135 pkt
->entry_type
= NOTIFY_ACK_TYPE
;
1136 pkt
->entry_count
= 1;
1138 nack
= (struct nack_to_isp
*)pkt
;
1139 nack
->ox_id
= ntfy
->ox_id
;
1141 nack
->u
.isp24
.nport_handle
= ntfy
->u
.isp24
.nport_handle
;
1142 if (le16_to_cpu(ntfy
->u
.isp24
.status
) == IMM_NTFY_ELS
) {
1143 nack
->u
.isp24
.flags
= ntfy
->u
.isp24
.flags
&
1144 __constant_cpu_to_le32(NOTIFY24XX_FLAGS_PUREX_IOCB
);
1146 nack
->u
.isp24
.srr_rx_id
= ntfy
->u
.isp24
.srr_rx_id
;
1147 nack
->u
.isp24
.status
= ntfy
->u
.isp24
.status
;
1148 nack
->u
.isp24
.status_subcode
= ntfy
->u
.isp24
.status_subcode
;
1149 nack
->u
.isp24
.fw_handle
= ntfy
->u
.isp24
.fw_handle
;
1150 nack
->u
.isp24
.exchange_address
= ntfy
->u
.isp24
.exchange_address
;
1151 nack
->u
.isp24
.srr_rel_offs
= ntfy
->u
.isp24
.srr_rel_offs
;
1152 nack
->u
.isp24
.srr_ui
= ntfy
->u
.isp24
.srr_ui
;
1153 nack
->u
.isp24
.srr_flags
= cpu_to_le16(srr_flags
);
1154 nack
->u
.isp24
.srr_reject_code
= srr_reject_code
;
1155 nack
->u
.isp24
.srr_reject_code_expl
= srr_explan
;
1156 nack
->u
.isp24
.vp_index
= ntfy
->u
.isp24
.vp_index
;
1158 ql_dbg(ql_dbg_tgt
, vha
, 0xe005,
1159 "qla_target(%d): Sending 24xx Notify Ack %d\n",
1160 vha
->vp_idx
, nack
->u
.isp24
.status
);
1162 /* Memory Barrier */
1164 qla2x00_start_iocbs(vha
, vha
->req
);
1168 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1170 static void qlt_24xx_send_abts_resp(struct scsi_qla_host
*vha
,
1171 struct abts_recv_from_24xx
*abts
, uint32_t status
,
1174 struct qla_hw_data
*ha
= vha
->hw
;
1175 struct abts_resp_to_24xx
*resp
;
1179 ql_dbg(ql_dbg_tgt
, vha
, 0xe006,
1180 "Sending task mgmt ABTS response (ha=%p, atio=%p, status=%x\n",
1183 /* Send marker if required */
1184 if (qlt_issue_marker(vha
, 1) != QLA_SUCCESS
)
1187 resp
= (struct abts_resp_to_24xx
*)qla2x00_alloc_iocbs_ready(vha
, NULL
);
1189 ql_dbg(ql_dbg_tgt
, vha
, 0xe04a,
1190 "qla_target(%d): %s failed: unable to allocate "
1191 "request packet", vha
->vp_idx
, __func__
);
1195 resp
->entry_type
= ABTS_RESP_24XX
;
1196 resp
->entry_count
= 1;
1197 resp
->nport_handle
= abts
->nport_handle
;
1198 resp
->vp_index
= vha
->vp_idx
;
1199 resp
->sof_type
= abts
->sof_type
;
1200 resp
->exchange_address
= abts
->exchange_address
;
1201 resp
->fcp_hdr_le
= abts
->fcp_hdr_le
;
1202 f_ctl
= __constant_cpu_to_le32(F_CTL_EXCH_CONTEXT_RESP
|
1203 F_CTL_LAST_SEQ
| F_CTL_END_SEQ
|
1204 F_CTL_SEQ_INITIATIVE
);
1205 p
= (uint8_t *)&f_ctl
;
1206 resp
->fcp_hdr_le
.f_ctl
[0] = *p
++;
1207 resp
->fcp_hdr_le
.f_ctl
[1] = *p
++;
1208 resp
->fcp_hdr_le
.f_ctl
[2] = *p
;
1210 resp
->fcp_hdr_le
.d_id
[0] = abts
->fcp_hdr_le
.d_id
[0];
1211 resp
->fcp_hdr_le
.d_id
[1] = abts
->fcp_hdr_le
.d_id
[1];
1212 resp
->fcp_hdr_le
.d_id
[2] = abts
->fcp_hdr_le
.d_id
[2];
1213 resp
->fcp_hdr_le
.s_id
[0] = abts
->fcp_hdr_le
.s_id
[0];
1214 resp
->fcp_hdr_le
.s_id
[1] = abts
->fcp_hdr_le
.s_id
[1];
1215 resp
->fcp_hdr_le
.s_id
[2] = abts
->fcp_hdr_le
.s_id
[2];
1217 resp
->fcp_hdr_le
.d_id
[0] = abts
->fcp_hdr_le
.s_id
[0];
1218 resp
->fcp_hdr_le
.d_id
[1] = abts
->fcp_hdr_le
.s_id
[1];
1219 resp
->fcp_hdr_le
.d_id
[2] = abts
->fcp_hdr_le
.s_id
[2];
1220 resp
->fcp_hdr_le
.s_id
[0] = abts
->fcp_hdr_le
.d_id
[0];
1221 resp
->fcp_hdr_le
.s_id
[1] = abts
->fcp_hdr_le
.d_id
[1];
1222 resp
->fcp_hdr_le
.s_id
[2] = abts
->fcp_hdr_le
.d_id
[2];
1224 resp
->exchange_addr_to_abort
= abts
->exchange_addr_to_abort
;
1225 if (status
== FCP_TMF_CMPL
) {
1226 resp
->fcp_hdr_le
.r_ctl
= R_CTL_BASIC_LINK_SERV
| R_CTL_B_ACC
;
1227 resp
->payload
.ba_acct
.seq_id_valid
= SEQ_ID_INVALID
;
1228 resp
->payload
.ba_acct
.low_seq_cnt
= 0x0000;
1229 resp
->payload
.ba_acct
.high_seq_cnt
= 0xFFFF;
1230 resp
->payload
.ba_acct
.ox_id
= abts
->fcp_hdr_le
.ox_id
;
1231 resp
->payload
.ba_acct
.rx_id
= abts
->fcp_hdr_le
.rx_id
;
1233 resp
->fcp_hdr_le
.r_ctl
= R_CTL_BASIC_LINK_SERV
| R_CTL_B_RJT
;
1234 resp
->payload
.ba_rjt
.reason_code
=
1235 BA_RJT_REASON_CODE_UNABLE_TO_PERFORM
;
1236 /* Other bytes are zero */
1239 vha
->vha_tgt
.qla_tgt
->abts_resp_expected
++;
1241 /* Memory Barrier */
1243 qla2x00_start_iocbs(vha
, vha
->req
);
1247 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1249 static void qlt_24xx_retry_term_exchange(struct scsi_qla_host
*vha
,
1250 struct abts_resp_from_24xx_fw
*entry
)
1252 struct ctio7_to_24xx
*ctio
;
1254 ql_dbg(ql_dbg_tgt
, vha
, 0xe007,
1255 "Sending retry TERM EXCH CTIO7 (ha=%p)\n", vha
->hw
);
1256 /* Send marker if required */
1257 if (qlt_issue_marker(vha
, 1) != QLA_SUCCESS
)
1260 ctio
= (struct ctio7_to_24xx
*)qla2x00_alloc_iocbs_ready(vha
, NULL
);
1262 ql_dbg(ql_dbg_tgt
, vha
, 0xe04b,
1263 "qla_target(%d): %s failed: unable to allocate "
1264 "request packet\n", vha
->vp_idx
, __func__
);
1269 * We've got on entrance firmware's response on by us generated
1270 * ABTS response. So, in it ID fields are reversed.
1273 ctio
->entry_type
= CTIO_TYPE7
;
1274 ctio
->entry_count
= 1;
1275 ctio
->nport_handle
= entry
->nport_handle
;
1276 ctio
->handle
= QLA_TGT_SKIP_HANDLE
| CTIO_COMPLETION_HANDLE_MARK
;
1277 ctio
->timeout
= __constant_cpu_to_le16(QLA_TGT_TIMEOUT
);
1278 ctio
->vp_index
= vha
->vp_idx
;
1279 ctio
->initiator_id
[0] = entry
->fcp_hdr_le
.d_id
[0];
1280 ctio
->initiator_id
[1] = entry
->fcp_hdr_le
.d_id
[1];
1281 ctio
->initiator_id
[2] = entry
->fcp_hdr_le
.d_id
[2];
1282 ctio
->exchange_addr
= entry
->exchange_addr_to_abort
;
1283 ctio
->u
.status1
.flags
=
1284 __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1
|
1285 CTIO7_FLAGS_TERMINATE
);
1286 ctio
->u
.status1
.ox_id
= cpu_to_le16(entry
->fcp_hdr_le
.ox_id
);
1288 /* Memory Barrier */
1290 qla2x00_start_iocbs(vha
, vha
->req
);
1292 qlt_24xx_send_abts_resp(vha
, (struct abts_recv_from_24xx
*)entry
,
1293 FCP_TMF_CMPL
, true);
1296 static int abort_cmd_for_tag(struct scsi_qla_host
*vha
, uint32_t tag
)
1298 struct qla_tgt_sess_op
*op
;
1299 struct qla_tgt_cmd
*cmd
;
1301 spin_lock(&vha
->cmd_list_lock
);
1303 list_for_each_entry(op
, &vha
->qla_sess_op_cmd_list
, cmd_list
) {
1304 if (tag
== op
->atio
.u
.isp24
.exchange_addr
) {
1306 spin_unlock(&vha
->cmd_list_lock
);
1311 list_for_each_entry(cmd
, &vha
->qla_cmd_list
, cmd_list
) {
1312 if (tag
== cmd
->atio
.u
.isp24
.exchange_addr
) {
1313 cmd
->state
= QLA_TGT_STATE_ABORTED
;
1314 spin_unlock(&vha
->cmd_list_lock
);
1319 spin_unlock(&vha
->cmd_list_lock
);
1323 /* drop cmds for the given lun
1324 * XXX only looks for cmds on the port through which lun reset was recieved
1325 * XXX does not go through the list of other port (which may have cmds
1328 static void abort_cmds_for_lun(struct scsi_qla_host
*vha
,
1329 uint32_t lun
, uint8_t *s_id
)
1331 struct qla_tgt_sess_op
*op
;
1332 struct qla_tgt_cmd
*cmd
;
1335 key
= sid_to_key(s_id
);
1336 spin_lock(&vha
->cmd_list_lock
);
1337 list_for_each_entry(op
, &vha
->qla_sess_op_cmd_list
, cmd_list
) {
1341 op_key
= sid_to_key(op
->atio
.u
.isp24
.fcp_hdr
.s_id
);
1342 op_lun
= scsilun_to_int(
1343 (struct scsi_lun
*)&op
->atio
.u
.isp24
.fcp_cmnd
.lun
);
1344 if (op_key
== key
&& op_lun
== lun
)
1347 list_for_each_entry(cmd
, &vha
->qla_cmd_list
, cmd_list
) {
1351 cmd_key
= sid_to_key(cmd
->atio
.u
.isp24
.fcp_hdr
.s_id
);
1352 cmd_lun
= scsilun_to_int(
1353 (struct scsi_lun
*)&cmd
->atio
.u
.isp24
.fcp_cmnd
.lun
);
1354 if (cmd_key
== key
&& cmd_lun
== lun
)
1355 cmd
->state
= QLA_TGT_STATE_ABORTED
;
1357 spin_unlock(&vha
->cmd_list_lock
);
1360 /* ha->hardware_lock supposed to be held on entry */
1361 static int __qlt_24xx_handle_abts(struct scsi_qla_host
*vha
,
1362 struct abts_recv_from_24xx
*abts
, struct qla_tgt_sess
*sess
)
1364 struct qla_hw_data
*ha
= vha
->hw
;
1365 struct se_session
*se_sess
= sess
->se_sess
;
1366 struct qla_tgt_mgmt_cmd
*mcmd
;
1367 struct se_cmd
*se_cmd
;
1370 bool found_lun
= false;
1372 spin_lock(&se_sess
->sess_cmd_lock
);
1373 list_for_each_entry(se_cmd
, &se_sess
->sess_cmd_list
, se_cmd_list
) {
1374 struct qla_tgt_cmd
*cmd
=
1375 container_of(se_cmd
, struct qla_tgt_cmd
, se_cmd
);
1376 if (se_cmd
->tag
== abts
->exchange_addr_to_abort
) {
1377 lun
= cmd
->unpacked_lun
;
1382 spin_unlock(&se_sess
->sess_cmd_lock
);
1384 /* cmd not in LIO lists, look in qla list */
1386 if (abort_cmd_for_tag(vha
, abts
->exchange_addr_to_abort
)) {
1387 /* send TASK_ABORT response immediately */
1388 qlt_24xx_send_abts_resp(vha
, abts
, FCP_TMF_CMPL
, false);
1391 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf081,
1392 "unable to find cmd in driver or LIO for tag 0x%x\n",
1393 abts
->exchange_addr_to_abort
);
1398 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf00f,
1399 "qla_target(%d): task abort (tag=%d)\n",
1400 vha
->vp_idx
, abts
->exchange_addr_to_abort
);
1402 mcmd
= mempool_alloc(qla_tgt_mgmt_cmd_mempool
, GFP_ATOMIC
);
1404 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf051,
1405 "qla_target(%d): %s: Allocation of ABORT cmd failed",
1406 vha
->vp_idx
, __func__
);
1409 memset(mcmd
, 0, sizeof(*mcmd
));
1412 memcpy(&mcmd
->orig_iocb
.abts
, abts
, sizeof(mcmd
->orig_iocb
.abts
));
1413 mcmd
->reset_count
= vha
->hw
->chip_reset
;
1415 rc
= ha
->tgt
.tgt_ops
->handle_tmr(mcmd
, lun
, TMR_ABORT_TASK
,
1416 abts
->exchange_addr_to_abort
);
1418 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf052,
1419 "qla_target(%d): tgt_ops->handle_tmr()"
1420 " failed: %d", vha
->vp_idx
, rc
);
1421 mempool_free(mcmd
, qla_tgt_mgmt_cmd_mempool
);
1429 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1431 static void qlt_24xx_handle_abts(struct scsi_qla_host
*vha
,
1432 struct abts_recv_from_24xx
*abts
)
1434 struct qla_hw_data
*ha
= vha
->hw
;
1435 struct qla_tgt_sess
*sess
;
1436 uint32_t tag
= abts
->exchange_addr_to_abort
;
1440 if (le32_to_cpu(abts
->fcp_hdr_le
.parameter
) & ABTS_PARAM_ABORT_SEQ
) {
1441 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf053,
1442 "qla_target(%d): ABTS: Abort Sequence not "
1443 "supported\n", vha
->vp_idx
);
1444 qlt_24xx_send_abts_resp(vha
, abts
, FCP_TMF_REJECTED
, false);
1448 if (tag
== ATIO_EXCHANGE_ADDRESS_UNKNOWN
) {
1449 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf010,
1450 "qla_target(%d): ABTS: Unknown Exchange "
1451 "Address received\n", vha
->vp_idx
);
1452 qlt_24xx_send_abts_resp(vha
, abts
, FCP_TMF_REJECTED
, false);
1456 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf011,
1457 "qla_target(%d): task abort (s_id=%x:%x:%x, "
1458 "tag=%d, param=%x)\n", vha
->vp_idx
, abts
->fcp_hdr_le
.s_id
[2],
1459 abts
->fcp_hdr_le
.s_id
[1], abts
->fcp_hdr_le
.s_id
[0], tag
,
1460 le32_to_cpu(abts
->fcp_hdr_le
.parameter
));
1462 s_id
[0] = abts
->fcp_hdr_le
.s_id
[2];
1463 s_id
[1] = abts
->fcp_hdr_le
.s_id
[1];
1464 s_id
[2] = abts
->fcp_hdr_le
.s_id
[0];
1466 sess
= ha
->tgt
.tgt_ops
->find_sess_by_s_id(vha
, s_id
);
1468 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf012,
1469 "qla_target(%d): task abort for non-existant session\n",
1471 rc
= qlt_sched_sess_work(vha
->vha_tgt
.qla_tgt
,
1472 QLA_TGT_SESS_WORK_ABORT
, abts
, sizeof(*abts
));
1474 qlt_24xx_send_abts_resp(vha
, abts
, FCP_TMF_REJECTED
,
1480 if (sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
) {
1481 qlt_24xx_send_abts_resp(vha
, abts
, FCP_TMF_REJECTED
, false);
1485 rc
= __qlt_24xx_handle_abts(vha
, abts
, sess
);
1487 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf054,
1488 "qla_target(%d): __qlt_24xx_handle_abts() failed: %d\n",
1490 qlt_24xx_send_abts_resp(vha
, abts
, FCP_TMF_REJECTED
, false);
1496 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1498 static void qlt_24xx_send_task_mgmt_ctio(struct scsi_qla_host
*ha
,
1499 struct qla_tgt_mgmt_cmd
*mcmd
, uint32_t resp_code
)
1501 struct atio_from_isp
*atio
= &mcmd
->orig_iocb
.atio
;
1502 struct ctio7_to_24xx
*ctio
;
1505 ql_dbg(ql_dbg_tgt
, ha
, 0xe008,
1506 "Sending task mgmt CTIO7 (ha=%p, atio=%p, resp_code=%x\n",
1507 ha
, atio
, resp_code
);
1509 /* Send marker if required */
1510 if (qlt_issue_marker(ha
, 1) != QLA_SUCCESS
)
1513 ctio
= (struct ctio7_to_24xx
*)qla2x00_alloc_iocbs(ha
, NULL
);
1515 ql_dbg(ql_dbg_tgt
, ha
, 0xe04c,
1516 "qla_target(%d): %s failed: unable to allocate "
1517 "request packet\n", ha
->vp_idx
, __func__
);
1521 ctio
->entry_type
= CTIO_TYPE7
;
1522 ctio
->entry_count
= 1;
1523 ctio
->handle
= QLA_TGT_SKIP_HANDLE
| CTIO_COMPLETION_HANDLE_MARK
;
1524 ctio
->nport_handle
= mcmd
->sess
->loop_id
;
1525 ctio
->timeout
= __constant_cpu_to_le16(QLA_TGT_TIMEOUT
);
1526 ctio
->vp_index
= ha
->vp_idx
;
1527 ctio
->initiator_id
[0] = atio
->u
.isp24
.fcp_hdr
.s_id
[2];
1528 ctio
->initiator_id
[1] = atio
->u
.isp24
.fcp_hdr
.s_id
[1];
1529 ctio
->initiator_id
[2] = atio
->u
.isp24
.fcp_hdr
.s_id
[0];
1530 ctio
->exchange_addr
= atio
->u
.isp24
.exchange_addr
;
1531 ctio
->u
.status1
.flags
= (atio
->u
.isp24
.attr
<< 9) |
1532 __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1
|
1533 CTIO7_FLAGS_SEND_STATUS
);
1534 temp
= be16_to_cpu(atio
->u
.isp24
.fcp_hdr
.ox_id
);
1535 ctio
->u
.status1
.ox_id
= cpu_to_le16(temp
);
1536 ctio
->u
.status1
.scsi_status
=
1537 __constant_cpu_to_le16(SS_RESPONSE_INFO_LEN_VALID
);
1538 ctio
->u
.status1
.response_len
= __constant_cpu_to_le16(8);
1539 ctio
->u
.status1
.sense_data
[0] = resp_code
;
1541 /* Memory Barrier */
1543 qla2x00_start_iocbs(ha
, ha
->req
);
1546 void qlt_free_mcmd(struct qla_tgt_mgmt_cmd
*mcmd
)
1548 mempool_free(mcmd
, qla_tgt_mgmt_cmd_mempool
);
1550 EXPORT_SYMBOL(qlt_free_mcmd
);
1552 /* callback from target fabric module code */
1553 void qlt_xmit_tm_rsp(struct qla_tgt_mgmt_cmd
*mcmd
)
1555 struct scsi_qla_host
*vha
= mcmd
->sess
->vha
;
1556 struct qla_hw_data
*ha
= vha
->hw
;
1557 unsigned long flags
;
1559 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf013,
1560 "TM response mcmd (%p) status %#x state %#x",
1561 mcmd
, mcmd
->fc_tm_rsp
, mcmd
->flags
);
1563 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1565 if (qla2x00_reset_active(vha
) || mcmd
->reset_count
!= ha
->chip_reset
) {
1567 * Either a chip reset is active or this request was from
1568 * previous life, just abort the processing.
1570 ql_dbg(ql_dbg_async
, vha
, 0xe100,
1571 "RESET-TMR active/old-count/new-count = %d/%d/%d.\n",
1572 qla2x00_reset_active(vha
), mcmd
->reset_count
,
1574 ha
->tgt
.tgt_ops
->free_mcmd(mcmd
);
1575 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1579 if (mcmd
->flags
== QLA24XX_MGMT_SEND_NACK
)
1580 qlt_send_notify_ack(vha
, &mcmd
->orig_iocb
.imm_ntfy
,
1583 if (mcmd
->se_cmd
.se_tmr_req
->function
== TMR_ABORT_TASK
)
1584 qlt_24xx_send_abts_resp(vha
, &mcmd
->orig_iocb
.abts
,
1585 mcmd
->fc_tm_rsp
, false);
1587 qlt_24xx_send_task_mgmt_ctio(vha
, mcmd
,
1591 * Make the callback for ->free_mcmd() to queue_work() and invoke
1592 * target_put_sess_cmd() to drop cmd_kref to 1. The final
1593 * target_put_sess_cmd() call will be made from TFO->check_stop_free()
1594 * -> tcm_qla2xxx_check_stop_free() to release the TMR associated se_cmd
1595 * descriptor after TFO->queue_tm_rsp() -> tcm_qla2xxx_queue_tm_rsp() ->
1596 * qlt_xmit_tm_rsp() returns here..
1598 ha
->tgt
.tgt_ops
->free_mcmd(mcmd
);
1599 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1601 EXPORT_SYMBOL(qlt_xmit_tm_rsp
);
1604 static int qlt_pci_map_calc_cnt(struct qla_tgt_prm
*prm
)
1606 struct qla_tgt_cmd
*cmd
= prm
->cmd
;
1608 BUG_ON(cmd
->sg_cnt
== 0);
1610 prm
->sg
= (struct scatterlist
*)cmd
->sg
;
1611 prm
->seg_cnt
= pci_map_sg(prm
->tgt
->ha
->pdev
, cmd
->sg
,
1612 cmd
->sg_cnt
, cmd
->dma_data_direction
);
1613 if (unlikely(prm
->seg_cnt
== 0))
1616 prm
->cmd
->sg_mapped
= 1;
1618 if (cmd
->se_cmd
.prot_op
== TARGET_PROT_NORMAL
) {
1620 * If greater than four sg entries then we need to allocate
1621 * the continuation entries
1623 if (prm
->seg_cnt
> prm
->tgt
->datasegs_per_cmd
)
1624 prm
->req_cnt
+= DIV_ROUND_UP(prm
->seg_cnt
-
1625 prm
->tgt
->datasegs_per_cmd
,
1626 prm
->tgt
->datasegs_per_cont
);
1629 if ((cmd
->se_cmd
.prot_op
== TARGET_PROT_DIN_INSERT
) ||
1630 (cmd
->se_cmd
.prot_op
== TARGET_PROT_DOUT_STRIP
)) {
1631 prm
->seg_cnt
= DIV_ROUND_UP(cmd
->bufflen
, cmd
->blk_sz
);
1632 prm
->tot_dsds
= prm
->seg_cnt
;
1634 prm
->tot_dsds
= prm
->seg_cnt
;
1636 if (cmd
->prot_sg_cnt
) {
1637 prm
->prot_sg
= cmd
->prot_sg
;
1638 prm
->prot_seg_cnt
= pci_map_sg(prm
->tgt
->ha
->pdev
,
1639 cmd
->prot_sg
, cmd
->prot_sg_cnt
,
1640 cmd
->dma_data_direction
);
1641 if (unlikely(prm
->prot_seg_cnt
== 0))
1644 if ((cmd
->se_cmd
.prot_op
== TARGET_PROT_DIN_INSERT
) ||
1645 (cmd
->se_cmd
.prot_op
== TARGET_PROT_DOUT_STRIP
)) {
1646 /* Dif Bundling not support here */
1647 prm
->prot_seg_cnt
= DIV_ROUND_UP(cmd
->bufflen
,
1649 prm
->tot_dsds
+= prm
->prot_seg_cnt
;
1651 prm
->tot_dsds
+= prm
->prot_seg_cnt
;
1658 ql_dbg(ql_dbg_tgt
, prm
->cmd
->vha
, 0xe04d,
1659 "qla_target(%d): PCI mapping failed: sg_cnt=%d",
1660 0, prm
->cmd
->sg_cnt
);
1664 static void qlt_unmap_sg(struct scsi_qla_host
*vha
, struct qla_tgt_cmd
*cmd
)
1666 struct qla_hw_data
*ha
= vha
->hw
;
1668 if (!cmd
->sg_mapped
)
1671 pci_unmap_sg(ha
->pdev
, cmd
->sg
, cmd
->sg_cnt
, cmd
->dma_data_direction
);
1674 if (cmd
->prot_sg_cnt
)
1675 pci_unmap_sg(ha
->pdev
, cmd
->prot_sg
, cmd
->prot_sg_cnt
,
1676 cmd
->dma_data_direction
);
1678 if (cmd
->ctx_dsd_alloced
)
1679 qla2x00_clean_dsd_pool(ha
, NULL
, cmd
);
1682 dma_pool_free(ha
->dl_dma_pool
, cmd
->ctx
, cmd
->ctx
->crc_ctx_dma
);
1685 static int qlt_check_reserve_free_req(struct scsi_qla_host
*vha
,
1688 uint32_t cnt
, cnt_in
;
1690 if (vha
->req
->cnt
< (req_cnt
+ 2)) {
1691 cnt
= (uint16_t)RD_REG_DWORD(vha
->req
->req_q_out
);
1692 cnt_in
= (uint16_t)RD_REG_DWORD(vha
->req
->req_q_in
);
1694 if (vha
->req
->ring_index
< cnt
)
1695 vha
->req
->cnt
= cnt
- vha
->req
->ring_index
;
1697 vha
->req
->cnt
= vha
->req
->length
-
1698 (vha
->req
->ring_index
- cnt
);
1701 if (unlikely(vha
->req
->cnt
< (req_cnt
+ 2))) {
1702 ql_dbg(ql_dbg_io
, vha
, 0x305a,
1703 "qla_target(%d): There is no room in the request ring: vha->req->ring_index=%d, vha->req->cnt=%d, req_cnt=%d Req-out=%d Req-in=%d Req-Length=%d\n",
1704 vha
->vp_idx
, vha
->req
->ring_index
,
1705 vha
->req
->cnt
, req_cnt
, cnt
, cnt_in
, vha
->req
->length
);
1708 vha
->req
->cnt
-= req_cnt
;
1714 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1716 static inline void *qlt_get_req_pkt(struct scsi_qla_host
*vha
)
1718 /* Adjust ring index. */
1719 vha
->req
->ring_index
++;
1720 if (vha
->req
->ring_index
== vha
->req
->length
) {
1721 vha
->req
->ring_index
= 0;
1722 vha
->req
->ring_ptr
= vha
->req
->ring
;
1724 vha
->req
->ring_ptr
++;
1726 return (cont_entry_t
*)vha
->req
->ring_ptr
;
1729 /* ha->hardware_lock supposed to be held on entry */
1730 static inline uint32_t qlt_make_handle(struct scsi_qla_host
*vha
)
1732 struct qla_hw_data
*ha
= vha
->hw
;
1735 h
= ha
->tgt
.current_handle
;
1736 /* always increment cmd handle */
1739 if (h
> DEFAULT_OUTSTANDING_COMMANDS
)
1740 h
= 1; /* 0 is QLA_TGT_NULL_HANDLE */
1741 if (h
== ha
->tgt
.current_handle
) {
1742 ql_dbg(ql_dbg_io
, vha
, 0x305b,
1743 "qla_target(%d): Ran out of "
1744 "empty cmd slots in ha %p\n", vha
->vp_idx
, ha
);
1745 h
= QLA_TGT_NULL_HANDLE
;
1748 } while ((h
== QLA_TGT_NULL_HANDLE
) ||
1749 (h
== QLA_TGT_SKIP_HANDLE
) ||
1750 (ha
->tgt
.cmds
[h
-1] != NULL
));
1752 if (h
!= QLA_TGT_NULL_HANDLE
)
1753 ha
->tgt
.current_handle
= h
;
1758 /* ha->hardware_lock supposed to be held on entry */
1759 static int qlt_24xx_build_ctio_pkt(struct qla_tgt_prm
*prm
,
1760 struct scsi_qla_host
*vha
)
1763 struct ctio7_to_24xx
*pkt
;
1764 struct qla_hw_data
*ha
= vha
->hw
;
1765 struct atio_from_isp
*atio
= &prm
->cmd
->atio
;
1768 pkt
= (struct ctio7_to_24xx
*)vha
->req
->ring_ptr
;
1770 memset(pkt
, 0, sizeof(*pkt
));
1772 pkt
->entry_type
= CTIO_TYPE7
;
1773 pkt
->entry_count
= (uint8_t)prm
->req_cnt
;
1774 pkt
->vp_index
= vha
->vp_idx
;
1776 h
= qlt_make_handle(vha
);
1777 if (unlikely(h
== QLA_TGT_NULL_HANDLE
)) {
1779 * CTIO type 7 from the firmware doesn't provide a way to
1780 * know the initiator's LOOP ID, hence we can't find
1781 * the session and, so, the command.
1785 ha
->tgt
.cmds
[h
-1] = prm
->cmd
;
1787 pkt
->handle
= h
| CTIO_COMPLETION_HANDLE_MARK
;
1788 pkt
->nport_handle
= prm
->cmd
->loop_id
;
1789 pkt
->timeout
= __constant_cpu_to_le16(QLA_TGT_TIMEOUT
);
1790 pkt
->initiator_id
[0] = atio
->u
.isp24
.fcp_hdr
.s_id
[2];
1791 pkt
->initiator_id
[1] = atio
->u
.isp24
.fcp_hdr
.s_id
[1];
1792 pkt
->initiator_id
[2] = atio
->u
.isp24
.fcp_hdr
.s_id
[0];
1793 pkt
->exchange_addr
= atio
->u
.isp24
.exchange_addr
;
1794 pkt
->u
.status0
.flags
|= (atio
->u
.isp24
.attr
<< 9);
1795 temp
= be16_to_cpu(atio
->u
.isp24
.fcp_hdr
.ox_id
);
1796 pkt
->u
.status0
.ox_id
= cpu_to_le16(temp
);
1797 pkt
->u
.status0
.relative_offset
= cpu_to_le32(prm
->cmd
->offset
);
1803 * ha->hardware_lock supposed to be held on entry. We have already made sure
1804 * that there is sufficient amount of request entries to not drop it.
1806 static void qlt_load_cont_data_segments(struct qla_tgt_prm
*prm
,
1807 struct scsi_qla_host
*vha
)
1810 uint32_t *dword_ptr
;
1811 int enable_64bit_addressing
= prm
->tgt
->tgt_enable_64bit_addr
;
1813 /* Build continuation packets */
1814 while (prm
->seg_cnt
> 0) {
1815 cont_a64_entry_t
*cont_pkt64
=
1816 (cont_a64_entry_t
*)qlt_get_req_pkt(vha
);
1819 * Make sure that from cont_pkt64 none of
1820 * 64-bit specific fields used for 32-bit
1821 * addressing. Cast to (cont_entry_t *) for
1825 memset(cont_pkt64
, 0, sizeof(*cont_pkt64
));
1827 cont_pkt64
->entry_count
= 1;
1828 cont_pkt64
->sys_define
= 0;
1830 if (enable_64bit_addressing
) {
1831 cont_pkt64
->entry_type
= CONTINUE_A64_TYPE
;
1833 (uint32_t *)&cont_pkt64
->dseg_0_address
;
1835 cont_pkt64
->entry_type
= CONTINUE_TYPE
;
1837 (uint32_t *)&((cont_entry_t
*)
1838 cont_pkt64
)->dseg_0_address
;
1841 /* Load continuation entry data segments */
1843 cnt
< prm
->tgt
->datasegs_per_cont
&& prm
->seg_cnt
;
1844 cnt
++, prm
->seg_cnt
--) {
1846 cpu_to_le32(pci_dma_lo32
1847 (sg_dma_address(prm
->sg
)));
1848 if (enable_64bit_addressing
) {
1850 cpu_to_le32(pci_dma_hi32
1854 *dword_ptr
++ = cpu_to_le32(sg_dma_len(prm
->sg
));
1856 prm
->sg
= sg_next(prm
->sg
);
1862 * ha->hardware_lock supposed to be held on entry. We have already made sure
1863 * that there is sufficient amount of request entries to not drop it.
1865 static void qlt_load_data_segments(struct qla_tgt_prm
*prm
,
1866 struct scsi_qla_host
*vha
)
1869 uint32_t *dword_ptr
;
1870 int enable_64bit_addressing
= prm
->tgt
->tgt_enable_64bit_addr
;
1871 struct ctio7_to_24xx
*pkt24
= (struct ctio7_to_24xx
*)prm
->pkt
;
1873 pkt24
->u
.status0
.transfer_length
= cpu_to_le32(prm
->cmd
->bufflen
);
1875 /* Setup packet address segment pointer */
1876 dword_ptr
= pkt24
->u
.status0
.dseg_0_address
;
1878 /* Set total data segment count */
1880 pkt24
->dseg_count
= cpu_to_le16(prm
->seg_cnt
);
1882 if (prm
->seg_cnt
== 0) {
1883 /* No data transfer */
1889 /* If scatter gather */
1891 /* Load command entry data segments */
1893 (cnt
< prm
->tgt
->datasegs_per_cmd
) && prm
->seg_cnt
;
1894 cnt
++, prm
->seg_cnt
--) {
1896 cpu_to_le32(pci_dma_lo32(sg_dma_address(prm
->sg
)));
1897 if (enable_64bit_addressing
) {
1899 cpu_to_le32(pci_dma_hi32(
1900 sg_dma_address(prm
->sg
)));
1902 *dword_ptr
++ = cpu_to_le32(sg_dma_len(prm
->sg
));
1904 prm
->sg
= sg_next(prm
->sg
);
1907 qlt_load_cont_data_segments(prm
, vha
);
1910 static inline int qlt_has_data(struct qla_tgt_cmd
*cmd
)
1912 return cmd
->bufflen
> 0;
1916 * Called without ha->hardware_lock held
1918 static int qlt_pre_xmit_response(struct qla_tgt_cmd
*cmd
,
1919 struct qla_tgt_prm
*prm
, int xmit_type
, uint8_t scsi_status
,
1920 uint32_t *full_req_cnt
)
1922 struct qla_tgt
*tgt
= cmd
->tgt
;
1923 struct scsi_qla_host
*vha
= tgt
->vha
;
1924 struct qla_hw_data
*ha
= vha
->hw
;
1925 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
1929 prm
->rq_result
= scsi_status
;
1930 prm
->sense_buffer
= &cmd
->sense_buffer
[0];
1931 prm
->sense_buffer_len
= TRANSPORT_SENSE_BUFFER
;
1935 prm
->add_status_pkt
= 0;
1937 /* Send marker if required */
1938 if (qlt_issue_marker(vha
, 0) != QLA_SUCCESS
)
1941 if ((xmit_type
& QLA_TGT_XMIT_DATA
) && qlt_has_data(cmd
)) {
1942 if (qlt_pci_map_calc_cnt(prm
) != 0)
1946 *full_req_cnt
= prm
->req_cnt
;
1948 if (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
) {
1949 prm
->residual
= se_cmd
->residual_count
;
1950 ql_dbg(ql_dbg_io
+ ql_dbg_verbose
, vha
, 0x305c,
1951 "Residual underflow: %d (tag %lld, op %x, bufflen %d, rq_result %x)\n",
1952 prm
->residual
, se_cmd
->tag
,
1953 se_cmd
->t_task_cdb
? se_cmd
->t_task_cdb
[0] : 0,
1954 cmd
->bufflen
, prm
->rq_result
);
1955 prm
->rq_result
|= SS_RESIDUAL_UNDER
;
1956 } else if (se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) {
1957 prm
->residual
= se_cmd
->residual_count
;
1958 ql_dbg(ql_dbg_io
, vha
, 0x305d,
1959 "Residual overflow: %d (tag %lld, op %x, bufflen %d, rq_result %x)\n",
1960 prm
->residual
, se_cmd
->tag
, se_cmd
->t_task_cdb
?
1961 se_cmd
->t_task_cdb
[0] : 0, cmd
->bufflen
, prm
->rq_result
);
1962 prm
->rq_result
|= SS_RESIDUAL_OVER
;
1965 if (xmit_type
& QLA_TGT_XMIT_STATUS
) {
1967 * If QLA_TGT_XMIT_DATA is not set, add_status_pkt will be
1968 * ignored in *xmit_response() below
1970 if (qlt_has_data(cmd
)) {
1971 if (QLA_TGT_SENSE_VALID(prm
->sense_buffer
) ||
1972 (IS_FWI2_CAPABLE(ha
) &&
1973 (prm
->rq_result
!= 0))) {
1974 prm
->add_status_pkt
= 1;
1983 static inline int qlt_need_explicit_conf(struct qla_hw_data
*ha
,
1984 struct qla_tgt_cmd
*cmd
, int sending_sense
)
1986 if (ha
->tgt
.enable_class_2
)
1990 return cmd
->conf_compl_supported
;
1992 return ha
->tgt
.enable_explicit_conf
&&
1993 cmd
->conf_compl_supported
;
1996 #ifdef CONFIG_QLA_TGT_DEBUG_SRR
1998 * Original taken from the XFS code
2000 static unsigned long qlt_srr_random(void)
2003 static unsigned long RandomValue
;
2004 static DEFINE_SPINLOCK(lock
);
2005 /* cycles pseudo-randomly through all values between 1 and 2^31 - 2 */
2009 unsigned long flags
;
2011 spin_lock_irqsave(&lock
, flags
);
2013 RandomValue
= jiffies
;
2019 rv
= 16807 * lo
- 2836 * hi
;
2023 spin_unlock_irqrestore(&lock
, flags
);
2027 static void qlt_check_srr_debug(struct qla_tgt_cmd
*cmd
, int *xmit_type
)
2029 #if 0 /* This is not a real status packets lost, so it won't lead to SRR */
2030 if ((*xmit_type
& QLA_TGT_XMIT_STATUS
) && (qlt_srr_random() % 200)
2032 *xmit_type
&= ~QLA_TGT_XMIT_STATUS
;
2033 ql_dbg(ql_dbg_tgt_mgt
, cmd
->vha
, 0xf015,
2034 "Dropping cmd %p (tag %d) status", cmd
, se_cmd
->tag
);
2038 * It's currently not possible to simulate SRRs for FCP_WRITE without
2039 * a physical link layer failure, so don't even try here..
2041 if (cmd
->dma_data_direction
!= DMA_FROM_DEVICE
)
2044 if (qlt_has_data(cmd
) && (cmd
->sg_cnt
> 1) &&
2045 ((qlt_srr_random() % 100) == 20)) {
2047 unsigned int tot_len
= 0;
2050 leave
= qlt_srr_random() % cmd
->sg_cnt
;
2052 for (i
= 0; i
< leave
; i
++)
2053 tot_len
+= cmd
->sg
[i
].length
;
2055 ql_dbg(ql_dbg_tgt_mgt
, cmd
->vha
, 0xf016,
2056 "Cutting cmd %p (tag %d) buffer"
2057 " tail to len %d, sg_cnt %d (cmd->bufflen %d,"
2058 " cmd->sg_cnt %d)", cmd
, se_cmd
->tag
, tot_len
, leave
,
2059 cmd
->bufflen
, cmd
->sg_cnt
);
2061 cmd
->bufflen
= tot_len
;
2062 cmd
->sg_cnt
= leave
;
2065 if (qlt_has_data(cmd
) && ((qlt_srr_random() % 100) == 70)) {
2066 unsigned int offset
= qlt_srr_random() % cmd
->bufflen
;
2068 ql_dbg(ql_dbg_tgt_mgt
, cmd
->vha
, 0xf017,
2069 "Cutting cmd %p (tag %d) buffer head "
2070 "to offset %d (cmd->bufflen %d)", cmd
, se_cmd
->tag
, offset
,
2073 *xmit_type
&= ~QLA_TGT_XMIT_DATA
;
2074 else if (qlt_set_data_offset(cmd
, offset
)) {
2075 ql_dbg(ql_dbg_tgt_mgt
, cmd
->vha
, 0xf018,
2076 "qlt_set_data_offset() failed (tag %d)", se_cmd
->tag
);
2081 static inline void qlt_check_srr_debug(struct qla_tgt_cmd
*cmd
, int *xmit_type
)
2085 static void qlt_24xx_init_ctio_to_isp(struct ctio7_to_24xx
*ctio
,
2086 struct qla_tgt_prm
*prm
)
2088 prm
->sense_buffer_len
= min_t(uint32_t, prm
->sense_buffer_len
,
2089 (uint32_t)sizeof(ctio
->u
.status1
.sense_data
));
2090 ctio
->u
.status0
.flags
|=
2091 __constant_cpu_to_le16(CTIO7_FLAGS_SEND_STATUS
);
2092 if (qlt_need_explicit_conf(prm
->tgt
->ha
, prm
->cmd
, 0)) {
2093 ctio
->u
.status0
.flags
|= __constant_cpu_to_le16(
2094 CTIO7_FLAGS_EXPLICIT_CONFORM
|
2095 CTIO7_FLAGS_CONFORM_REQ
);
2097 ctio
->u
.status0
.residual
= cpu_to_le32(prm
->residual
);
2098 ctio
->u
.status0
.scsi_status
= cpu_to_le16(prm
->rq_result
);
2099 if (QLA_TGT_SENSE_VALID(prm
->sense_buffer
)) {
2102 if (qlt_need_explicit_conf(prm
->tgt
->ha
, prm
->cmd
, 1)) {
2103 if (prm
->cmd
->se_cmd
.scsi_status
!= 0) {
2104 ql_dbg(ql_dbg_tgt
, prm
->cmd
->vha
, 0xe017,
2105 "Skipping EXPLICIT_CONFORM and "
2106 "CTIO7_FLAGS_CONFORM_REQ for FCP READ w/ "
2107 "non GOOD status\n");
2108 goto skip_explict_conf
;
2110 ctio
->u
.status1
.flags
|= __constant_cpu_to_le16(
2111 CTIO7_FLAGS_EXPLICIT_CONFORM
|
2112 CTIO7_FLAGS_CONFORM_REQ
);
2115 ctio
->u
.status1
.flags
&=
2116 ~__constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_0
);
2117 ctio
->u
.status1
.flags
|=
2118 __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1
);
2119 ctio
->u
.status1
.scsi_status
|=
2120 __constant_cpu_to_le16(SS_SENSE_LEN_VALID
);
2121 ctio
->u
.status1
.sense_length
=
2122 cpu_to_le16(prm
->sense_buffer_len
);
2123 for (i
= 0; i
< prm
->sense_buffer_len
/4; i
++)
2124 ((uint32_t *)ctio
->u
.status1
.sense_data
)[i
] =
2125 cpu_to_be32(((uint32_t *)prm
->sense_buffer
)[i
]);
2127 if (unlikely((prm
->sense_buffer_len
% 4) != 0)) {
2130 ql_dbg(ql_dbg_tgt
, vha
, 0xe04f,
2131 "qla_target(%d): %d bytes of sense "
2132 "lost", prm
->tgt
->ha
->vp_idx
,
2133 prm
->sense_buffer_len
% 4);
2139 ctio
->u
.status1
.flags
&=
2140 ~__constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_0
);
2141 ctio
->u
.status1
.flags
|=
2142 __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1
);
2143 ctio
->u
.status1
.sense_length
= 0;
2144 memset(ctio
->u
.status1
.sense_data
, 0,
2145 sizeof(ctio
->u
.status1
.sense_data
));
2148 /* Sense with len > 24, is it possible ??? */
2155 qlt_hba_err_chk_enabled(struct se_cmd
*se_cmd
)
2158 * Uncomment when corresponding SCSI changes are done.
2160 if (!sp->cmd->prot_chk)
2164 switch (se_cmd
->prot_op
) {
2165 case TARGET_PROT_DOUT_INSERT
:
2166 case TARGET_PROT_DIN_STRIP
:
2167 if (ql2xenablehba_err_chk
>= 1)
2170 case TARGET_PROT_DOUT_PASS
:
2171 case TARGET_PROT_DIN_PASS
:
2172 if (ql2xenablehba_err_chk
>= 2)
2175 case TARGET_PROT_DIN_INSERT
:
2176 case TARGET_PROT_DOUT_STRIP
:
2185 * qla24xx_set_t10dif_tags_from_cmd - Extract Ref and App tags from SCSI command
2189 qlt_set_t10dif_tags(struct se_cmd
*se_cmd
, struct crc_context
*ctx
)
2191 uint32_t lba
= 0xffffffff & se_cmd
->t_task_lba
;
2193 /* wait til Mode Sense/Select cmd, modepage Ah, subpage 2
2194 * have been immplemented by TCM, before AppTag is avail.
2195 * Look for modesense_handlers[]
2198 ctx
->app_tag_mask
[0] = 0x0;
2199 ctx
->app_tag_mask
[1] = 0x0;
2201 switch (se_cmd
->prot_type
) {
2202 case TARGET_DIF_TYPE0_PROT
:
2204 * No check for ql2xenablehba_err_chk, as it would be an
2205 * I/O error if hba tag generation is not done.
2207 ctx
->ref_tag
= cpu_to_le32(lba
);
2209 if (!qlt_hba_err_chk_enabled(se_cmd
))
2212 /* enable ALL bytes of the ref tag */
2213 ctx
->ref_tag_mask
[0] = 0xff;
2214 ctx
->ref_tag_mask
[1] = 0xff;
2215 ctx
->ref_tag_mask
[2] = 0xff;
2216 ctx
->ref_tag_mask
[3] = 0xff;
2219 * For TYpe 1 protection: 16 bit GUARD tag, 32 bit REF tag, and
2222 case TARGET_DIF_TYPE1_PROT
:
2223 ctx
->ref_tag
= cpu_to_le32(lba
);
2225 if (!qlt_hba_err_chk_enabled(se_cmd
))
2228 /* enable ALL bytes of the ref tag */
2229 ctx
->ref_tag_mask
[0] = 0xff;
2230 ctx
->ref_tag_mask
[1] = 0xff;
2231 ctx
->ref_tag_mask
[2] = 0xff;
2232 ctx
->ref_tag_mask
[3] = 0xff;
2235 * For TYPE 2 protection: 16 bit GUARD + 32 bit REF tag has to
2236 * match LBA in CDB + N
2238 case TARGET_DIF_TYPE2_PROT
:
2239 ctx
->ref_tag
= cpu_to_le32(lba
);
2241 if (!qlt_hba_err_chk_enabled(se_cmd
))
2244 /* enable ALL bytes of the ref tag */
2245 ctx
->ref_tag_mask
[0] = 0xff;
2246 ctx
->ref_tag_mask
[1] = 0xff;
2247 ctx
->ref_tag_mask
[2] = 0xff;
2248 ctx
->ref_tag_mask
[3] = 0xff;
2251 /* For Type 3 protection: 16 bit GUARD only */
2252 case TARGET_DIF_TYPE3_PROT
:
2253 ctx
->ref_tag_mask
[0] = ctx
->ref_tag_mask
[1] =
2254 ctx
->ref_tag_mask
[2] = ctx
->ref_tag_mask
[3] = 0x00;
2261 qlt_build_ctio_crc2_pkt(struct qla_tgt_prm
*prm
, scsi_qla_host_t
*vha
)
2265 uint32_t transfer_length
= 0;
2266 uint32_t data_bytes
;
2268 uint8_t bundling
= 1;
2270 struct crc_context
*crc_ctx_pkt
= NULL
;
2271 struct qla_hw_data
*ha
;
2272 struct ctio_crc2_to_fw
*pkt
;
2273 dma_addr_t crc_ctx_dma
;
2274 uint16_t fw_prot_opts
= 0;
2275 struct qla_tgt_cmd
*cmd
= prm
->cmd
;
2276 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
2278 struct atio_from_isp
*atio
= &prm
->cmd
->atio
;
2284 pkt
= (struct ctio_crc2_to_fw
*)vha
->req
->ring_ptr
;
2286 memset(pkt
, 0, sizeof(*pkt
));
2288 ql_dbg(ql_dbg_tgt
, vha
, 0xe071,
2289 "qla_target(%d):%s: se_cmd[%p] CRC2 prot_op[0x%x] cmd prot sg:cnt[%p:%x] lba[%llu]\n",
2290 vha
->vp_idx
, __func__
, se_cmd
, se_cmd
->prot_op
,
2291 prm
->prot_sg
, prm
->prot_seg_cnt
, se_cmd
->t_task_lba
);
2293 if ((se_cmd
->prot_op
== TARGET_PROT_DIN_INSERT
) ||
2294 (se_cmd
->prot_op
== TARGET_PROT_DOUT_STRIP
))
2297 /* Compute dif len and adjust data len to incude protection */
2298 data_bytes
= cmd
->bufflen
;
2299 dif_bytes
= (data_bytes
/ cmd
->blk_sz
) * 8;
2301 switch (se_cmd
->prot_op
) {
2302 case TARGET_PROT_DIN_INSERT
:
2303 case TARGET_PROT_DOUT_STRIP
:
2304 transfer_length
= data_bytes
;
2305 data_bytes
+= dif_bytes
;
2308 case TARGET_PROT_DIN_STRIP
:
2309 case TARGET_PROT_DOUT_INSERT
:
2310 case TARGET_PROT_DIN_PASS
:
2311 case TARGET_PROT_DOUT_PASS
:
2312 transfer_length
= data_bytes
+ dif_bytes
;
2320 if (!qlt_hba_err_chk_enabled(se_cmd
))
2321 fw_prot_opts
|= 0x10; /* Disable Guard tag checking */
2322 /* HBA error checking enabled */
2323 else if (IS_PI_UNINIT_CAPABLE(ha
)) {
2324 if ((se_cmd
->prot_type
== TARGET_DIF_TYPE1_PROT
) ||
2325 (se_cmd
->prot_type
== TARGET_DIF_TYPE2_PROT
))
2326 fw_prot_opts
|= PO_DIS_VALD_APP_ESC
;
2327 else if (se_cmd
->prot_type
== TARGET_DIF_TYPE3_PROT
)
2328 fw_prot_opts
|= PO_DIS_VALD_APP_REF_ESC
;
2331 switch (se_cmd
->prot_op
) {
2332 case TARGET_PROT_DIN_INSERT
:
2333 case TARGET_PROT_DOUT_INSERT
:
2334 fw_prot_opts
|= PO_MODE_DIF_INSERT
;
2336 case TARGET_PROT_DIN_STRIP
:
2337 case TARGET_PROT_DOUT_STRIP
:
2338 fw_prot_opts
|= PO_MODE_DIF_REMOVE
;
2340 case TARGET_PROT_DIN_PASS
:
2341 case TARGET_PROT_DOUT_PASS
:
2342 fw_prot_opts
|= PO_MODE_DIF_PASS
;
2343 /* FUTURE: does tcm require T10CRC<->IPCKSUM conversion? */
2345 default:/* Normal Request */
2346 fw_prot_opts
|= PO_MODE_DIF_PASS
;
2352 /* Update entry type to indicate Command Type CRC_2 IOCB */
2353 pkt
->entry_type
= CTIO_CRC2
;
2354 pkt
->entry_count
= 1;
2355 pkt
->vp_index
= vha
->vp_idx
;
2357 h
= qlt_make_handle(vha
);
2358 if (unlikely(h
== QLA_TGT_NULL_HANDLE
)) {
2360 * CTIO type 7 from the firmware doesn't provide a way to
2361 * know the initiator's LOOP ID, hence we can't find
2362 * the session and, so, the command.
2366 ha
->tgt
.cmds
[h
-1] = prm
->cmd
;
2369 pkt
->handle
= h
| CTIO_COMPLETION_HANDLE_MARK
;
2370 pkt
->nport_handle
= prm
->cmd
->loop_id
;
2371 pkt
->timeout
= __constant_cpu_to_le16(QLA_TGT_TIMEOUT
);
2372 pkt
->initiator_id
[0] = atio
->u
.isp24
.fcp_hdr
.s_id
[2];
2373 pkt
->initiator_id
[1] = atio
->u
.isp24
.fcp_hdr
.s_id
[1];
2374 pkt
->initiator_id
[2] = atio
->u
.isp24
.fcp_hdr
.s_id
[0];
2375 pkt
->exchange_addr
= atio
->u
.isp24
.exchange_addr
;
2377 /* silence compile warning */
2378 t16
= be16_to_cpu(atio
->u
.isp24
.fcp_hdr
.ox_id
);
2379 pkt
->ox_id
= cpu_to_le16(t16
);
2381 t16
= (atio
->u
.isp24
.attr
<< 9);
2382 pkt
->flags
|= cpu_to_le16(t16
);
2383 pkt
->relative_offset
= cpu_to_le32(prm
->cmd
->offset
);
2385 /* Set transfer direction */
2386 if (cmd
->dma_data_direction
== DMA_TO_DEVICE
)
2387 pkt
->flags
= __constant_cpu_to_le16(CTIO7_FLAGS_DATA_IN
);
2388 else if (cmd
->dma_data_direction
== DMA_FROM_DEVICE
)
2389 pkt
->flags
= __constant_cpu_to_le16(CTIO7_FLAGS_DATA_OUT
);
2392 pkt
->dseg_count
= prm
->tot_dsds
;
2393 /* Fibre channel byte count */
2394 pkt
->transfer_length
= cpu_to_le32(transfer_length
);
2397 /* ----- CRC context -------- */
2399 /* Allocate CRC context from global pool */
2400 crc_ctx_pkt
= cmd
->ctx
=
2401 dma_pool_alloc(ha
->dl_dma_pool
, GFP_ATOMIC
, &crc_ctx_dma
);
2404 goto crc_queuing_error
;
2406 /* Zero out CTX area. */
2407 clr_ptr
= (uint8_t *)crc_ctx_pkt
;
2408 memset(clr_ptr
, 0, sizeof(*crc_ctx_pkt
));
2410 crc_ctx_pkt
->crc_ctx_dma
= crc_ctx_dma
;
2411 INIT_LIST_HEAD(&crc_ctx_pkt
->dsd_list
);
2414 crc_ctx_pkt
->handle
= pkt
->handle
;
2416 qlt_set_t10dif_tags(se_cmd
, crc_ctx_pkt
);
2418 pkt
->crc_context_address
[0] = cpu_to_le32(LSD(crc_ctx_dma
));
2419 pkt
->crc_context_address
[1] = cpu_to_le32(MSD(crc_ctx_dma
));
2420 pkt
->crc_context_len
= CRC_CONTEXT_LEN_FW
;
2424 cur_dsd
= (uint32_t *) &crc_ctx_pkt
->u
.nobundling
.data_address
;
2427 * Configure Bundling if we need to fetch interlaving
2428 * protection PCI accesses
2430 fw_prot_opts
|= PO_ENABLE_DIF_BUNDLING
;
2431 crc_ctx_pkt
->u
.bundling
.dif_byte_count
= cpu_to_le32(dif_bytes
);
2432 crc_ctx_pkt
->u
.bundling
.dseg_count
=
2433 cpu_to_le16(prm
->tot_dsds
- prm
->prot_seg_cnt
);
2434 cur_dsd
= (uint32_t *) &crc_ctx_pkt
->u
.bundling
.data_address
;
2437 /* Finish the common fields of CRC pkt */
2438 crc_ctx_pkt
->blk_size
= cpu_to_le16(cmd
->blk_sz
);
2439 crc_ctx_pkt
->prot_opts
= cpu_to_le16(fw_prot_opts
);
2440 crc_ctx_pkt
->byte_count
= cpu_to_le32(data_bytes
);
2441 crc_ctx_pkt
->guard_seed
= __constant_cpu_to_le16(0);
2444 /* Walks data segments */
2445 pkt
->flags
|= __constant_cpu_to_le16(CTIO7_FLAGS_DSD_PTR
);
2447 if (!bundling
&& prm
->prot_seg_cnt
) {
2448 if (qla24xx_walk_and_build_sglist_no_difb(ha
, NULL
, cur_dsd
,
2449 prm
->tot_dsds
, cmd
))
2450 goto crc_queuing_error
;
2451 } else if (qla24xx_walk_and_build_sglist(ha
, NULL
, cur_dsd
,
2452 (prm
->tot_dsds
- prm
->prot_seg_cnt
), cmd
))
2453 goto crc_queuing_error
;
2455 if (bundling
&& prm
->prot_seg_cnt
) {
2456 /* Walks dif segments */
2457 pkt
->add_flags
|= CTIO_CRC2_AF_DIF_DSD_ENA
;
2459 cur_dsd
= (uint32_t *) &crc_ctx_pkt
->u
.bundling
.dif_address
;
2460 if (qla24xx_walk_and_build_prot_sglist(ha
, NULL
, cur_dsd
,
2461 prm
->prot_seg_cnt
, cmd
))
2462 goto crc_queuing_error
;
2467 /* Cleanup will be performed by the caller */
2469 return QLA_FUNCTION_FAILED
;
2474 * Callback to setup response of xmit_type of QLA_TGT_XMIT_DATA and *
2475 * QLA_TGT_XMIT_STATUS for >= 24xx silicon
2477 int qlt_xmit_response(struct qla_tgt_cmd
*cmd
, int xmit_type
,
2478 uint8_t scsi_status
)
2480 struct scsi_qla_host
*vha
= cmd
->vha
;
2481 struct qla_hw_data
*ha
= vha
->hw
;
2482 struct ctio7_to_24xx
*pkt
;
2483 struct qla_tgt_prm prm
;
2484 uint32_t full_req_cnt
= 0;
2485 unsigned long flags
= 0;
2488 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2489 if (cmd
->sess
&& cmd
->sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
) {
2490 cmd
->state
= QLA_TGT_STATE_PROCESSED
;
2491 if (cmd
->sess
->logout_completed
)
2492 /* no need to terminate. FW already freed exchange. */
2493 qlt_abort_cmd_on_host_reset(cmd
->vha
, cmd
);
2495 qlt_send_term_exchange(vha
, cmd
, &cmd
->atio
, 1);
2496 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2499 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2501 memset(&prm
, 0, sizeof(prm
));
2502 qlt_check_srr_debug(cmd
, &xmit_type
);
2504 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe018,
2505 "is_send_status=%d, cmd->bufflen=%d, cmd->sg_cnt=%d, cmd->dma_data_direction=%d se_cmd[%p]\n",
2506 (xmit_type
& QLA_TGT_XMIT_STATUS
) ?
2507 1 : 0, cmd
->bufflen
, cmd
->sg_cnt
, cmd
->dma_data_direction
,
2510 res
= qlt_pre_xmit_response(cmd
, &prm
, xmit_type
, scsi_status
,
2512 if (unlikely(res
!= 0)) {
2516 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2518 if (qla2x00_reset_active(vha
) || cmd
->reset_count
!= ha
->chip_reset
) {
2520 * Either a chip reset is active or this request was from
2521 * previous life, just abort the processing.
2523 cmd
->state
= QLA_TGT_STATE_PROCESSED
;
2524 qlt_abort_cmd_on_host_reset(cmd
->vha
, cmd
);
2525 ql_dbg(ql_dbg_async
, vha
, 0xe101,
2526 "RESET-RSP active/old-count/new-count = %d/%d/%d.\n",
2527 qla2x00_reset_active(vha
), cmd
->reset_count
,
2529 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2533 /* Does F/W have an IOCBs for this request */
2534 res
= qlt_check_reserve_free_req(vha
, full_req_cnt
);
2536 goto out_unmap_unlock
;
2538 if (cmd
->se_cmd
.prot_op
&& (xmit_type
& QLA_TGT_XMIT_DATA
))
2539 res
= qlt_build_ctio_crc2_pkt(&prm
, vha
);
2541 res
= qlt_24xx_build_ctio_pkt(&prm
, vha
);
2542 if (unlikely(res
!= 0)) {
2543 vha
->req
->cnt
+= full_req_cnt
;
2544 goto out_unmap_unlock
;
2547 pkt
= (struct ctio7_to_24xx
*)prm
.pkt
;
2549 if (qlt_has_data(cmd
) && (xmit_type
& QLA_TGT_XMIT_DATA
)) {
2550 pkt
->u
.status0
.flags
|=
2551 __constant_cpu_to_le16(CTIO7_FLAGS_DATA_IN
|
2552 CTIO7_FLAGS_STATUS_MODE_0
);
2554 if (cmd
->se_cmd
.prot_op
== TARGET_PROT_NORMAL
)
2555 qlt_load_data_segments(&prm
, vha
);
2557 if (prm
.add_status_pkt
== 0) {
2558 if (xmit_type
& QLA_TGT_XMIT_STATUS
) {
2559 pkt
->u
.status0
.scsi_status
=
2560 cpu_to_le16(prm
.rq_result
);
2561 pkt
->u
.status0
.residual
=
2562 cpu_to_le32(prm
.residual
);
2563 pkt
->u
.status0
.flags
|= __constant_cpu_to_le16(
2564 CTIO7_FLAGS_SEND_STATUS
);
2565 if (qlt_need_explicit_conf(ha
, cmd
, 0)) {
2566 pkt
->u
.status0
.flags
|=
2567 __constant_cpu_to_le16(
2568 CTIO7_FLAGS_EXPLICIT_CONFORM
|
2569 CTIO7_FLAGS_CONFORM_REQ
);
2575 * We have already made sure that there is sufficient
2576 * amount of request entries to not drop HW lock in
2579 struct ctio7_to_24xx
*ctio
=
2580 (struct ctio7_to_24xx
*)qlt_get_req_pkt(vha
);
2582 ql_dbg(ql_dbg_io
, vha
, 0x305e,
2583 "Building additional status packet 0x%p.\n",
2587 * T10Dif: ctio_crc2_to_fw overlay ontop of
2590 memcpy(ctio
, pkt
, sizeof(*ctio
));
2591 /* reset back to CTIO7 */
2592 ctio
->entry_count
= 1;
2593 ctio
->entry_type
= CTIO_TYPE7
;
2594 ctio
->dseg_count
= 0;
2595 ctio
->u
.status1
.flags
&= ~__constant_cpu_to_le16(
2596 CTIO7_FLAGS_DATA_IN
);
2598 /* Real finish is ctio_m1's finish */
2599 pkt
->handle
|= CTIO_INTERMEDIATE_HANDLE_MARK
;
2600 pkt
->u
.status0
.flags
|= __constant_cpu_to_le16(
2601 CTIO7_FLAGS_DONT_RET_CTIO
);
2603 /* qlt_24xx_init_ctio_to_isp will correct
2604 * all neccessary fields that's part of CTIO7.
2605 * There should be no residual of CTIO-CRC2 data.
2607 qlt_24xx_init_ctio_to_isp((struct ctio7_to_24xx
*)ctio
,
2609 pr_debug("Status CTIO7: %p\n", ctio
);
2612 qlt_24xx_init_ctio_to_isp(pkt
, &prm
);
2615 cmd
->state
= QLA_TGT_STATE_PROCESSED
; /* Mid-level is done processing */
2616 cmd
->cmd_sent_to_fw
= 1;
2618 /* Memory Barrier */
2620 qla2x00_start_iocbs(vha
, vha
->req
);
2621 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2626 qlt_unmap_sg(vha
, cmd
);
2627 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2631 EXPORT_SYMBOL(qlt_xmit_response
);
2633 int qlt_rdy_to_xfer(struct qla_tgt_cmd
*cmd
)
2635 struct ctio7_to_24xx
*pkt
;
2636 struct scsi_qla_host
*vha
= cmd
->vha
;
2637 struct qla_hw_data
*ha
= vha
->hw
;
2638 struct qla_tgt
*tgt
= cmd
->tgt
;
2639 struct qla_tgt_prm prm
;
2640 unsigned long flags
;
2643 memset(&prm
, 0, sizeof(prm
));
2649 /* Send marker if required */
2650 if (qlt_issue_marker(vha
, 0) != QLA_SUCCESS
)
2653 /* Calculate number of entries and segments required */
2654 if (qlt_pci_map_calc_cnt(&prm
) != 0)
2657 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
2659 if (qla2x00_reset_active(vha
) || (cmd
->reset_count
!= ha
->chip_reset
) ||
2660 (cmd
->sess
&& cmd
->sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
)) {
2662 * Either a chip reset is active or this request was from
2663 * previous life, just abort the processing.
2665 cmd
->state
= QLA_TGT_STATE_NEED_DATA
;
2666 qlt_abort_cmd_on_host_reset(cmd
->vha
, cmd
);
2667 ql_dbg(ql_dbg_async
, vha
, 0xe102,
2668 "RESET-XFR active/old-count/new-count = %d/%d/%d.\n",
2669 qla2x00_reset_active(vha
), cmd
->reset_count
,
2671 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2675 /* Does F/W have an IOCBs for this request */
2676 res
= qlt_check_reserve_free_req(vha
, prm
.req_cnt
);
2678 goto out_unlock_free_unmap
;
2679 if (cmd
->se_cmd
.prot_op
)
2680 res
= qlt_build_ctio_crc2_pkt(&prm
, vha
);
2682 res
= qlt_24xx_build_ctio_pkt(&prm
, vha
);
2684 if (unlikely(res
!= 0)) {
2685 vha
->req
->cnt
+= prm
.req_cnt
;
2686 goto out_unlock_free_unmap
;
2689 pkt
= (struct ctio7_to_24xx
*)prm
.pkt
;
2690 pkt
->u
.status0
.flags
|= __constant_cpu_to_le16(CTIO7_FLAGS_DATA_OUT
|
2691 CTIO7_FLAGS_STATUS_MODE_0
);
2693 if (cmd
->se_cmd
.prot_op
== TARGET_PROT_NORMAL
)
2694 qlt_load_data_segments(&prm
, vha
);
2696 cmd
->state
= QLA_TGT_STATE_NEED_DATA
;
2697 cmd
->cmd_sent_to_fw
= 1;
2699 /* Memory Barrier */
2701 qla2x00_start_iocbs(vha
, vha
->req
);
2702 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2706 out_unlock_free_unmap
:
2707 qlt_unmap_sg(vha
, cmd
);
2708 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2712 EXPORT_SYMBOL(qlt_rdy_to_xfer
);
2716 * Checks the guard or meta-data for the type of error
2717 * detected by the HBA.
2720 qlt_handle_dif_error(struct scsi_qla_host
*vha
, struct qla_tgt_cmd
*cmd
,
2721 struct ctio_crc_from_fw
*sts
)
2723 uint8_t *ap
= &sts
->actual_dif
[0];
2724 uint8_t *ep
= &sts
->expected_dif
[0];
2725 uint32_t e_ref_tag
, a_ref_tag
;
2726 uint16_t e_app_tag
, a_app_tag
;
2727 uint16_t e_guard
, a_guard
;
2728 uint64_t lba
= cmd
->se_cmd
.t_task_lba
;
2730 a_guard
= be16_to_cpu(*(uint16_t *)(ap
+ 0));
2731 a_app_tag
= be16_to_cpu(*(uint16_t *)(ap
+ 2));
2732 a_ref_tag
= be32_to_cpu(*(uint32_t *)(ap
+ 4));
2734 e_guard
= be16_to_cpu(*(uint16_t *)(ep
+ 0));
2735 e_app_tag
= be16_to_cpu(*(uint16_t *)(ep
+ 2));
2736 e_ref_tag
= be32_to_cpu(*(uint32_t *)(ep
+ 4));
2738 ql_dbg(ql_dbg_tgt
, vha
, 0xe075,
2739 "iocb(s) %p Returned STATUS.\n", sts
);
2741 ql_dbg(ql_dbg_tgt
, vha
, 0xf075,
2742 "dif check TGT cdb 0x%x lba 0x%llx: [Actual|Expected] Ref Tag[0x%x|0x%x], App Tag [0x%x|0x%x], Guard [0x%x|0x%x]\n",
2743 cmd
->atio
.u
.isp24
.fcp_cmnd
.cdb
[0], lba
,
2744 a_ref_tag
, e_ref_tag
, a_app_tag
, e_app_tag
, a_guard
, e_guard
);
2748 * For type 3: ref & app tag is all 'f's
2749 * For type 0,1,2: app tag is all 'f's
2751 if ((a_app_tag
== 0xffff) &&
2752 ((cmd
->se_cmd
.prot_type
!= TARGET_DIF_TYPE3_PROT
) ||
2753 (a_ref_tag
== 0xffffffff))) {
2754 uint32_t blocks_done
;
2756 /* 2TB boundary case covered automatically with this */
2757 blocks_done
= e_ref_tag
- (uint32_t)lba
+ 1;
2758 cmd
->se_cmd
.bad_sector
= e_ref_tag
;
2759 cmd
->se_cmd
.pi_err
= 0;
2760 ql_dbg(ql_dbg_tgt
, vha
, 0xf074,
2761 "need to return scsi good\n");
2763 /* Update protection tag */
2764 if (cmd
->prot_sg_cnt
) {
2765 uint32_t i
, j
= 0, k
= 0, num_ent
;
2766 struct scatterlist
*sg
, *sgl
;
2771 /* Patch the corresponding protection tags */
2772 for_each_sg(sgl
, sg
, cmd
->prot_sg_cnt
, i
) {
2773 num_ent
= sg_dma_len(sg
) / 8;
2774 if (k
+ num_ent
< blocks_done
) {
2778 j
= blocks_done
- k
- 1;
2783 if (k
!= blocks_done
) {
2784 ql_log(ql_log_warn
, vha
, 0xf076,
2785 "unexpected tag values tag:lba=%u:%llu)\n",
2786 e_ref_tag
, (unsigned long long)lba
);
2791 struct sd_dif_tuple
*spt
;
2793 * This section came from initiator. Is it valid here?
2794 * should ulp be override with actual val???
2796 spt
= page_address(sg_page(sg
)) + sg
->offset
;
2799 spt
->app_tag
= 0xffff;
2800 if (cmd
->se_cmd
.prot_type
== SCSI_PROT_DIF_TYPE3
)
2801 spt
->ref_tag
= 0xffffffff;
2809 if (e_guard
!= a_guard
) {
2810 cmd
->se_cmd
.pi_err
= TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED
;
2811 cmd
->se_cmd
.bad_sector
= cmd
->se_cmd
.t_task_lba
;
2813 ql_log(ql_log_warn
, vha
, 0xe076,
2814 "Guard ERR: cdb 0x%x lba 0x%llx: [Actual|Expected] Ref Tag[0x%x|0x%x], App Tag [0x%x|0x%x], Guard [0x%x|0x%x] cmd=%p\n",
2815 cmd
->atio
.u
.isp24
.fcp_cmnd
.cdb
[0], lba
,
2816 a_ref_tag
, e_ref_tag
, a_app_tag
, e_app_tag
,
2817 a_guard
, e_guard
, cmd
);
2822 if (e_ref_tag
!= a_ref_tag
) {
2823 cmd
->se_cmd
.pi_err
= TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED
;
2824 cmd
->se_cmd
.bad_sector
= e_ref_tag
;
2826 ql_log(ql_log_warn
, vha
, 0xe077,
2827 "Ref Tag ERR: cdb 0x%x lba 0x%llx: [Actual|Expected] Ref Tag[0x%x|0x%x], App Tag [0x%x|0x%x], Guard [0x%x|0x%x] cmd=%p\n",
2828 cmd
->atio
.u
.isp24
.fcp_cmnd
.cdb
[0], lba
,
2829 a_ref_tag
, e_ref_tag
, a_app_tag
, e_app_tag
,
2830 a_guard
, e_guard
, cmd
);
2834 /* check appl tag */
2835 if (e_app_tag
!= a_app_tag
) {
2836 cmd
->se_cmd
.pi_err
= TCM_LOGICAL_BLOCK_APP_TAG_CHECK_FAILED
;
2837 cmd
->se_cmd
.bad_sector
= cmd
->se_cmd
.t_task_lba
;
2839 ql_log(ql_log_warn
, vha
, 0xe078,
2840 "App Tag ERR: cdb 0x%x lba 0x%llx: [Actual|Expected] Ref Tag[0x%x|0x%x], App Tag [0x%x|0x%x], Guard [0x%x|0x%x] cmd=%p\n",
2841 cmd
->atio
.u
.isp24
.fcp_cmnd
.cdb
[0], lba
,
2842 a_ref_tag
, e_ref_tag
, a_app_tag
, e_app_tag
,
2843 a_guard
, e_guard
, cmd
);
2851 /* If hardware_lock held on entry, might drop it, then reaquire */
2852 /* This function sends the appropriate CTIO to ISP 2xxx or 24xx */
2853 static int __qlt_send_term_imm_notif(struct scsi_qla_host
*vha
,
2854 struct imm_ntfy_from_isp
*ntfy
)
2856 struct nack_to_isp
*nack
;
2857 struct qla_hw_data
*ha
= vha
->hw
;
2861 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0xe01c,
2862 "Sending TERM ELS CTIO (ha=%p)\n", ha
);
2864 pkt
= (request_t
*)qla2x00_alloc_iocbs_ready(vha
, NULL
);
2866 ql_dbg(ql_dbg_tgt
, vha
, 0xe080,
2867 "qla_target(%d): %s failed: unable to allocate "
2868 "request packet\n", vha
->vp_idx
, __func__
);
2872 pkt
->entry_type
= NOTIFY_ACK_TYPE
;
2873 pkt
->entry_count
= 1;
2874 pkt
->handle
= QLA_TGT_SKIP_HANDLE
| CTIO_COMPLETION_HANDLE_MARK
;
2876 nack
= (struct nack_to_isp
*)pkt
;
2877 nack
->ox_id
= ntfy
->ox_id
;
2879 nack
->u
.isp24
.nport_handle
= ntfy
->u
.isp24
.nport_handle
;
2880 if (le16_to_cpu(ntfy
->u
.isp24
.status
) == IMM_NTFY_ELS
) {
2881 nack
->u
.isp24
.flags
= ntfy
->u
.isp24
.flags
&
2882 __constant_cpu_to_le32(NOTIFY24XX_FLAGS_PUREX_IOCB
);
2886 nack
->u
.isp24
.flags
|=
2887 __constant_cpu_to_le16(NOTIFY_ACK_FLAGS_TERMINATE
);
2889 nack
->u
.isp24
.srr_rx_id
= ntfy
->u
.isp24
.srr_rx_id
;
2890 nack
->u
.isp24
.status
= ntfy
->u
.isp24
.status
;
2891 nack
->u
.isp24
.status_subcode
= ntfy
->u
.isp24
.status_subcode
;
2892 nack
->u
.isp24
.fw_handle
= ntfy
->u
.isp24
.fw_handle
;
2893 nack
->u
.isp24
.exchange_address
= ntfy
->u
.isp24
.exchange_address
;
2894 nack
->u
.isp24
.srr_rel_offs
= ntfy
->u
.isp24
.srr_rel_offs
;
2895 nack
->u
.isp24
.srr_ui
= ntfy
->u
.isp24
.srr_ui
;
2896 nack
->u
.isp24
.vp_index
= ntfy
->u
.isp24
.vp_index
;
2898 qla2x00_start_iocbs(vha
, vha
->req
);
2902 static void qlt_send_term_imm_notif(struct scsi_qla_host
*vha
,
2903 struct imm_ntfy_from_isp
*imm
, int ha_locked
)
2905 unsigned long flags
= 0;
2908 if (qlt_issue_marker(vha
, ha_locked
) < 0)
2912 rc
= __qlt_send_term_imm_notif(vha
, imm
);
2916 qlt_alloc_qfull_cmd(vha
, imm
, 0, 0);
2921 spin_lock_irqsave(&vha
->hw
->hardware_lock
, flags
);
2922 rc
= __qlt_send_term_imm_notif(vha
, imm
);
2926 qlt_alloc_qfull_cmd(vha
, imm
, 0, 0);
2931 spin_unlock_irqrestore(&vha
->hw
->hardware_lock
, flags
);
2934 /* If hardware_lock held on entry, might drop it, then reaquire */
2935 /* This function sends the appropriate CTIO to ISP 2xxx or 24xx */
2936 static int __qlt_send_term_exchange(struct scsi_qla_host
*vha
,
2937 struct qla_tgt_cmd
*cmd
,
2938 struct atio_from_isp
*atio
)
2940 struct ctio7_to_24xx
*ctio24
;
2941 struct qla_hw_data
*ha
= vha
->hw
;
2946 ql_dbg(ql_dbg_tgt
, vha
, 0xe01c, "Sending TERM EXCH CTIO (ha=%p)\n", ha
);
2948 pkt
= (request_t
*)qla2x00_alloc_iocbs_ready(vha
, NULL
);
2950 ql_dbg(ql_dbg_tgt
, vha
, 0xe050,
2951 "qla_target(%d): %s failed: unable to allocate "
2952 "request packet\n", vha
->vp_idx
, __func__
);
2957 if (cmd
->state
< QLA_TGT_STATE_PROCESSED
) {
2958 ql_dbg(ql_dbg_tgt
, vha
, 0xe051,
2959 "qla_target(%d): Terminating cmd %p with "
2960 "incorrect state %d\n", vha
->vp_idx
, cmd
,
2966 pkt
->entry_count
= 1;
2967 pkt
->handle
= QLA_TGT_SKIP_HANDLE
| CTIO_COMPLETION_HANDLE_MARK
;
2969 ctio24
= (struct ctio7_to_24xx
*)pkt
;
2970 ctio24
->entry_type
= CTIO_TYPE7
;
2971 ctio24
->nport_handle
= cmd
? cmd
->loop_id
: CTIO7_NHANDLE_UNRECOGNIZED
;
2972 ctio24
->timeout
= __constant_cpu_to_le16(QLA_TGT_TIMEOUT
);
2973 ctio24
->vp_index
= vha
->vp_idx
;
2974 ctio24
->initiator_id
[0] = atio
->u
.isp24
.fcp_hdr
.s_id
[2];
2975 ctio24
->initiator_id
[1] = atio
->u
.isp24
.fcp_hdr
.s_id
[1];
2976 ctio24
->initiator_id
[2] = atio
->u
.isp24
.fcp_hdr
.s_id
[0];
2977 ctio24
->exchange_addr
= atio
->u
.isp24
.exchange_addr
;
2978 ctio24
->u
.status1
.flags
= (atio
->u
.isp24
.attr
<< 9) |
2979 __constant_cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1
|
2980 CTIO7_FLAGS_TERMINATE
);
2981 temp
= be16_to_cpu(atio
->u
.isp24
.fcp_hdr
.ox_id
);
2982 ctio24
->u
.status1
.ox_id
= cpu_to_le16(temp
);
2984 /* Most likely, it isn't needed */
2985 ctio24
->u
.status1
.residual
= get_unaligned((uint32_t *)
2986 &atio
->u
.isp24
.fcp_cmnd
.add_cdb
[
2987 atio
->u
.isp24
.fcp_cmnd
.add_cdb_len
]);
2988 if (ctio24
->u
.status1
.residual
!= 0)
2989 ctio24
->u
.status1
.scsi_status
|= SS_RESIDUAL_UNDER
;
2991 /* Memory Barrier */
2993 qla2x00_start_iocbs(vha
, vha
->req
);
2997 static void qlt_send_term_exchange(struct scsi_qla_host
*vha
,
2998 struct qla_tgt_cmd
*cmd
, struct atio_from_isp
*atio
, int ha_locked
)
3000 unsigned long flags
= 0;
3003 if (qlt_issue_marker(vha
, ha_locked
) < 0)
3007 rc
= __qlt_send_term_exchange(vha
, cmd
, atio
);
3009 qlt_alloc_qfull_cmd(vha
, atio
, 0, 0);
3012 spin_lock_irqsave(&vha
->hw
->hardware_lock
, flags
);
3013 rc
= __qlt_send_term_exchange(vha
, cmd
, atio
);
3015 qlt_alloc_qfull_cmd(vha
, atio
, 0, 0);
3018 if (cmd
&& ((cmd
->state
!= QLA_TGT_STATE_ABORTED
) ||
3019 !cmd
->cmd_sent_to_fw
)) {
3021 qlt_unmap_sg(vha
, cmd
);
3022 vha
->hw
->tgt
.tgt_ops
->free_cmd(cmd
);
3026 spin_unlock_irqrestore(&vha
->hw
->hardware_lock
, flags
);
3031 static void qlt_init_term_exchange(struct scsi_qla_host
*vha
)
3033 struct list_head free_list
;
3034 struct qla_tgt_cmd
*cmd
, *tcmd
;
3036 vha
->hw
->tgt
.leak_exchg_thresh_hold
=
3037 (vha
->hw
->fw_xcb_count
/100) * LEAK_EXCHG_THRESH_HOLD_PERCENT
;
3040 if (!list_empty(&vha
->hw
->tgt
.q_full_list
)) {
3041 INIT_LIST_HEAD(&free_list
);
3042 list_splice_init(&vha
->hw
->tgt
.q_full_list
, &free_list
);
3044 list_for_each_entry_safe(cmd
, tcmd
, &free_list
, cmd_list
) {
3045 list_del(&cmd
->cmd_list
);
3046 /* This cmd was never sent to TCM. There is no need
3047 * to schedule free or call free_cmd
3050 vha
->hw
->tgt
.num_qfull_cmds_alloc
--;
3053 vha
->hw
->tgt
.num_qfull_cmds_dropped
= 0;
3056 static void qlt_chk_exch_leak_thresh_hold(struct scsi_qla_host
*vha
)
3058 uint32_t total_leaked
;
3060 total_leaked
= vha
->hw
->tgt
.num_qfull_cmds_dropped
;
3062 if (vha
->hw
->tgt
.leak_exchg_thresh_hold
&&
3063 (total_leaked
> vha
->hw
->tgt
.leak_exchg_thresh_hold
)) {
3065 ql_dbg(ql_dbg_tgt
, vha
, 0xe079,
3066 "Chip reset due to exchange starvation: %d/%d.\n",
3067 total_leaked
, vha
->hw
->fw_xcb_count
);
3069 if (IS_P3P_TYPE(vha
->hw
))
3070 set_bit(FCOE_CTX_RESET_NEEDED
, &vha
->dpc_flags
);
3072 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
3073 qla2xxx_wake_dpc(vha
);
3078 void qlt_abort_cmd(struct qla_tgt_cmd
*cmd
)
3080 struct qla_tgt
*tgt
= cmd
->tgt
;
3081 struct scsi_qla_host
*vha
= tgt
->vha
;
3082 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
3084 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf014,
3085 "qla_target(%d): terminating exchange for aborted cmd=%p "
3086 "(se_cmd=%p, tag=%llu)", vha
->vp_idx
, cmd
, &cmd
->se_cmd
,
3089 cmd
->state
= QLA_TGT_STATE_ABORTED
;
3090 cmd
->cmd_flags
|= BIT_6
;
3092 qlt_send_term_exchange(vha
, cmd
, &cmd
->atio
, 0);
3094 EXPORT_SYMBOL(qlt_abort_cmd
);
3096 void qlt_free_cmd(struct qla_tgt_cmd
*cmd
)
3098 struct qla_tgt_sess
*sess
= cmd
->sess
;
3100 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe074,
3101 "%s: se_cmd[%p] ox_id %04x\n",
3102 __func__
, &cmd
->se_cmd
,
3103 be16_to_cpu(cmd
->atio
.u
.isp24
.fcp_hdr
.ox_id
));
3105 BUG_ON(cmd
->cmd_in_wq
);
3108 qlt_decr_num_pend_cmds(cmd
->vha
);
3110 BUG_ON(cmd
->sg_mapped
);
3111 cmd
->jiffies_at_free
= get_jiffies_64();
3112 if (unlikely(cmd
->free_sg
))
3115 if (!sess
|| !sess
->se_sess
) {
3119 cmd
->jiffies_at_free
= get_jiffies_64();
3120 percpu_ida_free(&sess
->se_sess
->sess_tag_pool
, cmd
->se_cmd
.map_tag
);
3122 EXPORT_SYMBOL(qlt_free_cmd
);
3124 /* ha->hardware_lock supposed to be held on entry */
3125 static int qlt_prepare_srr_ctio(struct scsi_qla_host
*vha
,
3126 struct qla_tgt_cmd
*cmd
, void *ctio
)
3128 struct qla_tgt_srr_ctio
*sc
;
3129 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
3130 struct qla_tgt_srr_imm
*imm
;
3133 cmd
->cmd_flags
|= BIT_15
;
3135 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf019,
3136 "qla_target(%d): CTIO with SRR status received\n", vha
->vp_idx
);
3139 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf055,
3140 "qla_target(%d): SRR CTIO, but ctio is NULL\n",
3145 sc
= kzalloc(sizeof(*sc
), GFP_ATOMIC
);
3148 /* IRQ is already OFF */
3149 spin_lock(&tgt
->srr_lock
);
3150 sc
->srr_id
= tgt
->ctio_srr_id
;
3151 list_add_tail(&sc
->srr_list_entry
,
3152 &tgt
->srr_ctio_list
);
3153 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf01a,
3154 "CTIO SRR %p added (id %d)\n", sc
, sc
->srr_id
);
3155 if (tgt
->imm_srr_id
== tgt
->ctio_srr_id
) {
3157 list_for_each_entry(imm
, &tgt
->srr_imm_list
,
3159 if (imm
->srr_id
== sc
->srr_id
) {
3165 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf01b,
3166 "Scheduling srr work\n");
3167 schedule_work(&tgt
->srr_work
);
3169 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf056,
3170 "qla_target(%d): imm_srr_id "
3171 "== ctio_srr_id (%d), but there is no "
3172 "corresponding SRR IMM, deleting CTIO "
3173 "SRR %p\n", vha
->vp_idx
,
3174 tgt
->ctio_srr_id
, sc
);
3175 list_del(&sc
->srr_list_entry
);
3176 spin_unlock(&tgt
->srr_lock
);
3182 spin_unlock(&tgt
->srr_lock
);
3184 struct qla_tgt_srr_imm
*ti
;
3186 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf057,
3187 "qla_target(%d): Unable to allocate SRR CTIO entry\n",
3189 spin_lock(&tgt
->srr_lock
);
3190 list_for_each_entry_safe(imm
, ti
, &tgt
->srr_imm_list
,
3192 if (imm
->srr_id
== tgt
->ctio_srr_id
) {
3193 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf01c,
3194 "IMM SRR %p deleted (id %d)\n",
3196 list_del(&imm
->srr_list_entry
);
3197 qlt_reject_free_srr_imm(vha
, imm
, 1);
3200 spin_unlock(&tgt
->srr_lock
);
3209 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
3211 static int qlt_term_ctio_exchange(struct scsi_qla_host
*vha
, void *ctio
,
3212 struct qla_tgt_cmd
*cmd
, uint32_t status
)
3217 struct ctio7_from_24xx
*c
= (struct ctio7_from_24xx
*)ctio
;
3219 __constant_cpu_to_le16(OF_TERM_EXCH
));
3224 qlt_send_term_exchange(vha
, cmd
, &cmd
->atio
, 1);
3229 /* ha->hardware_lock supposed to be held on entry */
3230 static inline struct qla_tgt_cmd
*qlt_get_cmd(struct scsi_qla_host
*vha
,
3233 struct qla_hw_data
*ha
= vha
->hw
;
3236 if (ha
->tgt
.cmds
[handle
] != NULL
) {
3237 struct qla_tgt_cmd
*cmd
= ha
->tgt
.cmds
[handle
];
3238 ha
->tgt
.cmds
[handle
] = NULL
;
3244 /* ha->hardware_lock supposed to be held on entry */
3245 static struct qla_tgt_cmd
*qlt_ctio_to_cmd(struct scsi_qla_host
*vha
,
3246 uint32_t handle
, void *ctio
)
3248 struct qla_tgt_cmd
*cmd
= NULL
;
3250 /* Clear out internal marks */
3251 handle
&= ~(CTIO_COMPLETION_HANDLE_MARK
|
3252 CTIO_INTERMEDIATE_HANDLE_MARK
);
3254 if (handle
!= QLA_TGT_NULL_HANDLE
) {
3255 if (unlikely(handle
== QLA_TGT_SKIP_HANDLE
))
3258 /* handle-1 is actually used */
3259 if (unlikely(handle
> DEFAULT_OUTSTANDING_COMMANDS
)) {
3260 ql_dbg(ql_dbg_tgt
, vha
, 0xe052,
3261 "qla_target(%d): Wrong handle %x received\n",
3262 vha
->vp_idx
, handle
);
3265 cmd
= qlt_get_cmd(vha
, handle
);
3266 if (unlikely(cmd
== NULL
)) {
3267 ql_dbg(ql_dbg_tgt
, vha
, 0xe053,
3268 "qla_target(%d): Suspicious: unable to "
3269 "find the command with handle %x\n", vha
->vp_idx
,
3273 } else if (ctio
!= NULL
) {
3274 /* We can't get loop ID from CTIO7 */
3275 ql_dbg(ql_dbg_tgt
, vha
, 0xe054,
3276 "qla_target(%d): Wrong CTIO received: QLA24xx doesn't "
3277 "support NULL handles\n", vha
->vp_idx
);
3284 /* hardware_lock should be held by caller. */
3286 qlt_abort_cmd_on_host_reset(struct scsi_qla_host
*vha
, struct qla_tgt_cmd
*cmd
)
3288 struct qla_hw_data
*ha
= vha
->hw
;
3292 qlt_unmap_sg(vha
, cmd
);
3294 handle
= qlt_make_handle(vha
);
3296 /* TODO: fix debug message type and ids. */
3297 if (cmd
->state
== QLA_TGT_STATE_PROCESSED
) {
3298 ql_dbg(ql_dbg_io
, vha
, 0xff00,
3299 "HOST-ABORT: handle=%d, state=PROCESSED.\n", handle
);
3300 } else if (cmd
->state
== QLA_TGT_STATE_NEED_DATA
) {
3301 cmd
->write_data_transferred
= 0;
3302 cmd
->state
= QLA_TGT_STATE_DATA_IN
;
3304 ql_dbg(ql_dbg_io
, vha
, 0xff01,
3305 "HOST-ABORT: handle=%d, state=DATA_IN.\n", handle
);
3307 ha
->tgt
.tgt_ops
->handle_data(cmd
);
3309 } else if (cmd
->state
== QLA_TGT_STATE_ABORTED
) {
3310 ql_dbg(ql_dbg_io
, vha
, 0xff02,
3311 "HOST-ABORT: handle=%d, state=ABORTED.\n", handle
);
3313 ql_dbg(ql_dbg_io
, vha
, 0xff03,
3314 "HOST-ABORT: handle=%d, state=BAD(%d).\n", handle
,
3319 cmd
->cmd_flags
|= BIT_17
;
3320 ha
->tgt
.tgt_ops
->free_cmd(cmd
);
3324 qlt_host_reset_handler(struct qla_hw_data
*ha
)
3326 struct qla_tgt_cmd
*cmd
;
3327 unsigned long flags
;
3328 scsi_qla_host_t
*base_vha
= pci_get_drvdata(ha
->pdev
);
3329 scsi_qla_host_t
*vha
= NULL
;
3330 struct qla_tgt
*tgt
= base_vha
->vha_tgt
.qla_tgt
;
3333 if (!base_vha
->hw
->tgt
.tgt_ops
)
3336 if (!tgt
|| qla_ini_mode_enabled(base_vha
)) {
3337 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf003,
3338 "Target mode disabled\n");
3342 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xff10,
3343 "HOST-ABORT-HNDLR: base_vha->dpc_flags=%lx.\n",
3344 base_vha
->dpc_flags
);
3346 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3347 for (i
= 1; i
< DEFAULT_OUTSTANDING_COMMANDS
+ 1; i
++) {
3348 cmd
= qlt_get_cmd(base_vha
, i
);
3351 /* ha->tgt.cmds entry is cleared by qlt_get_cmd. */
3353 qlt_abort_cmd_on_host_reset(vha
, cmd
);
3355 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3360 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
3362 static void qlt_do_ctio_completion(struct scsi_qla_host
*vha
, uint32_t handle
,
3363 uint32_t status
, void *ctio
)
3365 struct qla_hw_data
*ha
= vha
->hw
;
3366 struct se_cmd
*se_cmd
;
3367 const struct target_core_fabric_ops
*tfo
;
3368 struct qla_tgt_cmd
*cmd
;
3370 if (handle
& CTIO_INTERMEDIATE_HANDLE_MARK
) {
3371 /* That could happen only in case of an error/reset/abort */
3372 if (status
!= CTIO_SUCCESS
) {
3373 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf01d,
3374 "Intermediate CTIO received"
3375 " (status %x)\n", status
);
3380 cmd
= qlt_ctio_to_cmd(vha
, handle
, ctio
);
3384 se_cmd
= &cmd
->se_cmd
;
3385 tfo
= se_cmd
->se_tfo
;
3386 cmd
->cmd_sent_to_fw
= 0;
3388 qlt_unmap_sg(vha
, cmd
);
3390 if (unlikely(status
!= CTIO_SUCCESS
)) {
3391 switch (status
& 0xFFFF) {
3392 case CTIO_LIP_RESET
:
3393 case CTIO_TARGET_RESET
:
3395 /* driver request abort via Terminate exchange */
3397 case CTIO_INVALID_RX_ID
:
3399 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf058,
3400 "qla_target(%d): CTIO with "
3401 "status %#x received, state %x, se_cmd %p, "
3402 "(LIP_RESET=e, ABORTED=2, TARGET_RESET=17, "
3403 "TIMEOUT=b, INVALID_RX_ID=8)\n", vha
->vp_idx
,
3404 status
, cmd
->state
, se_cmd
);
3407 case CTIO_PORT_LOGGED_OUT
:
3408 case CTIO_PORT_UNAVAILABLE
:
3409 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf059,
3410 "qla_target(%d): CTIO with PORT LOGGED "
3411 "OUT (29) or PORT UNAVAILABLE (28) status %x "
3412 "received (state %x, se_cmd %p)\n", vha
->vp_idx
,
3413 status
, cmd
->state
, se_cmd
);
3416 case CTIO_SRR_RECEIVED
:
3417 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf05a,
3418 "qla_target(%d): CTIO with SRR_RECEIVED"
3419 " status %x received (state %x, se_cmd %p)\n",
3420 vha
->vp_idx
, status
, cmd
->state
, se_cmd
);
3421 if (qlt_prepare_srr_ctio(vha
, cmd
, ctio
) != 0)
3426 case CTIO_DIF_ERROR
: {
3427 struct ctio_crc_from_fw
*crc
=
3428 (struct ctio_crc_from_fw
*)ctio
;
3429 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf073,
3430 "qla_target(%d): CTIO with DIF_ERROR status %x received (state %x, se_cmd %p) actual_dif[0x%llx] expect_dif[0x%llx]\n",
3431 vha
->vp_idx
, status
, cmd
->state
, se_cmd
,
3432 *((u64
*)&crc
->actual_dif
[0]),
3433 *((u64
*)&crc
->expected_dif
[0]));
3435 if (qlt_handle_dif_error(vha
, cmd
, ctio
)) {
3436 if (cmd
->state
== QLA_TGT_STATE_NEED_DATA
) {
3437 /* scsi Write/xfer rdy complete */
3440 /* scsi read/xmit respond complete
3441 * call handle dif to send scsi status
3442 * rather than terminate exchange.
3444 cmd
->state
= QLA_TGT_STATE_PROCESSED
;
3445 ha
->tgt
.tgt_ops
->handle_dif_err(cmd
);
3449 /* Need to generate a SCSI good completion.
3450 * because FW did not send scsi status.
3458 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf05b,
3459 "qla_target(%d): CTIO with error status 0x%x received (state %x, se_cmd %p\n",
3460 vha
->vp_idx
, status
, cmd
->state
, se_cmd
);
3465 /* "cmd->state == QLA_TGT_STATE_ABORTED" means
3466 * cmd is already aborted/terminated, we don't
3467 * need to terminate again. The exchange is already
3468 * cleaned up/freed at FW level. Just cleanup at driver
3471 if ((cmd
->state
!= QLA_TGT_STATE_NEED_DATA
) &&
3472 (cmd
->state
!= QLA_TGT_STATE_ABORTED
)) {
3473 cmd
->cmd_flags
|= BIT_13
;
3474 if (qlt_term_ctio_exchange(vha
, ctio
, cmd
, status
))
3480 if (cmd
->state
== QLA_TGT_STATE_PROCESSED
) {
3481 cmd
->cmd_flags
|= BIT_12
;
3482 } else if (cmd
->state
== QLA_TGT_STATE_NEED_DATA
) {
3485 cmd
->state
= QLA_TGT_STATE_DATA_IN
;
3487 if (unlikely(status
!= CTIO_SUCCESS
))
3490 cmd
->write_data_transferred
= 1;
3492 ha
->tgt
.tgt_ops
->handle_data(cmd
);
3494 } else if (cmd
->state
== QLA_TGT_STATE_ABORTED
) {
3495 cmd
->cmd_flags
|= BIT_18
;
3496 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf01e,
3497 "Aborted command %p (tag %lld) finished\n", cmd
, se_cmd
->tag
);
3499 cmd
->cmd_flags
|= BIT_19
;
3500 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf05c,
3501 "qla_target(%d): A command in state (%d) should "
3502 "not return a CTIO complete\n", vha
->vp_idx
, cmd
->state
);
3505 if (unlikely(status
!= CTIO_SUCCESS
) &&
3506 (cmd
->state
!= QLA_TGT_STATE_ABORTED
)) {
3507 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf01f, "Finishing failed CTIO\n");
3511 ha
->tgt
.tgt_ops
->free_cmd(cmd
);
3514 static inline int qlt_get_fcp_task_attr(struct scsi_qla_host
*vha
,
3519 switch (task_codes
) {
3520 case ATIO_SIMPLE_QUEUE
:
3521 fcp_task_attr
= TCM_SIMPLE_TAG
;
3523 case ATIO_HEAD_OF_QUEUE
:
3524 fcp_task_attr
= TCM_HEAD_TAG
;
3526 case ATIO_ORDERED_QUEUE
:
3527 fcp_task_attr
= TCM_ORDERED_TAG
;
3529 case ATIO_ACA_QUEUE
:
3530 fcp_task_attr
= TCM_ACA_TAG
;
3533 fcp_task_attr
= TCM_SIMPLE_TAG
;
3536 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf05d,
3537 "qla_target: unknown task code %x, use ORDERED instead\n",
3539 fcp_task_attr
= TCM_ORDERED_TAG
;
3543 return fcp_task_attr
;
3546 static struct qla_tgt_sess
*qlt_make_local_sess(struct scsi_qla_host
*,
3549 * Process context for I/O path into tcm_qla2xxx code
3551 static void __qlt_do_work(struct qla_tgt_cmd
*cmd
)
3553 scsi_qla_host_t
*vha
= cmd
->vha
;
3554 struct qla_hw_data
*ha
= vha
->hw
;
3555 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
3556 struct qla_tgt_sess
*sess
= cmd
->sess
;
3557 struct atio_from_isp
*atio
= &cmd
->atio
;
3559 unsigned long flags
;
3560 uint32_t data_length
;
3561 int ret
, fcp_task_attr
, data_dir
, bidi
= 0;
3564 cmd
->cmd_flags
|= BIT_1
;
3568 if (cmd
->state
== QLA_TGT_STATE_ABORTED
) {
3569 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf082,
3570 "cmd with tag %u is aborted\n",
3571 cmd
->atio
.u
.isp24
.exchange_addr
);
3575 cdb
= &atio
->u
.isp24
.fcp_cmnd
.cdb
[0];
3576 cmd
->se_cmd
.tag
= atio
->u
.isp24
.exchange_addr
;
3577 cmd
->unpacked_lun
= scsilun_to_int(
3578 (struct scsi_lun
*)&atio
->u
.isp24
.fcp_cmnd
.lun
);
3580 if (atio
->u
.isp24
.fcp_cmnd
.rddata
&&
3581 atio
->u
.isp24
.fcp_cmnd
.wrdata
) {
3583 data_dir
= DMA_TO_DEVICE
;
3584 } else if (atio
->u
.isp24
.fcp_cmnd
.rddata
)
3585 data_dir
= DMA_FROM_DEVICE
;
3586 else if (atio
->u
.isp24
.fcp_cmnd
.wrdata
)
3587 data_dir
= DMA_TO_DEVICE
;
3589 data_dir
= DMA_NONE
;
3591 fcp_task_attr
= qlt_get_fcp_task_attr(vha
,
3592 atio
->u
.isp24
.fcp_cmnd
.task_attr
);
3593 data_length
= be32_to_cpu(get_unaligned((uint32_t *)
3594 &atio
->u
.isp24
.fcp_cmnd
.add_cdb
[
3595 atio
->u
.isp24
.fcp_cmnd
.add_cdb_len
]));
3597 ret
= ha
->tgt
.tgt_ops
->handle_cmd(vha
, cmd
, cdb
, data_length
,
3598 fcp_task_attr
, data_dir
, bidi
);
3602 * Drop extra session reference from qla_tgt_handle_cmd_for_atio*(
3604 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3605 ha
->tgt
.tgt_ops
->put_sess(sess
);
3606 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3610 ql_dbg(ql_dbg_io
, vha
, 0x3060, "Terminating work cmd %p", cmd
);
3612 * cmd has not sent to target yet, so pass NULL as the second
3613 * argument to qlt_send_term_exchange() and free the memory here.
3615 cmd
->cmd_flags
|= BIT_2
;
3616 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3617 qlt_send_term_exchange(vha
, NULL
, &cmd
->atio
, 1);
3619 qlt_decr_num_pend_cmds(vha
);
3620 percpu_ida_free(&sess
->se_sess
->sess_tag_pool
, cmd
->se_cmd
.map_tag
);
3621 ha
->tgt
.tgt_ops
->put_sess(sess
);
3622 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3625 static void qlt_do_work(struct work_struct
*work
)
3627 struct qla_tgt_cmd
*cmd
= container_of(work
, struct qla_tgt_cmd
, work
);
3628 scsi_qla_host_t
*vha
= cmd
->vha
;
3629 unsigned long flags
;
3631 spin_lock_irqsave(&vha
->cmd_list_lock
, flags
);
3632 list_del(&cmd
->cmd_list
);
3633 spin_unlock_irqrestore(&vha
->cmd_list_lock
, flags
);
3638 static struct qla_tgt_cmd
*qlt_get_tag(scsi_qla_host_t
*vha
,
3639 struct qla_tgt_sess
*sess
,
3640 struct atio_from_isp
*atio
)
3642 struct se_session
*se_sess
= sess
->se_sess
;
3643 struct qla_tgt_cmd
*cmd
;
3646 tag
= percpu_ida_alloc(&se_sess
->sess_tag_pool
, TASK_RUNNING
);
3650 cmd
= &((struct qla_tgt_cmd
*)se_sess
->sess_cmd_map
)[tag
];
3651 memset(cmd
, 0, sizeof(struct qla_tgt_cmd
));
3653 memcpy(&cmd
->atio
, atio
, sizeof(*atio
));
3654 cmd
->state
= QLA_TGT_STATE_NEW
;
3655 cmd
->tgt
= vha
->vha_tgt
.qla_tgt
;
3656 qlt_incr_num_pend_cmds(vha
);
3658 cmd
->se_cmd
.map_tag
= tag
;
3660 cmd
->loop_id
= sess
->loop_id
;
3661 cmd
->conf_compl_supported
= sess
->conf_compl_supported
;
3664 cmd
->jiffies_at_alloc
= get_jiffies_64();
3666 cmd
->reset_count
= vha
->hw
->chip_reset
;
3671 static void qlt_send_busy(struct scsi_qla_host
*, struct atio_from_isp
*,
3674 static void qlt_create_sess_from_atio(struct work_struct
*work
)
3676 struct qla_tgt_sess_op
*op
= container_of(work
,
3677 struct qla_tgt_sess_op
, work
);
3678 scsi_qla_host_t
*vha
= op
->vha
;
3679 struct qla_hw_data
*ha
= vha
->hw
;
3680 struct qla_tgt_sess
*sess
;
3681 struct qla_tgt_cmd
*cmd
;
3682 unsigned long flags
;
3683 uint8_t *s_id
= op
->atio
.u
.isp24
.fcp_hdr
.s_id
;
3685 spin_lock_irqsave(&vha
->cmd_list_lock
, flags
);
3686 list_del(&op
->cmd_list
);
3687 spin_unlock_irqrestore(&vha
->cmd_list_lock
, flags
);
3690 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf083,
3691 "sess_op with tag %u is aborted\n",
3692 op
->atio
.u
.isp24
.exchange_addr
);
3696 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf022,
3697 "qla_target(%d): Unable to find wwn login"
3698 " (s_id %x:%x:%x), trying to create it manually\n",
3699 vha
->vp_idx
, s_id
[0], s_id
[1], s_id
[2]);
3701 if (op
->atio
.u
.raw
.entry_count
> 1) {
3702 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf023,
3703 "Dropping multy entry atio %p\n", &op
->atio
);
3707 mutex_lock(&vha
->vha_tgt
.tgt_mutex
);
3708 sess
= qlt_make_local_sess(vha
, s_id
);
3709 /* sess has an extra creation ref. */
3710 mutex_unlock(&vha
->vha_tgt
.tgt_mutex
);
3715 * Now obtain a pre-allocated session tag using the original op->atio
3716 * packet header, and dispatch into __qlt_do_work() using the existing
3719 cmd
= qlt_get_tag(vha
, sess
, &op
->atio
);
3721 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3722 qlt_send_busy(vha
, &op
->atio
, SAM_STAT_BUSY
);
3723 ha
->tgt
.tgt_ops
->put_sess(sess
);
3724 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3729 * __qlt_do_work() will call ha->tgt.tgt_ops->put_sess() to release
3730 * the extra reference taken above by qlt_make_local_sess()
3737 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3738 qlt_send_term_exchange(vha
, NULL
, &op
->atio
, 1);
3739 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3744 /* ha->hardware_lock supposed to be held on entry */
3745 static int qlt_handle_cmd_for_atio(struct scsi_qla_host
*vha
,
3746 struct atio_from_isp
*atio
)
3748 struct qla_hw_data
*ha
= vha
->hw
;
3749 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
3750 struct qla_tgt_sess
*sess
;
3751 struct qla_tgt_cmd
*cmd
;
3753 if (unlikely(tgt
->tgt_stop
)) {
3754 ql_dbg(ql_dbg_io
, vha
, 0x3061,
3755 "New command while device %p is shutting down\n", tgt
);
3759 sess
= ha
->tgt
.tgt_ops
->find_sess_by_s_id(vha
, atio
->u
.isp24
.fcp_hdr
.s_id
);
3760 if (unlikely(!sess
)) {
3761 struct qla_tgt_sess_op
*op
= kzalloc(sizeof(struct qla_tgt_sess_op
),
3766 memcpy(&op
->atio
, atio
, sizeof(*atio
));
3769 spin_lock(&vha
->cmd_list_lock
);
3770 list_add_tail(&op
->cmd_list
, &vha
->qla_sess_op_cmd_list
);
3771 spin_unlock(&vha
->cmd_list_lock
);
3773 INIT_WORK(&op
->work
, qlt_create_sess_from_atio
);
3774 queue_work(qla_tgt_wq
, &op
->work
);
3778 /* Another WWN used to have our s_id. Our PLOGI scheduled its
3779 * session deletion, but it's still in sess_del_work wq */
3780 if (sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
) {
3781 ql_dbg(ql_dbg_io
, vha
, 0x3061,
3782 "New command while old session %p is being deleted\n",
3788 * Do kref_get() before returning + dropping qla_hw_data->hardware_lock.
3790 kref_get(&sess
->se_sess
->sess_kref
);
3792 cmd
= qlt_get_tag(vha
, sess
, atio
);
3794 ql_dbg(ql_dbg_io
, vha
, 0x3062,
3795 "qla_target(%d): Allocation of cmd failed\n", vha
->vp_idx
);
3796 ha
->tgt
.tgt_ops
->put_sess(sess
);
3801 cmd
->cmd_flags
|= BIT_0
;
3803 spin_lock(&vha
->cmd_list_lock
);
3804 list_add_tail(&cmd
->cmd_list
, &vha
->qla_cmd_list
);
3805 spin_unlock(&vha
->cmd_list_lock
);
3807 INIT_WORK(&cmd
->work
, qlt_do_work
);
3808 queue_work(qla_tgt_wq
, &cmd
->work
);
3813 /* ha->hardware_lock supposed to be held on entry */
3814 static int qlt_issue_task_mgmt(struct qla_tgt_sess
*sess
, uint32_t lun
,
3815 int fn
, void *iocb
, int flags
)
3817 struct scsi_qla_host
*vha
= sess
->vha
;
3818 struct qla_hw_data
*ha
= vha
->hw
;
3819 struct qla_tgt_mgmt_cmd
*mcmd
;
3820 struct atio_from_isp
*a
= (struct atio_from_isp
*)iocb
;
3824 mcmd
= mempool_alloc(qla_tgt_mgmt_cmd_mempool
, GFP_ATOMIC
);
3826 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10009,
3827 "qla_target(%d): Allocation of management "
3828 "command failed, some commands and their data could "
3829 "leak\n", vha
->vp_idx
);
3832 memset(mcmd
, 0, sizeof(*mcmd
));
3836 memcpy(&mcmd
->orig_iocb
.imm_ntfy
, iocb
,
3837 sizeof(mcmd
->orig_iocb
.imm_ntfy
));
3839 mcmd
->tmr_func
= fn
;
3840 mcmd
->flags
= flags
;
3841 mcmd
->reset_count
= vha
->hw
->chip_reset
;
3844 case QLA_TGT_CLEAR_ACA
:
3845 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10000,
3846 "qla_target(%d): CLEAR_ACA received\n", sess
->vha
->vp_idx
);
3847 tmr_func
= TMR_CLEAR_ACA
;
3850 case QLA_TGT_TARGET_RESET
:
3851 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10001,
3852 "qla_target(%d): TARGET_RESET received\n",
3854 tmr_func
= TMR_TARGET_WARM_RESET
;
3857 case QLA_TGT_LUN_RESET
:
3858 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10002,
3859 "qla_target(%d): LUN_RESET received\n", sess
->vha
->vp_idx
);
3860 tmr_func
= TMR_LUN_RESET
;
3861 abort_cmds_for_lun(vha
, lun
, a
->u
.isp24
.fcp_hdr
.s_id
);
3864 case QLA_TGT_CLEAR_TS
:
3865 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10003,
3866 "qla_target(%d): CLEAR_TS received\n", sess
->vha
->vp_idx
);
3867 tmr_func
= TMR_CLEAR_TASK_SET
;
3870 case QLA_TGT_ABORT_TS
:
3871 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10004,
3872 "qla_target(%d): ABORT_TS received\n", sess
->vha
->vp_idx
);
3873 tmr_func
= TMR_ABORT_TASK_SET
;
3876 case QLA_TGT_ABORT_ALL
:
3877 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10005,
3878 "qla_target(%d): Doing ABORT_ALL_TASKS\n",
3883 case QLA_TGT_ABORT_ALL_SESS
:
3884 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10006,
3885 "qla_target(%d): Doing ABORT_ALL_TASKS_SESS\n",
3890 case QLA_TGT_NEXUS_LOSS_SESS
:
3891 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10007,
3892 "qla_target(%d): Doing NEXUS_LOSS_SESS\n",
3897 case QLA_TGT_NEXUS_LOSS
:
3898 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x10008,
3899 "qla_target(%d): Doing NEXUS_LOSS\n", sess
->vha
->vp_idx
);
3904 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x1000a,
3905 "qla_target(%d): Unknown task mgmt fn 0x%x\n",
3906 sess
->vha
->vp_idx
, fn
);
3907 mempool_free(mcmd
, qla_tgt_mgmt_cmd_mempool
);
3911 res
= ha
->tgt
.tgt_ops
->handle_tmr(mcmd
, lun
, tmr_func
, 0);
3913 ql_dbg(ql_dbg_tgt_tmr
, vha
, 0x1000b,
3914 "qla_target(%d): tgt.tgt_ops->handle_tmr() failed: %d\n",
3915 sess
->vha
->vp_idx
, res
);
3916 mempool_free(mcmd
, qla_tgt_mgmt_cmd_mempool
);
3923 /* ha->hardware_lock supposed to be held on entry */
3924 static int qlt_handle_task_mgmt(struct scsi_qla_host
*vha
, void *iocb
)
3926 struct atio_from_isp
*a
= (struct atio_from_isp
*)iocb
;
3927 struct qla_hw_data
*ha
= vha
->hw
;
3928 struct qla_tgt
*tgt
;
3929 struct qla_tgt_sess
*sess
;
3930 uint32_t lun
, unpacked_lun
;
3933 tgt
= vha
->vha_tgt
.qla_tgt
;
3935 lun
= a
->u
.isp24
.fcp_cmnd
.lun
;
3936 lun_size
= sizeof(a
->u
.isp24
.fcp_cmnd
.lun
);
3937 fn
= a
->u
.isp24
.fcp_cmnd
.task_mgmt_flags
;
3938 sess
= ha
->tgt
.tgt_ops
->find_sess_by_s_id(vha
,
3939 a
->u
.isp24
.fcp_hdr
.s_id
);
3940 unpacked_lun
= scsilun_to_int((struct scsi_lun
*)&lun
);
3943 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf024,
3944 "qla_target(%d): task mgmt fn 0x%x for "
3945 "non-existant session\n", vha
->vp_idx
, fn
);
3946 return qlt_sched_sess_work(tgt
, QLA_TGT_SESS_WORK_TM
, iocb
,
3947 sizeof(struct atio_from_isp
));
3950 if (sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
)
3953 return qlt_issue_task_mgmt(sess
, unpacked_lun
, fn
, iocb
, 0);
3956 /* ha->hardware_lock supposed to be held on entry */
3957 static int __qlt_abort_task(struct scsi_qla_host
*vha
,
3958 struct imm_ntfy_from_isp
*iocb
, struct qla_tgt_sess
*sess
)
3960 struct atio_from_isp
*a
= (struct atio_from_isp
*)iocb
;
3961 struct qla_hw_data
*ha
= vha
->hw
;
3962 struct qla_tgt_mgmt_cmd
*mcmd
;
3963 uint32_t lun
, unpacked_lun
;
3966 mcmd
= mempool_alloc(qla_tgt_mgmt_cmd_mempool
, GFP_ATOMIC
);
3968 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf05f,
3969 "qla_target(%d): %s: Allocation of ABORT cmd failed\n",
3970 vha
->vp_idx
, __func__
);
3973 memset(mcmd
, 0, sizeof(*mcmd
));
3976 memcpy(&mcmd
->orig_iocb
.imm_ntfy
, iocb
,
3977 sizeof(mcmd
->orig_iocb
.imm_ntfy
));
3979 lun
= a
->u
.isp24
.fcp_cmnd
.lun
;
3980 unpacked_lun
= scsilun_to_int((struct scsi_lun
*)&lun
);
3981 mcmd
->reset_count
= vha
->hw
->chip_reset
;
3983 rc
= ha
->tgt
.tgt_ops
->handle_tmr(mcmd
, unpacked_lun
, TMR_ABORT_TASK
,
3984 le16_to_cpu(iocb
->u
.isp2x
.seq_id
));
3986 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf060,
3987 "qla_target(%d): tgt_ops->handle_tmr() failed: %d\n",
3989 mempool_free(mcmd
, qla_tgt_mgmt_cmd_mempool
);
3996 /* ha->hardware_lock supposed to be held on entry */
3997 static int qlt_abort_task(struct scsi_qla_host
*vha
,
3998 struct imm_ntfy_from_isp
*iocb
)
4000 struct qla_hw_data
*ha
= vha
->hw
;
4001 struct qla_tgt_sess
*sess
;
4004 loop_id
= GET_TARGET_ID(ha
, (struct atio_from_isp
*)iocb
);
4006 sess
= ha
->tgt
.tgt_ops
->find_sess_by_loop_id(vha
, loop_id
);
4008 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf025,
4009 "qla_target(%d): task abort for unexisting "
4010 "session\n", vha
->vp_idx
);
4011 return qlt_sched_sess_work(vha
->vha_tgt
.qla_tgt
,
4012 QLA_TGT_SESS_WORK_ABORT
, iocb
, sizeof(*iocb
));
4015 return __qlt_abort_task(vha
, iocb
, sess
);
4018 void qlt_logo_completion_handler(fc_port_t
*fcport
, int rc
)
4020 if (fcport
->tgt_session
) {
4021 if (rc
!= MBS_COMMAND_COMPLETE
) {
4022 ql_dbg(ql_dbg_tgt_mgt
, fcport
->vha
, 0xf093,
4023 "%s: se_sess %p / sess %p from"
4024 " port %8phC loop_id %#04x s_id %02x:%02x:%02x"
4025 " LOGO failed: %#x\n",
4027 fcport
->tgt_session
->se_sess
,
4028 fcport
->tgt_session
,
4029 fcport
->port_name
, fcport
->loop_id
,
4030 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
4031 fcport
->d_id
.b
.al_pa
, rc
);
4034 fcport
->tgt_session
->logout_completed
= 1;
4038 static void qlt_swap_imm_ntfy_iocb(struct imm_ntfy_from_isp
*a
,
4039 struct imm_ntfy_from_isp
*b
)
4041 struct imm_ntfy_from_isp tmp
;
4042 memcpy(&tmp
, a
, sizeof(struct imm_ntfy_from_isp
));
4043 memcpy(a
, b
, sizeof(struct imm_ntfy_from_isp
));
4044 memcpy(b
, &tmp
, sizeof(struct imm_ntfy_from_isp
));
4048 * ha->hardware_lock supposed to be held on entry (to protect tgt->sess_list)
4050 * Schedules sessions with matching port_id/loop_id but different wwn for
4051 * deletion. Returns existing session with matching wwn if present.
4054 static struct qla_tgt_sess
*
4055 qlt_find_sess_invalidate_other(struct qla_tgt
*tgt
, uint64_t wwn
,
4056 port_id_t port_id
, uint16_t loop_id
)
4058 struct qla_tgt_sess
*sess
= NULL
, *other_sess
;
4061 list_for_each_entry(other_sess
, &tgt
->sess_list
, sess_list_entry
) {
4063 other_wwn
= wwn_to_u64(other_sess
->port_name
);
4065 if (wwn
== other_wwn
) {
4071 /* find other sess with nport_id collision */
4072 if (port_id
.b24
== other_sess
->s_id
.b24
) {
4073 if (loop_id
!= other_sess
->loop_id
) {
4074 ql_dbg(ql_dbg_tgt_tmr
, tgt
->vha
, 0x1000c,
4075 "Invalidating sess %p loop_id %d wwn %llx.\n",
4076 other_sess
, other_sess
->loop_id
, other_wwn
);
4079 * logout_on_delete is set by default, but another
4080 * session that has the same s_id/loop_id combo
4081 * might have cleared it when requested this session
4082 * deletion, so don't touch it
4084 qlt_schedule_sess_for_deletion(other_sess
, true);
4087 * Another wwn used to have our s_id/loop_id
4088 * combo - kill the session, but don't log out
4090 sess
->logout_on_delete
= 0;
4091 qlt_schedule_sess_for_deletion(other_sess
,
4097 /* find other sess with nport handle collision */
4098 if (loop_id
== other_sess
->loop_id
) {
4099 ql_dbg(ql_dbg_tgt_tmr
, tgt
->vha
, 0x1000d,
4100 "Invalidating sess %p loop_id %d wwn %llx.\n",
4101 other_sess
, other_sess
->loop_id
, other_wwn
);
4103 /* Same loop_id but different s_id
4104 * Ok to kill and logout */
4105 qlt_schedule_sess_for_deletion(other_sess
, true);
4112 /* Abort any commands for this s_id waiting on qla_tgt_wq workqueue */
4113 static int abort_cmds_for_s_id(struct scsi_qla_host
*vha
, port_id_t
*s_id
)
4115 struct qla_tgt_sess_op
*op
;
4116 struct qla_tgt_cmd
*cmd
;
4120 key
= (((u32
)s_id
->b
.domain
<< 16) |
4121 ((u32
)s_id
->b
.area
<< 8) |
4122 ((u32
)s_id
->b
.al_pa
));
4124 spin_lock(&vha
->cmd_list_lock
);
4125 list_for_each_entry(op
, &vha
->qla_sess_op_cmd_list
, cmd_list
) {
4126 uint32_t op_key
= sid_to_key(op
->atio
.u
.isp24
.fcp_hdr
.s_id
);
4127 if (op_key
== key
) {
4132 list_for_each_entry(cmd
, &vha
->qla_cmd_list
, cmd_list
) {
4133 uint32_t cmd_key
= sid_to_key(cmd
->atio
.u
.isp24
.fcp_hdr
.s_id
);
4134 if (cmd_key
== key
) {
4135 cmd
->state
= QLA_TGT_STATE_ABORTED
;
4139 spin_unlock(&vha
->cmd_list_lock
);
4145 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
4147 static int qlt_24xx_handle_els(struct scsi_qla_host
*vha
,
4148 struct imm_ntfy_from_isp
*iocb
)
4150 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
4151 struct qla_hw_data
*ha
= vha
->hw
;
4152 struct qla_tgt_sess
*sess
= NULL
;
4159 wwn
= wwn_to_u64(iocb
->u
.isp24
.port_name
);
4161 port_id
.b
.domain
= iocb
->u
.isp24
.port_id
[2];
4162 port_id
.b
.area
= iocb
->u
.isp24
.port_id
[1];
4163 port_id
.b
.al_pa
= iocb
->u
.isp24
.port_id
[0];
4164 port_id
.b
.rsvd_1
= 0;
4166 loop_id
= le16_to_cpu(iocb
->u
.isp24
.nport_handle
);
4168 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf026,
4169 "qla_target(%d): Port ID: 0x%3phC ELS opcode: 0x%02x\n",
4170 vha
->vp_idx
, iocb
->u
.isp24
.port_id
, iocb
->u
.isp24
.status_subcode
);
4172 /* res = 1 means ack at the end of thread
4173 * res = 0 means ack async/later.
4175 switch (iocb
->u
.isp24
.status_subcode
) {
4178 /* Mark all stale commands in qla_tgt_wq for deletion */
4179 abort_cmds_for_s_id(vha
, &port_id
);
4182 sess
= qlt_find_sess_invalidate_other(tgt
, wwn
,
4185 if (!sess
|| IS_SW_RESV_ADDR(sess
->s_id
)) {
4190 if (sess
->plogi_ack_needed
) {
4192 * Initiator sent another PLOGI before last PLOGI could
4193 * finish. Swap plogi iocbs and terminate old one
4194 * without acking, new one will get acked when session
4195 * deletion completes.
4197 ql_log(ql_log_warn
, sess
->vha
, 0xf094,
4198 "sess %p received double plogi.\n", sess
);
4200 qlt_swap_imm_ntfy_iocb(iocb
, &sess
->tm_iocb
);
4202 qlt_send_term_imm_notif(vha
, iocb
, 1);
4211 * Save immediate Notif IOCB for Ack when sess is done
4212 * and being deleted.
4214 memcpy(&sess
->tm_iocb
, iocb
, sizeof(sess
->tm_iocb
));
4215 sess
->plogi_ack_needed
= 1;
4218 * Under normal circumstances we want to release nport handle
4219 * during LOGO process to avoid nport handle leaks inside FW.
4220 * The exception is when LOGO is done while another PLOGI with
4221 * the same nport handle is waiting as might be the case here.
4222 * Note: there is always a possibily of a race where session
4223 * deletion has already started for other reasons (e.g. ACL
4224 * removal) and now PLOGI arrives:
4225 * 1. if PLOGI arrived in FW after nport handle has been freed,
4226 * FW must have assigned this PLOGI a new/same handle and we
4227 * can proceed ACK'ing it as usual when session deletion
4229 * 2. if PLOGI arrived in FW before LOGO with LCF_FREE_NPORT
4230 * bit reached it, the handle has now been released. We'll
4231 * get an error when we ACK this PLOGI. Nothing will be sent
4232 * back to initiator. Initiator should eventually retry
4233 * PLOGI and situation will correct itself.
4235 sess
->keep_nport_handle
= ((sess
->loop_id
== loop_id
) &&
4236 (sess
->s_id
.b24
== port_id
.b24
));
4237 qlt_schedule_sess_for_deletion(sess
, true);
4241 wd3_lo
= le16_to_cpu(iocb
->u
.isp24
.u
.prli
.wd3_lo
);
4244 sess
= qlt_find_sess_invalidate_other(tgt
, wwn
, port_id
,
4248 if (sess
->deleted
) {
4250 * Impatient initiator sent PRLI before last
4251 * PLOGI could finish. Will force him to re-try,
4252 * while last one finishes.
4254 ql_log(ql_log_warn
, sess
->vha
, 0xf095,
4255 "sess %p PRLI received, before plogi ack.\n",
4257 qlt_send_term_imm_notif(vha
, iocb
, 1);
4263 * This shouldn't happen under normal circumstances,
4264 * since we have deleted the old session during PLOGI
4266 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf096,
4267 "PRLI (loop_id %#04x) for existing sess %p (loop_id %#04x)\n",
4268 sess
->loop_id
, sess
, iocb
->u
.isp24
.nport_handle
);
4271 sess
->loop_id
= loop_id
;
4272 sess
->s_id
= port_id
;
4275 sess
->conf_compl_supported
= 1;
4278 res
= 1; /* send notify ack */
4280 /* Make session global (not used in fabric mode) */
4281 if (ha
->current_topology
!= ISP_CFG_F
) {
4282 set_bit(LOOP_RESYNC_NEEDED
, &vha
->dpc_flags
);
4283 set_bit(LOCAL_LOOP_UPDATE
, &vha
->dpc_flags
);
4284 qla2xxx_wake_dpc(vha
);
4286 /* todo: else - create sess here. */
4287 res
= 1; /* send notify ack */
4294 res
= qlt_reset(vha
, iocb
, QLA_TGT_NEXUS_LOSS_SESS
);
4299 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
4300 if (tgt
->link_reinit_iocb_pending
) {
4301 qlt_send_notify_ack(vha
, &tgt
->link_reinit_iocb
,
4303 tgt
->link_reinit_iocb_pending
= 0;
4305 res
= 1; /* send notify ack */
4309 case ELS_FLOGI
: /* should never happen */
4311 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf061,
4312 "qla_target(%d): Unsupported ELS command %x "
4313 "received\n", vha
->vp_idx
, iocb
->u
.isp24
.status_subcode
);
4314 res
= qlt_reset(vha
, iocb
, QLA_TGT_NEXUS_LOSS_SESS
);
4321 static int qlt_set_data_offset(struct qla_tgt_cmd
*cmd
, uint32_t offset
)
4325 * FIXME: Reject non zero SRR relative offset until we can test
4326 * this code properly.
4328 pr_debug("Rejecting non zero SRR rel_offs: %u\n", offset
);
4331 struct scatterlist
*sg
, *sgp
, *sg_srr
, *sg_srr_start
= NULL
;
4332 size_t first_offset
= 0, rem_offset
= offset
, tmp
= 0;
4333 int i
, sg_srr_cnt
, bufflen
= 0;
4335 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe023,
4336 "Entering qla_tgt_set_data_offset: cmd: %p, cmd->sg: %p, "
4337 "cmd->sg_cnt: %u, direction: %d\n",
4338 cmd
, cmd
->sg
, cmd
->sg_cnt
, cmd
->dma_data_direction
);
4340 if (!cmd
->sg
|| !cmd
->sg_cnt
) {
4341 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe055,
4342 "Missing cmd->sg or zero cmd->sg_cnt in"
4343 " qla_tgt_set_data_offset\n");
4347 * Walk the current cmd->sg list until we locate the new sg_srr_start
4349 for_each_sg(cmd
->sg
, sg
, cmd
->sg_cnt
, i
) {
4350 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe024,
4351 "sg[%d]: %p page: %p, length: %d, offset: %d\n",
4352 i
, sg
, sg_page(sg
), sg
->length
, sg
->offset
);
4354 if ((sg
->length
+ tmp
) > offset
) {
4355 first_offset
= rem_offset
;
4357 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe025,
4358 "Found matching sg[%d], using %p as sg_srr_start, "
4359 "and using first_offset: %zu\n", i
, sg
,
4364 rem_offset
-= sg
->length
;
4367 if (!sg_srr_start
) {
4368 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe056,
4369 "Unable to locate sg_srr_start for offset: %u\n", offset
);
4372 sg_srr_cnt
= (cmd
->sg_cnt
- i
);
4374 sg_srr
= kzalloc(sizeof(struct scatterlist
) * sg_srr_cnt
, GFP_KERNEL
);
4376 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe057,
4377 "Unable to allocate sgp\n");
4380 sg_init_table(sg_srr
, sg_srr_cnt
);
4383 * Walk the remaining list for sg_srr_start, mapping to the newly
4384 * allocated sg_srr taking first_offset into account.
4386 for_each_sg(sg_srr_start
, sg
, sg_srr_cnt
, i
) {
4388 sg_set_page(sgp
, sg_page(sg
),
4389 (sg
->length
- first_offset
), first_offset
);
4392 sg_set_page(sgp
, sg_page(sg
), sg
->length
, 0);
4394 bufflen
+= sgp
->length
;
4402 cmd
->sg_cnt
= sg_srr_cnt
;
4403 cmd
->bufflen
= bufflen
;
4404 cmd
->offset
+= offset
;
4407 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe026, "New cmd->sg: %p\n", cmd
->sg
);
4408 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe027, "New cmd->sg_cnt: %u\n",
4410 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe028, "New cmd->bufflen: %u\n",
4412 ql_dbg(ql_dbg_tgt
, cmd
->vha
, 0xe029, "New cmd->offset: %u\n",
4415 if (cmd
->sg_cnt
< 0)
4418 if (cmd
->bufflen
< 0)
4425 static inline int qlt_srr_adjust_data(struct qla_tgt_cmd
*cmd
,
4426 uint32_t srr_rel_offs
, int *xmit_type
)
4428 int res
= 0, rel_offs
;
4430 rel_offs
= srr_rel_offs
- cmd
->offset
;
4431 ql_dbg(ql_dbg_tgt_mgt
, cmd
->vha
, 0xf027, "srr_rel_offs=%d, rel_offs=%d",
4432 srr_rel_offs
, rel_offs
);
4434 *xmit_type
= QLA_TGT_XMIT_ALL
;
4437 ql_dbg(ql_dbg_tgt_mgt
, cmd
->vha
, 0xf062,
4438 "qla_target(%d): SRR rel_offs (%d) < 0",
4439 cmd
->vha
->vp_idx
, rel_offs
);
4441 } else if (rel_offs
== cmd
->bufflen
)
4442 *xmit_type
= QLA_TGT_XMIT_STATUS
;
4443 else if (rel_offs
> 0)
4444 res
= qlt_set_data_offset(cmd
, rel_offs
);
4449 /* No locks, thread context */
4450 static void qlt_handle_srr(struct scsi_qla_host
*vha
,
4451 struct qla_tgt_srr_ctio
*sctio
, struct qla_tgt_srr_imm
*imm
)
4453 struct imm_ntfy_from_isp
*ntfy
=
4454 (struct imm_ntfy_from_isp
*)&imm
->imm_ntfy
;
4455 struct qla_hw_data
*ha
= vha
->hw
;
4456 struct qla_tgt_cmd
*cmd
= sctio
->cmd
;
4457 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
4458 unsigned long flags
;
4459 int xmit_type
= 0, resp
= 0;
4463 offset
= le32_to_cpu(ntfy
->u
.isp24
.srr_rel_offs
);
4464 srr_ui
= ntfy
->u
.isp24
.srr_ui
;
4466 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf028, "SRR cmd %p, srr_ui %x\n",
4471 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
4472 qlt_send_notify_ack(vha
, ntfy
,
4473 0, 0, 0, NOTIFY_ACK_SRR_FLAGS_ACCEPT
, 0, 0);
4474 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
4475 xmit_type
= QLA_TGT_XMIT_STATUS
;
4478 case SRR_IU_DATA_IN
:
4479 if (!cmd
->sg
|| !cmd
->sg_cnt
) {
4480 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf063,
4481 "Unable to process SRR_IU_DATA_IN due to"
4482 " missing cmd->sg, state: %d\n", cmd
->state
);
4486 if (se_cmd
->scsi_status
!= 0) {
4487 ql_dbg(ql_dbg_tgt
, vha
, 0xe02a,
4488 "Rejecting SRR_IU_DATA_IN with non GOOD "
4492 cmd
->bufflen
= se_cmd
->data_length
;
4494 if (qlt_has_data(cmd
)) {
4495 if (qlt_srr_adjust_data(cmd
, offset
, &xmit_type
) != 0)
4497 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
4498 qlt_send_notify_ack(vha
, ntfy
,
4499 0, 0, 0, NOTIFY_ACK_SRR_FLAGS_ACCEPT
, 0, 0);
4500 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
4503 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf064,
4504 "qla_target(%d): SRR for in data for cmd without them (tag %lld, SCSI status %d), reject",
4505 vha
->vp_idx
, se_cmd
->tag
,
4506 cmd
->se_cmd
.scsi_status
);
4510 case SRR_IU_DATA_OUT
:
4511 if (!cmd
->sg
|| !cmd
->sg_cnt
) {
4512 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf065,
4513 "Unable to process SRR_IU_DATA_OUT due to"
4514 " missing cmd->sg\n");
4518 if (se_cmd
->scsi_status
!= 0) {
4519 ql_dbg(ql_dbg_tgt
, vha
, 0xe02b,
4520 "Rejecting SRR_IU_DATA_OUT"
4521 " with non GOOD scsi_status\n");
4524 cmd
->bufflen
= se_cmd
->data_length
;
4526 if (qlt_has_data(cmd
)) {
4527 if (qlt_srr_adjust_data(cmd
, offset
, &xmit_type
) != 0)
4529 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
4530 qlt_send_notify_ack(vha
, ntfy
,
4531 0, 0, 0, NOTIFY_ACK_SRR_FLAGS_ACCEPT
, 0, 0);
4532 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
4533 if (xmit_type
& QLA_TGT_XMIT_DATA
) {
4534 cmd
->cmd_flags
|= BIT_8
;
4535 qlt_rdy_to_xfer(cmd
);
4538 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf066,
4539 "qla_target(%d): SRR for out data for cmd without them (tag %lld, SCSI status %d), reject",
4540 vha
->vp_idx
, se_cmd
->tag
, cmd
->se_cmd
.scsi_status
);
4545 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf067,
4546 "qla_target(%d): Unknown srr_ui value %x",
4547 vha
->vp_idx
, srr_ui
);
4551 /* Transmit response in case of status and data-in cases */
4553 cmd
->cmd_flags
|= BIT_7
;
4554 qlt_xmit_response(cmd
, xmit_type
, se_cmd
->scsi_status
);
4560 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
4561 qlt_send_notify_ack(vha
, ntfy
, 0, 0, 0,
4562 NOTIFY_ACK_SRR_FLAGS_REJECT
,
4563 NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM
,
4564 NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL
);
4565 if (cmd
->state
== QLA_TGT_STATE_NEED_DATA
) {
4566 cmd
->state
= QLA_TGT_STATE_DATA_IN
;
4569 cmd
->cmd_flags
|= BIT_9
;
4570 qlt_send_term_exchange(vha
, cmd
, &cmd
->atio
, 1);
4572 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
4575 static void qlt_reject_free_srr_imm(struct scsi_qla_host
*vha
,
4576 struct qla_tgt_srr_imm
*imm
, int ha_locked
)
4578 struct qla_hw_data
*ha
= vha
->hw
;
4579 unsigned long flags
= 0;
4582 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
4584 qlt_send_notify_ack(vha
, (void *)&imm
->imm_ntfy
, 0, 0, 0,
4585 NOTIFY_ACK_SRR_FLAGS_REJECT
,
4586 NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM
,
4587 NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL
);
4590 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
4595 static void qlt_handle_srr_work(struct work_struct
*work
)
4597 struct qla_tgt
*tgt
= container_of(work
, struct qla_tgt
, srr_work
);
4598 struct scsi_qla_host
*vha
= tgt
->vha
;
4599 struct qla_tgt_srr_ctio
*sctio
;
4600 unsigned long flags
;
4602 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf029, "Entering SRR work (tgt %p)\n",
4606 spin_lock_irqsave(&tgt
->srr_lock
, flags
);
4607 list_for_each_entry(sctio
, &tgt
->srr_ctio_list
, srr_list_entry
) {
4608 struct qla_tgt_srr_imm
*imm
, *i
, *ti
;
4609 struct qla_tgt_cmd
*cmd
;
4610 struct se_cmd
*se_cmd
;
4613 list_for_each_entry_safe(i
, ti
, &tgt
->srr_imm_list
,
4615 if (i
->srr_id
== sctio
->srr_id
) {
4616 list_del(&i
->srr_list_entry
);
4618 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf068,
4619 "qla_target(%d): There must be "
4620 "only one IMM SRR per CTIO SRR "
4621 "(IMM SRR %p, id %d, CTIO %p\n",
4622 vha
->vp_idx
, i
, i
->srr_id
, sctio
);
4623 qlt_reject_free_srr_imm(tgt
->vha
, i
, 0);
4629 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf02a,
4630 "IMM SRR %p, CTIO SRR %p (id %d)\n", imm
, sctio
,
4634 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf02b,
4635 "Not found matching IMM for SRR CTIO (id %d)\n",
4639 list_del(&sctio
->srr_list_entry
);
4641 spin_unlock_irqrestore(&tgt
->srr_lock
, flags
);
4645 * Reset qla_tgt_cmd SRR values and SGL pointer+count to follow
4646 * tcm_qla2xxx_write_pending() and tcm_qla2xxx_queue_data_in()
4655 se_cmd
= &cmd
->se_cmd
;
4657 cmd
->sg_cnt
= se_cmd
->t_data_nents
;
4658 cmd
->sg
= se_cmd
->t_data_sg
;
4660 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf02c,
4661 "SRR cmd %p (se_cmd %p, tag %lld, op %x), sg_cnt=%d, offset=%d",
4662 cmd
, &cmd
->se_cmd
, se_cmd
->tag
, se_cmd
->t_task_cdb
?
4663 se_cmd
->t_task_cdb
[0] : 0, cmd
->sg_cnt
, cmd
->offset
);
4665 qlt_handle_srr(vha
, sctio
, imm
);
4671 spin_unlock_irqrestore(&tgt
->srr_lock
, flags
);
4674 /* ha->hardware_lock supposed to be held on entry */
4675 static void qlt_prepare_srr_imm(struct scsi_qla_host
*vha
,
4676 struct imm_ntfy_from_isp
*iocb
)
4678 struct qla_tgt_srr_imm
*imm
;
4679 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
4680 struct qla_tgt_srr_ctio
*sctio
;
4684 ql_log(ql_log_warn
, vha
, 0xf02d, "qla_target(%d): SRR received\n",
4687 imm
= kzalloc(sizeof(*imm
), GFP_ATOMIC
);
4689 memcpy(&imm
->imm_ntfy
, iocb
, sizeof(imm
->imm_ntfy
));
4691 /* IRQ is already OFF */
4692 spin_lock(&tgt
->srr_lock
);
4693 imm
->srr_id
= tgt
->imm_srr_id
;
4694 list_add_tail(&imm
->srr_list_entry
,
4695 &tgt
->srr_imm_list
);
4696 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf02e,
4697 "IMM NTFY SRR %p added (id %d, ui %x)\n",
4698 imm
, imm
->srr_id
, iocb
->u
.isp24
.srr_ui
);
4699 if (tgt
->imm_srr_id
== tgt
->ctio_srr_id
) {
4701 list_for_each_entry(sctio
, &tgt
->srr_ctio_list
,
4703 if (sctio
->srr_id
== imm
->srr_id
) {
4709 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf02f, "%s",
4710 "Scheduling srr work\n");
4711 schedule_work(&tgt
->srr_work
);
4713 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf030,
4714 "qla_target(%d): imm_srr_id "
4715 "== ctio_srr_id (%d), but there is no "
4716 "corresponding SRR CTIO, deleting IMM "
4717 "SRR %p\n", vha
->vp_idx
, tgt
->ctio_srr_id
,
4719 list_del(&imm
->srr_list_entry
);
4723 spin_unlock(&tgt
->srr_lock
);
4727 spin_unlock(&tgt
->srr_lock
);
4729 struct qla_tgt_srr_ctio
*ts
;
4731 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf069,
4732 "qla_target(%d): Unable to allocate SRR IMM "
4733 "entry, SRR request will be rejected\n", vha
->vp_idx
);
4735 /* IRQ is already OFF */
4736 spin_lock(&tgt
->srr_lock
);
4737 list_for_each_entry_safe(sctio
, ts
, &tgt
->srr_ctio_list
,
4739 if (sctio
->srr_id
== tgt
->imm_srr_id
) {
4740 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf031,
4741 "CTIO SRR %p deleted (id %d)\n",
4742 sctio
, sctio
->srr_id
);
4743 list_del(&sctio
->srr_list_entry
);
4744 qlt_send_term_exchange(vha
, sctio
->cmd
,
4745 &sctio
->cmd
->atio
, 1);
4749 spin_unlock(&tgt
->srr_lock
);
4756 qlt_send_notify_ack(vha
, iocb
, 0, 0, 0,
4757 NOTIFY_ACK_SRR_FLAGS_REJECT
,
4758 NOTIFY_ACK_SRR_REJECT_REASON_UNABLE_TO_PERFORM
,
4759 NOTIFY_ACK_SRR_FLAGS_REJECT_EXPL_NO_EXPL
);
4763 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
4765 static void qlt_handle_imm_notify(struct scsi_qla_host
*vha
,
4766 struct imm_ntfy_from_isp
*iocb
)
4768 struct qla_hw_data
*ha
= vha
->hw
;
4769 uint32_t add_flags
= 0;
4770 int send_notify_ack
= 1;
4773 status
= le16_to_cpu(iocb
->u
.isp2x
.status
);
4775 case IMM_NTFY_LIP_RESET
:
4777 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf032,
4778 "qla_target(%d): LIP reset (loop %#x), subcode %x\n",
4779 vha
->vp_idx
, le16_to_cpu(iocb
->u
.isp24
.nport_handle
),
4780 iocb
->u
.isp24
.status_subcode
);
4782 if (qlt_reset(vha
, iocb
, QLA_TGT_ABORT_ALL
) == 0)
4783 send_notify_ack
= 0;
4787 case IMM_NTFY_LIP_LINK_REINIT
:
4789 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
4790 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf033,
4791 "qla_target(%d): LINK REINIT (loop %#x, "
4792 "subcode %x)\n", vha
->vp_idx
,
4793 le16_to_cpu(iocb
->u
.isp24
.nport_handle
),
4794 iocb
->u
.isp24
.status_subcode
);
4795 if (tgt
->link_reinit_iocb_pending
) {
4796 qlt_send_notify_ack(vha
, &tgt
->link_reinit_iocb
,
4799 memcpy(&tgt
->link_reinit_iocb
, iocb
, sizeof(*iocb
));
4800 tgt
->link_reinit_iocb_pending
= 1;
4802 * QLogic requires to wait after LINK REINIT for possible
4803 * PDISC or ADISC ELS commands
4805 send_notify_ack
= 0;
4809 case IMM_NTFY_PORT_LOGOUT
:
4810 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf034,
4811 "qla_target(%d): Port logout (loop "
4812 "%#x, subcode %x)\n", vha
->vp_idx
,
4813 le16_to_cpu(iocb
->u
.isp24
.nport_handle
),
4814 iocb
->u
.isp24
.status_subcode
);
4816 if (qlt_reset(vha
, iocb
, QLA_TGT_NEXUS_LOSS_SESS
) == 0)
4817 send_notify_ack
= 0;
4818 /* The sessions will be cleared in the callback, if needed */
4821 case IMM_NTFY_GLBL_TPRLO
:
4822 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf035,
4823 "qla_target(%d): Global TPRLO (%x)\n", vha
->vp_idx
, status
);
4824 if (qlt_reset(vha
, iocb
, QLA_TGT_NEXUS_LOSS
) == 0)
4825 send_notify_ack
= 0;
4826 /* The sessions will be cleared in the callback, if needed */
4829 case IMM_NTFY_PORT_CONFIG
:
4830 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf036,
4831 "qla_target(%d): Port config changed (%x)\n", vha
->vp_idx
,
4833 if (qlt_reset(vha
, iocb
, QLA_TGT_ABORT_ALL
) == 0)
4834 send_notify_ack
= 0;
4835 /* The sessions will be cleared in the callback, if needed */
4838 case IMM_NTFY_GLBL_LOGO
:
4839 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf06a,
4840 "qla_target(%d): Link failure detected\n",
4842 /* I_T nexus loss */
4843 if (qlt_reset(vha
, iocb
, QLA_TGT_NEXUS_LOSS
) == 0)
4844 send_notify_ack
= 0;
4847 case IMM_NTFY_IOCB_OVERFLOW
:
4848 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf06b,
4849 "qla_target(%d): Cannot provide requested "
4850 "capability (IOCB overflowed the immediate notify "
4851 "resource count)\n", vha
->vp_idx
);
4854 case IMM_NTFY_ABORT_TASK
:
4855 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf037,
4856 "qla_target(%d): Abort Task (S %08x I %#x -> "
4857 "L %#x)\n", vha
->vp_idx
,
4858 le16_to_cpu(iocb
->u
.isp2x
.seq_id
),
4859 GET_TARGET_ID(ha
, (struct atio_from_isp
*)iocb
),
4860 le16_to_cpu(iocb
->u
.isp2x
.lun
));
4861 if (qlt_abort_task(vha
, iocb
) == 0)
4862 send_notify_ack
= 0;
4865 case IMM_NTFY_RESOURCE
:
4866 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf06c,
4867 "qla_target(%d): Out of resources, host %ld\n",
4868 vha
->vp_idx
, vha
->host_no
);
4871 case IMM_NTFY_MSG_RX
:
4872 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf038,
4873 "qla_target(%d): Immediate notify task %x\n",
4874 vha
->vp_idx
, iocb
->u
.isp2x
.task_flags
);
4875 if (qlt_handle_task_mgmt(vha
, iocb
) == 0)
4876 send_notify_ack
= 0;
4880 if (qlt_24xx_handle_els(vha
, iocb
) == 0)
4881 send_notify_ack
= 0;
4885 qlt_prepare_srr_imm(vha
, iocb
);
4886 send_notify_ack
= 0;
4890 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf06d,
4891 "qla_target(%d): Received unknown immediate "
4892 "notify status %x\n", vha
->vp_idx
, status
);
4896 if (send_notify_ack
)
4897 qlt_send_notify_ack(vha
, iocb
, add_flags
, 0, 0, 0, 0, 0);
4901 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
4902 * This function sends busy to ISP 2xxx or 24xx.
4904 static int __qlt_send_busy(struct scsi_qla_host
*vha
,
4905 struct atio_from_isp
*atio
, uint16_t status
)
4907 struct ctio7_to_24xx
*ctio24
;
4908 struct qla_hw_data
*ha
= vha
->hw
;
4910 struct qla_tgt_sess
*sess
= NULL
;
4912 sess
= ha
->tgt
.tgt_ops
->find_sess_by_s_id(vha
,
4913 atio
->u
.isp24
.fcp_hdr
.s_id
);
4915 qlt_send_term_exchange(vha
, NULL
, atio
, 1);
4918 /* Sending marker isn't necessary, since we called from ISR */
4920 pkt
= (request_t
*)qla2x00_alloc_iocbs(vha
, NULL
);
4922 ql_dbg(ql_dbg_io
, vha
, 0x3063,
4923 "qla_target(%d): %s failed: unable to allocate "
4924 "request packet", vha
->vp_idx
, __func__
);
4928 pkt
->entry_count
= 1;
4929 pkt
->handle
= QLA_TGT_SKIP_HANDLE
| CTIO_COMPLETION_HANDLE_MARK
;
4931 ctio24
= (struct ctio7_to_24xx
*)pkt
;
4932 ctio24
->entry_type
= CTIO_TYPE7
;
4933 ctio24
->nport_handle
= sess
->loop_id
;
4934 ctio24
->timeout
= __constant_cpu_to_le16(QLA_TGT_TIMEOUT
);
4935 ctio24
->vp_index
= vha
->vp_idx
;
4936 ctio24
->initiator_id
[0] = atio
->u
.isp24
.fcp_hdr
.s_id
[2];
4937 ctio24
->initiator_id
[1] = atio
->u
.isp24
.fcp_hdr
.s_id
[1];
4938 ctio24
->initiator_id
[2] = atio
->u
.isp24
.fcp_hdr
.s_id
[0];
4939 ctio24
->exchange_addr
= atio
->u
.isp24
.exchange_addr
;
4940 ctio24
->u
.status1
.flags
= (atio
->u
.isp24
.attr
<< 9) |
4941 __constant_cpu_to_le16(
4942 CTIO7_FLAGS_STATUS_MODE_1
| CTIO7_FLAGS_SEND_STATUS
|
4943 CTIO7_FLAGS_DONT_RET_CTIO
);
4945 * CTIO from fw w/o se_cmd doesn't provide enough info to retry it,
4946 * if the explicit conformation is used.
4948 ctio24
->u
.status1
.ox_id
= swab16(atio
->u
.isp24
.fcp_hdr
.ox_id
);
4949 ctio24
->u
.status1
.scsi_status
= cpu_to_le16(status
);
4950 /* Memory Barrier */
4952 qla2x00_start_iocbs(vha
, vha
->req
);
4957 * This routine is used to allocate a command for either a QFull condition
4958 * (ie reply SAM_STAT_BUSY) or to terminate an exchange that did not go
4962 qlt_alloc_qfull_cmd(struct scsi_qla_host
*vha
,
4963 struct atio_from_isp
*atio
, uint16_t status
, int qfull
)
4965 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
4966 struct qla_hw_data
*ha
= vha
->hw
;
4967 struct qla_tgt_sess
*sess
;
4968 struct se_session
*se_sess
;
4969 struct qla_tgt_cmd
*cmd
;
4972 if (unlikely(tgt
->tgt_stop
)) {
4973 ql_dbg(ql_dbg_io
, vha
, 0x300a,
4974 "New command while device %p is shutting down\n", tgt
);
4978 if ((vha
->hw
->tgt
.num_qfull_cmds_alloc
+ 1) > MAX_QFULL_CMDS_ALLOC
) {
4979 vha
->hw
->tgt
.num_qfull_cmds_dropped
++;
4980 if (vha
->hw
->tgt
.num_qfull_cmds_dropped
>
4981 vha
->hw
->qla_stats
.stat_max_qfull_cmds_dropped
)
4982 vha
->hw
->qla_stats
.stat_max_qfull_cmds_dropped
=
4983 vha
->hw
->tgt
.num_qfull_cmds_dropped
;
4985 ql_dbg(ql_dbg_io
, vha
, 0x3068,
4986 "qla_target(%d): %s: QFull CMD dropped[%d]\n",
4987 vha
->vp_idx
, __func__
,
4988 vha
->hw
->tgt
.num_qfull_cmds_dropped
);
4990 qlt_chk_exch_leak_thresh_hold(vha
);
4994 sess
= ha
->tgt
.tgt_ops
->find_sess_by_s_id
4995 (vha
, atio
->u
.isp24
.fcp_hdr
.s_id
);
4999 se_sess
= sess
->se_sess
;
5001 tag
= percpu_ida_alloc(&se_sess
->sess_tag_pool
, TASK_RUNNING
);
5005 cmd
= &((struct qla_tgt_cmd
*)se_sess
->sess_cmd_map
)[tag
];
5007 ql_dbg(ql_dbg_io
, vha
, 0x3009,
5008 "qla_target(%d): %s: Allocation of cmd failed\n",
5009 vha
->vp_idx
, __func__
);
5011 vha
->hw
->tgt
.num_qfull_cmds_dropped
++;
5012 if (vha
->hw
->tgt
.num_qfull_cmds_dropped
>
5013 vha
->hw
->qla_stats
.stat_max_qfull_cmds_dropped
)
5014 vha
->hw
->qla_stats
.stat_max_qfull_cmds_dropped
=
5015 vha
->hw
->tgt
.num_qfull_cmds_dropped
;
5017 qlt_chk_exch_leak_thresh_hold(vha
);
5021 memset(cmd
, 0, sizeof(struct qla_tgt_cmd
));
5023 qlt_incr_num_pend_cmds(vha
);
5024 INIT_LIST_HEAD(&cmd
->cmd_list
);
5025 memcpy(&cmd
->atio
, atio
, sizeof(*atio
));
5027 cmd
->tgt
= vha
->vha_tgt
.qla_tgt
;
5029 cmd
->reset_count
= vha
->hw
->chip_reset
;
5034 /* NOTE: borrowing the state field to carry the status */
5035 cmd
->state
= status
;
5037 cmd
->term_exchg
= 1;
5039 list_add_tail(&cmd
->cmd_list
, &vha
->hw
->tgt
.q_full_list
);
5041 vha
->hw
->tgt
.num_qfull_cmds_alloc
++;
5042 if (vha
->hw
->tgt
.num_qfull_cmds_alloc
>
5043 vha
->hw
->qla_stats
.stat_max_qfull_cmds_alloc
)
5044 vha
->hw
->qla_stats
.stat_max_qfull_cmds_alloc
=
5045 vha
->hw
->tgt
.num_qfull_cmds_alloc
;
5049 qlt_free_qfull_cmds(struct scsi_qla_host
*vha
)
5051 struct qla_hw_data
*ha
= vha
->hw
;
5052 unsigned long flags
;
5053 struct qla_tgt_cmd
*cmd
, *tcmd
;
5054 struct list_head free_list
;
5057 if (list_empty(&ha
->tgt
.q_full_list
))
5060 INIT_LIST_HEAD(&free_list
);
5062 spin_lock_irqsave(&vha
->hw
->hardware_lock
, flags
);
5064 if (list_empty(&ha
->tgt
.q_full_list
)) {
5065 spin_unlock_irqrestore(&vha
->hw
->hardware_lock
, flags
);
5069 list_for_each_entry_safe(cmd
, tcmd
, &ha
->tgt
.q_full_list
, cmd_list
) {
5071 /* cmd->state is a borrowed field to hold status */
5072 rc
= __qlt_send_busy(vha
, &cmd
->atio
, cmd
->state
);
5073 else if (cmd
->term_exchg
)
5074 rc
= __qlt_send_term_exchange(vha
, NULL
, &cmd
->atio
);
5080 ql_dbg(ql_dbg_io
, vha
, 0x3006,
5081 "%s: busy sent for ox_id[%04x]\n", __func__
,
5082 be16_to_cpu(cmd
->atio
.u
.isp24
.fcp_hdr
.ox_id
));
5083 else if (cmd
->term_exchg
)
5084 ql_dbg(ql_dbg_io
, vha
, 0x3007,
5085 "%s: Term exchg sent for ox_id[%04x]\n", __func__
,
5086 be16_to_cpu(cmd
->atio
.u
.isp24
.fcp_hdr
.ox_id
));
5088 ql_dbg(ql_dbg_io
, vha
, 0x3008,
5089 "%s: Unexpected cmd in QFull list %p\n", __func__
,
5092 list_del(&cmd
->cmd_list
);
5093 list_add_tail(&cmd
->cmd_list
, &free_list
);
5095 /* piggy back on hardware_lock for protection */
5096 vha
->hw
->tgt
.num_qfull_cmds_alloc
--;
5098 spin_unlock_irqrestore(&vha
->hw
->hardware_lock
, flags
);
5102 list_for_each_entry_safe(cmd
, tcmd
, &free_list
, cmd_list
) {
5103 list_del(&cmd
->cmd_list
);
5104 /* This cmd was never sent to TCM. There is no need
5105 * to schedule free or call free_cmd
5113 qlt_send_busy(struct scsi_qla_host
*vha
,
5114 struct atio_from_isp
*atio
, uint16_t status
)
5118 rc
= __qlt_send_busy(vha
, atio
, status
);
5120 qlt_alloc_qfull_cmd(vha
, atio
, status
, 1);
5124 qlt_chk_qfull_thresh_hold(struct scsi_qla_host
*vha
,
5125 struct atio_from_isp
*atio
)
5127 struct qla_hw_data
*ha
= vha
->hw
;
5130 if (ha
->tgt
.num_pend_cmds
< Q_FULL_THRESH_HOLD(ha
))
5133 status
= temp_sam_status
;
5134 qlt_send_busy(vha
, atio
, status
);
5138 /* ha->hardware_lock supposed to be held on entry */
5139 /* called via callback from qla2xxx */
5140 static void qlt_24xx_atio_pkt(struct scsi_qla_host
*vha
,
5141 struct atio_from_isp
*atio
)
5143 struct qla_hw_data
*ha
= vha
->hw
;
5144 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
5147 if (unlikely(tgt
== NULL
)) {
5148 ql_dbg(ql_dbg_io
, vha
, 0x3064,
5149 "ATIO pkt, but no tgt (ha %p)", ha
);
5153 * In tgt_stop mode we also should allow all requests to pass.
5154 * Otherwise, some commands can stuck.
5157 tgt
->irq_cmd_count
++;
5159 switch (atio
->u
.raw
.entry_type
) {
5161 if (unlikely(atio
->u
.isp24
.exchange_addr
==
5162 ATIO_EXCHANGE_ADDRESS_UNKNOWN
)) {
5163 ql_dbg(ql_dbg_io
, vha
, 0x3065,
5164 "qla_target(%d): ATIO_TYPE7 "
5165 "received with UNKNOWN exchange address, "
5166 "sending QUEUE_FULL\n", vha
->vp_idx
);
5167 qlt_send_busy(vha
, atio
, SAM_STAT_TASK_SET_FULL
);
5173 if (likely(atio
->u
.isp24
.fcp_cmnd
.task_mgmt_flags
== 0)) {
5174 rc
= qlt_chk_qfull_thresh_hold(vha
, atio
);
5176 tgt
->irq_cmd_count
--;
5179 rc
= qlt_handle_cmd_for_atio(vha
, atio
);
5181 rc
= qlt_handle_task_mgmt(vha
, atio
);
5183 if (unlikely(rc
!= 0)) {
5185 #if 1 /* With TERM EXCHANGE some FC cards refuse to boot */
5186 qlt_send_busy(vha
, atio
, SAM_STAT_BUSY
);
5188 qlt_send_term_exchange(vha
, NULL
, atio
, 1);
5191 if (tgt
->tgt_stop
) {
5192 ql_dbg(ql_dbg_tgt
, vha
, 0xe059,
5193 "qla_target: Unable to send "
5194 "command to target for req, "
5197 ql_dbg(ql_dbg_tgt
, vha
, 0xe05a,
5198 "qla_target(%d): Unable to send "
5199 "command to target, sending BUSY "
5200 "status.\n", vha
->vp_idx
);
5201 qlt_send_busy(vha
, atio
, SAM_STAT_BUSY
);
5207 case IMMED_NOTIFY_TYPE
:
5209 if (unlikely(atio
->u
.isp2x
.entry_status
!= 0)) {
5210 ql_dbg(ql_dbg_tgt
, vha
, 0xe05b,
5211 "qla_target(%d): Received ATIO packet %x "
5212 "with error status %x\n", vha
->vp_idx
,
5213 atio
->u
.raw
.entry_type
,
5214 atio
->u
.isp2x
.entry_status
);
5217 ql_dbg(ql_dbg_tgt
, vha
, 0xe02e, "%s", "IMMED_NOTIFY ATIO");
5218 qlt_handle_imm_notify(vha
, (struct imm_ntfy_from_isp
*)atio
);
5223 ql_dbg(ql_dbg_tgt
, vha
, 0xe05c,
5224 "qla_target(%d): Received unknown ATIO atio "
5225 "type %x\n", vha
->vp_idx
, atio
->u
.raw
.entry_type
);
5229 tgt
->irq_cmd_count
--;
5232 /* ha->hardware_lock supposed to be held on entry */
5233 /* called via callback from qla2xxx */
5234 static void qlt_response_pkt(struct scsi_qla_host
*vha
, response_t
*pkt
)
5236 struct qla_hw_data
*ha
= vha
->hw
;
5237 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
5239 if (unlikely(tgt
== NULL
)) {
5240 ql_dbg(ql_dbg_tgt
, vha
, 0xe05d,
5241 "qla_target(%d): Response pkt %x received, but no "
5242 "tgt (ha %p)\n", vha
->vp_idx
, pkt
->entry_type
, ha
);
5247 * In tgt_stop mode we also should allow all requests to pass.
5248 * Otherwise, some commands can stuck.
5251 tgt
->irq_cmd_count
++;
5253 switch (pkt
->entry_type
) {
5257 struct ctio7_from_24xx
*entry
= (struct ctio7_from_24xx
*)pkt
;
5258 qlt_do_ctio_completion(vha
, entry
->handle
,
5259 le16_to_cpu(entry
->status
)|(pkt
->entry_status
<< 16),
5264 case ACCEPT_TGT_IO_TYPE
:
5266 struct atio_from_isp
*atio
= (struct atio_from_isp
*)pkt
;
5268 if (atio
->u
.isp2x
.status
!=
5269 __constant_cpu_to_le16(ATIO_CDB_VALID
)) {
5270 ql_dbg(ql_dbg_tgt
, vha
, 0xe05e,
5271 "qla_target(%d): ATIO with error "
5272 "status %x received\n", vha
->vp_idx
,
5273 le16_to_cpu(atio
->u
.isp2x
.status
));
5277 rc
= qlt_chk_qfull_thresh_hold(vha
, atio
);
5279 tgt
->irq_cmd_count
--;
5283 rc
= qlt_handle_cmd_for_atio(vha
, atio
);
5284 if (unlikely(rc
!= 0)) {
5286 #if 1 /* With TERM EXCHANGE some FC cards refuse to boot */
5287 qlt_send_busy(vha
, atio
, 0);
5289 qlt_send_term_exchange(vha
, NULL
, atio
, 1);
5292 if (tgt
->tgt_stop
) {
5293 ql_dbg(ql_dbg_tgt
, vha
, 0xe05f,
5294 "qla_target: Unable to send "
5295 "command to target, sending TERM "
5296 "EXCHANGE for rsp\n");
5297 qlt_send_term_exchange(vha
, NULL
,
5300 ql_dbg(ql_dbg_tgt
, vha
, 0xe060,
5301 "qla_target(%d): Unable to send "
5302 "command to target, sending BUSY "
5303 "status\n", vha
->vp_idx
);
5304 qlt_send_busy(vha
, atio
, 0);
5311 case CONTINUE_TGT_IO_TYPE
:
5313 struct ctio_to_2xxx
*entry
= (struct ctio_to_2xxx
*)pkt
;
5314 qlt_do_ctio_completion(vha
, entry
->handle
,
5315 le16_to_cpu(entry
->status
)|(pkt
->entry_status
<< 16),
5322 struct ctio_to_2xxx
*entry
= (struct ctio_to_2xxx
*)pkt
;
5323 qlt_do_ctio_completion(vha
, entry
->handle
,
5324 le16_to_cpu(entry
->status
)|(pkt
->entry_status
<< 16),
5329 case IMMED_NOTIFY_TYPE
:
5330 ql_dbg(ql_dbg_tgt
, vha
, 0xe035, "%s", "IMMED_NOTIFY\n");
5331 qlt_handle_imm_notify(vha
, (struct imm_ntfy_from_isp
*)pkt
);
5334 case NOTIFY_ACK_TYPE
:
5335 if (tgt
->notify_ack_expected
> 0) {
5336 struct nack_to_isp
*entry
= (struct nack_to_isp
*)pkt
;
5337 ql_dbg(ql_dbg_tgt
, vha
, 0xe036,
5338 "NOTIFY_ACK seq %08x status %x\n",
5339 le16_to_cpu(entry
->u
.isp2x
.seq_id
),
5340 le16_to_cpu(entry
->u
.isp2x
.status
));
5341 tgt
->notify_ack_expected
--;
5342 if (entry
->u
.isp2x
.status
!=
5343 __constant_cpu_to_le16(NOTIFY_ACK_SUCCESS
)) {
5344 ql_dbg(ql_dbg_tgt
, vha
, 0xe061,
5345 "qla_target(%d): NOTIFY_ACK "
5346 "failed %x\n", vha
->vp_idx
,
5347 le16_to_cpu(entry
->u
.isp2x
.status
));
5350 ql_dbg(ql_dbg_tgt
, vha
, 0xe062,
5351 "qla_target(%d): Unexpected NOTIFY_ACK received\n",
5356 case ABTS_RECV_24XX
:
5357 ql_dbg(ql_dbg_tgt
, vha
, 0xe037,
5358 "ABTS_RECV_24XX: instance %d\n", vha
->vp_idx
);
5359 qlt_24xx_handle_abts(vha
, (struct abts_recv_from_24xx
*)pkt
);
5362 case ABTS_RESP_24XX
:
5363 if (tgt
->abts_resp_expected
> 0) {
5364 struct abts_resp_from_24xx_fw
*entry
=
5365 (struct abts_resp_from_24xx_fw
*)pkt
;
5366 ql_dbg(ql_dbg_tgt
, vha
, 0xe038,
5367 "ABTS_RESP_24XX: compl_status %x\n",
5368 entry
->compl_status
);
5369 tgt
->abts_resp_expected
--;
5370 if (le16_to_cpu(entry
->compl_status
) !=
5371 ABTS_RESP_COMPL_SUCCESS
) {
5372 if ((entry
->error_subcode1
== 0x1E) &&
5373 (entry
->error_subcode2
== 0)) {
5375 * We've got a race here: aborted
5376 * exchange not terminated, i.e.
5377 * response for the aborted command was
5378 * sent between the abort request was
5379 * received and processed.
5380 * Unfortunately, the firmware has a
5381 * silly requirement that all aborted
5382 * exchanges must be explicitely
5383 * terminated, otherwise it refuses to
5384 * send responses for the abort
5385 * requests. So, we have to
5386 * (re)terminate the exchange and retry
5387 * the abort response.
5389 qlt_24xx_retry_term_exchange(vha
,
5392 ql_dbg(ql_dbg_tgt
, vha
, 0xe063,
5393 "qla_target(%d): ABTS_RESP_24XX "
5394 "failed %x (subcode %x:%x)",
5395 vha
->vp_idx
, entry
->compl_status
,
5396 entry
->error_subcode1
,
5397 entry
->error_subcode2
);
5400 ql_dbg(ql_dbg_tgt
, vha
, 0xe064,
5401 "qla_target(%d): Unexpected ABTS_RESP_24XX "
5402 "received\n", vha
->vp_idx
);
5407 ql_dbg(ql_dbg_tgt
, vha
, 0xe065,
5408 "qla_target(%d): Received unknown response pkt "
5409 "type %x\n", vha
->vp_idx
, pkt
->entry_type
);
5413 tgt
->irq_cmd_count
--;
5417 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
5419 void qlt_async_event(uint16_t code
, struct scsi_qla_host
*vha
,
5422 struct qla_hw_data
*ha
= vha
->hw
;
5423 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
5426 if (!ha
->tgt
.tgt_ops
)
5429 if (unlikely(tgt
== NULL
)) {
5430 ql_dbg(ql_dbg_tgt
, vha
, 0xe03a,
5431 "ASYNC EVENT %#x, but no tgt (ha %p)\n", code
, ha
);
5435 if (((code
== MBA_POINT_TO_POINT
) || (code
== MBA_CHG_IN_CONNECTION
)) &&
5439 * In tgt_stop mode we also should allow all requests to pass.
5440 * Otherwise, some commands can stuck.
5443 tgt
->irq_cmd_count
++;
5446 case MBA_RESET
: /* Reset */
5447 case MBA_SYSTEM_ERR
: /* System Error */
5448 case MBA_REQ_TRANSFER_ERR
: /* Request Transfer Error */
5449 case MBA_RSP_TRANSFER_ERR
: /* Response Transfer Error */
5450 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf03a,
5451 "qla_target(%d): System error async event %#x "
5452 "occurred", vha
->vp_idx
, code
);
5454 case MBA_WAKEUP_THRES
: /* Request Queue Wake-up. */
5455 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
5460 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf03b,
5461 "qla_target(%d): Async LOOP_UP occurred "
5462 "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha
->vp_idx
,
5463 le16_to_cpu(mailbox
[0]), le16_to_cpu(mailbox
[1]),
5464 le16_to_cpu(mailbox
[2]), le16_to_cpu(mailbox
[3]));
5465 if (tgt
->link_reinit_iocb_pending
) {
5466 qlt_send_notify_ack(vha
, (void *)&tgt
->link_reinit_iocb
,
5468 tgt
->link_reinit_iocb_pending
= 0;
5473 case MBA_LIP_OCCURRED
:
5476 case MBA_RSCN_UPDATE
:
5477 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf03c,
5478 "qla_target(%d): Async event %#x occurred "
5479 "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha
->vp_idx
, code
,
5480 le16_to_cpu(mailbox
[0]), le16_to_cpu(mailbox
[1]),
5481 le16_to_cpu(mailbox
[2]), le16_to_cpu(mailbox
[3]));
5484 case MBA_PORT_UPDATE
:
5485 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf03d,
5486 "qla_target(%d): Port update async event %#x "
5487 "occurred: updating the ports database (m[0]=%x, m[1]=%x, "
5488 "m[2]=%x, m[3]=%x)", vha
->vp_idx
, code
,
5489 le16_to_cpu(mailbox
[0]), le16_to_cpu(mailbox
[1]),
5490 le16_to_cpu(mailbox
[2]), le16_to_cpu(mailbox
[3]));
5492 login_code
= le16_to_cpu(mailbox
[2]);
5493 if (login_code
== 0x4)
5494 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf03e,
5495 "Async MB 2: Got PLOGI Complete\n");
5496 else if (login_code
== 0x7)
5497 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf03f,
5498 "Async MB 2: Port Logged Out\n");
5505 tgt
->irq_cmd_count
--;
5508 static fc_port_t
*qlt_get_port_database(struct scsi_qla_host
*vha
,
5514 fcport
= kzalloc(sizeof(*fcport
), GFP_KERNEL
);
5516 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf06f,
5517 "qla_target(%d): Allocation of tmp FC port failed",
5522 fcport
->loop_id
= loop_id
;
5524 rc
= qla2x00_get_port_database(vha
, fcport
, 0);
5525 if (rc
!= QLA_SUCCESS
) {
5526 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf070,
5527 "qla_target(%d): Failed to retrieve fcport "
5528 "information -- get_port_database() returned %x "
5529 "(loop_id=0x%04x)", vha
->vp_idx
, rc
, loop_id
);
5537 /* Must be called under tgt_mutex */
5538 static struct qla_tgt_sess
*qlt_make_local_sess(struct scsi_qla_host
*vha
,
5541 struct qla_tgt_sess
*sess
= NULL
;
5542 fc_port_t
*fcport
= NULL
;
5543 int rc
, global_resets
;
5544 uint16_t loop_id
= 0;
5548 atomic_read(&vha
->vha_tgt
.qla_tgt
->tgt_global_resets_count
);
5550 rc
= qla24xx_get_loop_id(vha
, s_id
, &loop_id
);
5552 if ((s_id
[0] == 0xFF) &&
5553 (s_id
[1] == 0xFC)) {
5555 * This is Domain Controller, so it should be
5556 * OK to drop SCSI commands from it.
5558 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf042,
5559 "Unable to find initiator with S_ID %x:%x:%x",
5560 s_id
[0], s_id
[1], s_id
[2]);
5562 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf071,
5563 "qla_target(%d): Unable to find "
5564 "initiator with S_ID %x:%x:%x",
5565 vha
->vp_idx
, s_id
[0], s_id
[1],
5570 fcport
= qlt_get_port_database(vha
, loop_id
);
5574 if (global_resets
!=
5575 atomic_read(&vha
->vha_tgt
.qla_tgt
->tgt_global_resets_count
)) {
5576 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf043,
5577 "qla_target(%d): global reset during session discovery "
5578 "(counter was %d, new %d), retrying", vha
->vp_idx
,
5580 atomic_read(&vha
->vha_tgt
.
5581 qla_tgt
->tgt_global_resets_count
));
5585 sess
= qlt_create_sess(vha
, fcport
, true);
5591 static void qlt_abort_work(struct qla_tgt
*tgt
,
5592 struct qla_tgt_sess_work_param
*prm
)
5594 struct scsi_qla_host
*vha
= tgt
->vha
;
5595 struct qla_hw_data
*ha
= vha
->hw
;
5596 struct qla_tgt_sess
*sess
= NULL
;
5597 unsigned long flags
;
5602 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
5607 s_id
[0] = prm
->abts
.fcp_hdr_le
.s_id
[2];
5608 s_id
[1] = prm
->abts
.fcp_hdr_le
.s_id
[1];
5609 s_id
[2] = prm
->abts
.fcp_hdr_le
.s_id
[0];
5611 sess
= ha
->tgt
.tgt_ops
->find_sess_by_s_id(vha
,
5612 (unsigned char *)&be_s_id
);
5614 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5616 mutex_lock(&vha
->vha_tgt
.tgt_mutex
);
5617 sess
= qlt_make_local_sess(vha
, s_id
);
5618 /* sess has got an extra creation ref */
5619 mutex_unlock(&vha
->vha_tgt
.tgt_mutex
);
5621 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
5625 if (sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
) {
5630 kref_get(&sess
->se_sess
->sess_kref
);
5636 rc
= __qlt_24xx_handle_abts(vha
, &prm
->abts
, sess
);
5640 ha
->tgt
.tgt_ops
->put_sess(sess
);
5641 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5645 qlt_24xx_send_abts_resp(vha
, &prm
->abts
, FCP_TMF_REJECTED
, false);
5647 ha
->tgt
.tgt_ops
->put_sess(sess
);
5648 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5651 static void qlt_tmr_work(struct qla_tgt
*tgt
,
5652 struct qla_tgt_sess_work_param
*prm
)
5654 struct atio_from_isp
*a
= &prm
->tm_iocb2
;
5655 struct scsi_qla_host
*vha
= tgt
->vha
;
5656 struct qla_hw_data
*ha
= vha
->hw
;
5657 struct qla_tgt_sess
*sess
= NULL
;
5658 unsigned long flags
;
5659 uint8_t *s_id
= NULL
; /* to hide compiler warnings */
5661 uint32_t lun
, unpacked_lun
;
5665 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
5670 s_id
= prm
->tm_iocb2
.u
.isp24
.fcp_hdr
.s_id
;
5671 sess
= ha
->tgt
.tgt_ops
->find_sess_by_s_id(vha
, s_id
);
5673 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5675 mutex_lock(&vha
->vha_tgt
.tgt_mutex
);
5676 sess
= qlt_make_local_sess(vha
, s_id
);
5677 /* sess has got an extra creation ref */
5678 mutex_unlock(&vha
->vha_tgt
.tgt_mutex
);
5680 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
5684 if (sess
->deleted
== QLA_SESS_DELETION_IN_PROGRESS
) {
5689 kref_get(&sess
->se_sess
->sess_kref
);
5693 lun
= a
->u
.isp24
.fcp_cmnd
.lun
;
5694 lun_size
= sizeof(lun
);
5695 fn
= a
->u
.isp24
.fcp_cmnd
.task_mgmt_flags
;
5696 unpacked_lun
= scsilun_to_int((struct scsi_lun
*)&lun
);
5698 rc
= qlt_issue_task_mgmt(sess
, unpacked_lun
, fn
, iocb
, 0);
5702 ha
->tgt
.tgt_ops
->put_sess(sess
);
5703 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5707 qlt_send_term_exchange(vha
, NULL
, &prm
->tm_iocb2
, 1);
5709 ha
->tgt
.tgt_ops
->put_sess(sess
);
5710 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5713 static void qlt_sess_work_fn(struct work_struct
*work
)
5715 struct qla_tgt
*tgt
= container_of(work
, struct qla_tgt
, sess_work
);
5716 struct scsi_qla_host
*vha
= tgt
->vha
;
5717 unsigned long flags
;
5719 ql_dbg(ql_dbg_tgt_mgt
, vha
, 0xf000, "Sess work (tgt %p)", tgt
);
5721 spin_lock_irqsave(&tgt
->sess_work_lock
, flags
);
5722 while (!list_empty(&tgt
->sess_works_list
)) {
5723 struct qla_tgt_sess_work_param
*prm
= list_entry(
5724 tgt
->sess_works_list
.next
, typeof(*prm
),
5725 sess_works_list_entry
);
5728 * This work can be scheduled on several CPUs at time, so we
5729 * must delete the entry to eliminate double processing
5731 list_del(&prm
->sess_works_list_entry
);
5733 spin_unlock_irqrestore(&tgt
->sess_work_lock
, flags
);
5735 switch (prm
->type
) {
5736 case QLA_TGT_SESS_WORK_ABORT
:
5737 qlt_abort_work(tgt
, prm
);
5739 case QLA_TGT_SESS_WORK_TM
:
5740 qlt_tmr_work(tgt
, prm
);
5747 spin_lock_irqsave(&tgt
->sess_work_lock
, flags
);
5751 spin_unlock_irqrestore(&tgt
->sess_work_lock
, flags
);
5754 /* Must be called under tgt_host_action_mutex */
5755 int qlt_add_target(struct qla_hw_data
*ha
, struct scsi_qla_host
*base_vha
)
5757 struct qla_tgt
*tgt
;
5759 if (!QLA_TGT_MODE_ENABLED())
5762 if (!IS_TGT_MODE_CAPABLE(ha
)) {
5763 ql_log(ql_log_warn
, base_vha
, 0xe070,
5764 "This adapter does not support target mode.\n");
5768 ql_dbg(ql_dbg_tgt
, base_vha
, 0xe03b,
5769 "Registering target for host %ld(%p).\n", base_vha
->host_no
, ha
);
5771 BUG_ON(base_vha
->vha_tgt
.qla_tgt
!= NULL
);
5773 tgt
= kzalloc(sizeof(struct qla_tgt
), GFP_KERNEL
);
5775 ql_dbg(ql_dbg_tgt
, base_vha
, 0xe066,
5776 "Unable to allocate struct qla_tgt\n");
5780 if (!(base_vha
->host
->hostt
->supported_mode
& MODE_TARGET
))
5781 base_vha
->host
->hostt
->supported_mode
|= MODE_TARGET
;
5784 tgt
->vha
= base_vha
;
5785 init_waitqueue_head(&tgt
->waitQ
);
5786 INIT_LIST_HEAD(&tgt
->sess_list
);
5787 INIT_LIST_HEAD(&tgt
->del_sess_list
);
5788 INIT_DELAYED_WORK(&tgt
->sess_del_work
,
5789 (void (*)(struct work_struct
*))qlt_del_sess_work_fn
);
5790 spin_lock_init(&tgt
->sess_work_lock
);
5791 INIT_WORK(&tgt
->sess_work
, qlt_sess_work_fn
);
5792 INIT_LIST_HEAD(&tgt
->sess_works_list
);
5793 spin_lock_init(&tgt
->srr_lock
);
5794 INIT_LIST_HEAD(&tgt
->srr_ctio_list
);
5795 INIT_LIST_HEAD(&tgt
->srr_imm_list
);
5796 INIT_WORK(&tgt
->srr_work
, qlt_handle_srr_work
);
5797 atomic_set(&tgt
->tgt_global_resets_count
, 0);
5799 base_vha
->vha_tgt
.qla_tgt
= tgt
;
5801 ql_dbg(ql_dbg_tgt
, base_vha
, 0xe067,
5802 "qla_target(%d): using 64 Bit PCI addressing",
5804 tgt
->tgt_enable_64bit_addr
= 1;
5806 tgt
->sg_tablesize
= QLA_TGT_MAX_SG_24XX(base_vha
->req
->length
- 3);
5807 tgt
->datasegs_per_cmd
= QLA_TGT_DATASEGS_PER_CMD_24XX
;
5808 tgt
->datasegs_per_cont
= QLA_TGT_DATASEGS_PER_CONT_24XX
;
5810 if (base_vha
->fc_vport
)
5813 mutex_lock(&qla_tgt_mutex
);
5814 list_add_tail(&tgt
->tgt_list_entry
, &qla_tgt_glist
);
5815 mutex_unlock(&qla_tgt_mutex
);
5820 /* Must be called under tgt_host_action_mutex */
5821 int qlt_remove_target(struct qla_hw_data
*ha
, struct scsi_qla_host
*vha
)
5823 if (!vha
->vha_tgt
.qla_tgt
)
5826 if (vha
->fc_vport
) {
5827 qlt_release(vha
->vha_tgt
.qla_tgt
);
5831 /* free left over qfull cmds */
5832 qlt_init_term_exchange(vha
);
5834 mutex_lock(&qla_tgt_mutex
);
5835 list_del(&vha
->vha_tgt
.qla_tgt
->tgt_list_entry
);
5836 mutex_unlock(&qla_tgt_mutex
);
5838 ql_dbg(ql_dbg_tgt
, vha
, 0xe03c, "Unregistering target for host %ld(%p)",
5840 qlt_release(vha
->vha_tgt
.qla_tgt
);
5845 static void qlt_lport_dump(struct scsi_qla_host
*vha
, u64 wwpn
,
5850 pr_debug("qla2xxx HW vha->node_name: ");
5851 for (i
= 0; i
< WWN_SIZE
; i
++)
5852 pr_debug("%02x ", vha
->node_name
[i
]);
5854 pr_debug("qla2xxx HW vha->port_name: ");
5855 for (i
= 0; i
< WWN_SIZE
; i
++)
5856 pr_debug("%02x ", vha
->port_name
[i
]);
5859 pr_debug("qla2xxx passed configfs WWPN: ");
5860 put_unaligned_be64(wwpn
, b
);
5861 for (i
= 0; i
< WWN_SIZE
; i
++)
5862 pr_debug("%02x ", b
[i
]);
5867 * qla_tgt_lport_register - register lport with external module
5869 * @qla_tgt_ops: Pointer for tcm_qla2xxx qla_tgt_ops
5870 * @wwpn: Passwd FC target WWPN
5871 * @callback: lport initialization callback for tcm_qla2xxx code
5872 * @target_lport_ptr: pointer for tcm_qla2xxx specific lport data
5874 int qlt_lport_register(void *target_lport_ptr
, u64 phys_wwpn
,
5875 u64 npiv_wwpn
, u64 npiv_wwnn
,
5876 int (*callback
)(struct scsi_qla_host
*, void *, u64
, u64
))
5878 struct qla_tgt
*tgt
;
5879 struct scsi_qla_host
*vha
;
5880 struct qla_hw_data
*ha
;
5881 struct Scsi_Host
*host
;
5882 unsigned long flags
;
5886 mutex_lock(&qla_tgt_mutex
);
5887 list_for_each_entry(tgt
, &qla_tgt_glist
, tgt_list_entry
) {
5895 if (!(host
->hostt
->supported_mode
& MODE_TARGET
))
5898 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
5899 if ((!npiv_wwpn
|| !npiv_wwnn
) && host
->active_mode
& MODE_TARGET
) {
5900 pr_debug("MODE_TARGET already active on qla2xxx(%d)\n",
5902 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5905 if (tgt
->tgt_stop
) {
5906 pr_debug("MODE_TARGET in shutdown on qla2xxx(%d)\n",
5908 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5911 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
5913 if (!scsi_host_get(host
)) {
5914 ql_dbg(ql_dbg_tgt
, vha
, 0xe068,
5915 "Unable to scsi_host_get() for"
5916 " qla2xxx scsi_host\n");
5919 qlt_lport_dump(vha
, phys_wwpn
, b
);
5921 if (memcmp(vha
->port_name
, b
, WWN_SIZE
)) {
5922 scsi_host_put(host
);
5925 rc
= (*callback
)(vha
, target_lport_ptr
, npiv_wwpn
, npiv_wwnn
);
5927 scsi_host_put(host
);
5929 mutex_unlock(&qla_tgt_mutex
);
5932 mutex_unlock(&qla_tgt_mutex
);
5936 EXPORT_SYMBOL(qlt_lport_register
);
5939 * qla_tgt_lport_deregister - Degister lport
5941 * @vha: Registered scsi_qla_host pointer
5943 void qlt_lport_deregister(struct scsi_qla_host
*vha
)
5945 struct qla_hw_data
*ha
= vha
->hw
;
5946 struct Scsi_Host
*sh
= vha
->host
;
5948 * Clear the target_lport_ptr qla_target_template pointer in qla_hw_data
5950 vha
->vha_tgt
.target_lport_ptr
= NULL
;
5951 ha
->tgt
.tgt_ops
= NULL
;
5953 * Release the Scsi_Host reference for the underlying qla2xxx host
5957 EXPORT_SYMBOL(qlt_lport_deregister
);
5959 /* Must be called under HW lock */
5960 static void qlt_set_mode(struct scsi_qla_host
*vha
)
5962 struct qla_hw_data
*ha
= vha
->hw
;
5964 switch (ql2x_ini_mode
) {
5965 case QLA2XXX_INI_MODE_DISABLED
:
5966 case QLA2XXX_INI_MODE_EXCLUSIVE
:
5967 vha
->host
->active_mode
= MODE_TARGET
;
5969 case QLA2XXX_INI_MODE_ENABLED
:
5970 vha
->host
->active_mode
|= MODE_TARGET
;
5976 if (ha
->tgt
.ini_mode_force_reverse
)
5977 qla_reverse_ini_mode(vha
);
5980 /* Must be called under HW lock */
5981 static void qlt_clear_mode(struct scsi_qla_host
*vha
)
5983 struct qla_hw_data
*ha
= vha
->hw
;
5985 switch (ql2x_ini_mode
) {
5986 case QLA2XXX_INI_MODE_DISABLED
:
5987 vha
->host
->active_mode
= MODE_UNKNOWN
;
5989 case QLA2XXX_INI_MODE_EXCLUSIVE
:
5990 vha
->host
->active_mode
= MODE_INITIATOR
;
5992 case QLA2XXX_INI_MODE_ENABLED
:
5993 vha
->host
->active_mode
&= ~MODE_TARGET
;
5999 if (ha
->tgt
.ini_mode_force_reverse
)
6000 qla_reverse_ini_mode(vha
);
6004 * qla_tgt_enable_vha - NO LOCK HELD
6006 * host_reset, bring up w/ Target Mode Enabled
6009 qlt_enable_vha(struct scsi_qla_host
*vha
)
6011 struct qla_hw_data
*ha
= vha
->hw
;
6012 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
6013 unsigned long flags
;
6014 scsi_qla_host_t
*base_vha
= pci_get_drvdata(ha
->pdev
);
6017 ql_dbg(ql_dbg_tgt
, vha
, 0xe069,
6018 "Unable to locate qla_tgt pointer from"
6019 " struct qla_hw_data\n");
6024 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
6025 tgt
->tgt_stopped
= 0;
6027 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
6030 qla24xx_disable_vp(vha
);
6031 qla24xx_enable_vp(vha
);
6033 set_bit(ISP_ABORT_NEEDED
, &base_vha
->dpc_flags
);
6034 qla2xxx_wake_dpc(base_vha
);
6035 qla2x00_wait_for_hba_online(base_vha
);
6038 EXPORT_SYMBOL(qlt_enable_vha
);
6041 * qla_tgt_disable_vha - NO LOCK HELD
6043 * Disable Target Mode and reset the adapter
6045 static void qlt_disable_vha(struct scsi_qla_host
*vha
)
6047 struct qla_hw_data
*ha
= vha
->hw
;
6048 struct qla_tgt
*tgt
= vha
->vha_tgt
.qla_tgt
;
6049 unsigned long flags
;
6052 ql_dbg(ql_dbg_tgt
, vha
, 0xe06a,
6053 "Unable to locate qla_tgt pointer from"
6054 " struct qla_hw_data\n");
6059 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
6060 qlt_clear_mode(vha
);
6061 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
6063 set_bit(ISP_ABORT_NEEDED
, &vha
->dpc_flags
);
6064 qla2xxx_wake_dpc(vha
);
6065 qla2x00_wait_for_hba_online(vha
);
6069 * Called from qla_init.c:qla24xx_vport_create() contex to setup
6070 * the target mode specific struct scsi_qla_host and struct qla_hw_data
6074 qlt_vport_create(struct scsi_qla_host
*vha
, struct qla_hw_data
*ha
)
6076 if (!qla_tgt_mode_enabled(vha
))
6079 vha
->vha_tgt
.qla_tgt
= NULL
;
6081 mutex_init(&vha
->vha_tgt
.tgt_mutex
);
6082 mutex_init(&vha
->vha_tgt
.tgt_host_action_mutex
);
6084 qlt_clear_mode(vha
);
6087 * NOTE: Currently the value is kept the same for <24xx and
6088 * >=24xx ISPs. If it is necessary to change it,
6089 * the check should be added for specific ISPs,
6090 * assigning the value appropriately.
6092 ha
->tgt
.atio_q_length
= ATIO_ENTRY_CNT_24XX
;
6094 qlt_add_target(ha
, vha
);
6098 qlt_rff_id(struct scsi_qla_host
*vha
, struct ct_sns_req
*ct_req
)
6101 * FC-4 Feature bit 0 indicates target functionality to the name server.
6103 if (qla_tgt_mode_enabled(vha
)) {
6104 if (qla_ini_mode_enabled(vha
))
6105 ct_req
->req
.rff_id
.fc4_feature
= BIT_0
| BIT_1
;
6107 ct_req
->req
.rff_id
.fc4_feature
= BIT_0
;
6108 } else if (qla_ini_mode_enabled(vha
)) {
6109 ct_req
->req
.rff_id
.fc4_feature
= BIT_1
;
6114 * qlt_init_atio_q_entries() - Initializes ATIO queue entries.
6117 * Beginning of ATIO ring has initialization control block already built
6118 * by nvram config routine.
6120 * Returns 0 on success.
6123 qlt_init_atio_q_entries(struct scsi_qla_host
*vha
)
6125 struct qla_hw_data
*ha
= vha
->hw
;
6127 struct atio_from_isp
*pkt
= (struct atio_from_isp
*)ha
->tgt
.atio_ring
;
6129 if (!qla_tgt_mode_enabled(vha
))
6132 for (cnt
= 0; cnt
< ha
->tgt
.atio_q_length
; cnt
++) {
6133 pkt
->u
.raw
.signature
= ATIO_PROCESSED
;
6140 * qlt_24xx_process_atio_queue() - Process ATIO queue entries.
6141 * @ha: SCSI driver HA context
6144 qlt_24xx_process_atio_queue(struct scsi_qla_host
*vha
)
6146 struct qla_hw_data
*ha
= vha
->hw
;
6147 struct atio_from_isp
*pkt
;
6150 if (!vha
->flags
.online
)
6153 while (ha
->tgt
.atio_ring_ptr
->signature
!= ATIO_PROCESSED
) {
6154 pkt
= (struct atio_from_isp
*)ha
->tgt
.atio_ring_ptr
;
6155 cnt
= pkt
->u
.raw
.entry_count
;
6157 qlt_24xx_atio_pkt_all_vps(vha
, (struct atio_from_isp
*)pkt
);
6159 for (i
= 0; i
< cnt
; i
++) {
6160 ha
->tgt
.atio_ring_index
++;
6161 if (ha
->tgt
.atio_ring_index
== ha
->tgt
.atio_q_length
) {
6162 ha
->tgt
.atio_ring_index
= 0;
6163 ha
->tgt
.atio_ring_ptr
= ha
->tgt
.atio_ring
;
6165 ha
->tgt
.atio_ring_ptr
++;
6167 pkt
->u
.raw
.signature
= ATIO_PROCESSED
;
6168 pkt
= (struct atio_from_isp
*)ha
->tgt
.atio_ring_ptr
;
6173 /* Adjust ring index */
6174 WRT_REG_DWORD(ISP_ATIO_Q_OUT(vha
), ha
->tgt
.atio_ring_index
);
6175 RD_REG_DWORD_RELAXED(ISP_ATIO_Q_OUT(vha
));
6179 qlt_24xx_config_rings(struct scsi_qla_host
*vha
)
6181 struct qla_hw_data
*ha
= vha
->hw
;
6182 if (!QLA_TGT_MODE_ENABLED())
6185 WRT_REG_DWORD(ISP_ATIO_Q_IN(vha
), 0);
6186 WRT_REG_DWORD(ISP_ATIO_Q_OUT(vha
), 0);
6187 RD_REG_DWORD(ISP_ATIO_Q_OUT(vha
));
6189 if (IS_ATIO_MSIX_CAPABLE(ha
)) {
6190 struct qla_msix_entry
*msix
= &ha
->msix_entries
[2];
6191 struct init_cb_24xx
*icb
= (struct init_cb_24xx
*)ha
->init_cb
;
6193 icb
->msix_atio
= cpu_to_le16(msix
->entry
);
6194 ql_dbg(ql_dbg_init
, vha
, 0xf072,
6195 "Registering ICB vector 0x%x for atio que.\n",
6201 qlt_24xx_config_nvram_stage1(struct scsi_qla_host
*vha
, struct nvram_24xx
*nv
)
6203 struct qla_hw_data
*ha
= vha
->hw
;
6205 if (qla_tgt_mode_enabled(vha
)) {
6206 if (!ha
->tgt
.saved_set
) {
6207 /* We save only once */
6208 ha
->tgt
.saved_exchange_count
= nv
->exchange_count
;
6209 ha
->tgt
.saved_firmware_options_1
=
6210 nv
->firmware_options_1
;
6211 ha
->tgt
.saved_firmware_options_2
=
6212 nv
->firmware_options_2
;
6213 ha
->tgt
.saved_firmware_options_3
=
6214 nv
->firmware_options_3
;
6215 ha
->tgt
.saved_set
= 1;
6218 nv
->exchange_count
= __constant_cpu_to_le16(0xFFFF);
6220 /* Enable target mode */
6221 nv
->firmware_options_1
|= __constant_cpu_to_le32(BIT_4
);
6223 /* Disable ini mode, if requested */
6224 if (!qla_ini_mode_enabled(vha
))
6225 nv
->firmware_options_1
|= __constant_cpu_to_le32(BIT_5
);
6227 /* Disable Full Login after LIP */
6228 nv
->firmware_options_1
&= __constant_cpu_to_le32(~BIT_13
);
6229 /* Enable initial LIP */
6230 nv
->firmware_options_1
&= __constant_cpu_to_le32(~BIT_9
);
6231 if (ql2xtgt_tape_enable
)
6232 /* Enable FC Tape support */
6233 nv
->firmware_options_2
|= cpu_to_le32(BIT_12
);
6235 /* Disable FC Tape support */
6236 nv
->firmware_options_2
&= cpu_to_le32(~BIT_12
);
6238 /* Disable Full Login after LIP */
6239 nv
->host_p
&= __constant_cpu_to_le32(~BIT_10
);
6240 /* Enable target PRLI control */
6241 nv
->firmware_options_2
|= __constant_cpu_to_le32(BIT_14
);
6243 if (ha
->tgt
.saved_set
) {
6244 nv
->exchange_count
= ha
->tgt
.saved_exchange_count
;
6245 nv
->firmware_options_1
=
6246 ha
->tgt
.saved_firmware_options_1
;
6247 nv
->firmware_options_2
=
6248 ha
->tgt
.saved_firmware_options_2
;
6249 nv
->firmware_options_3
=
6250 ha
->tgt
.saved_firmware_options_3
;
6255 /* out-of-order frames reassembly */
6256 nv
->firmware_options_3
|= BIT_6
|BIT_9
;
6258 if (ha
->tgt
.enable_class_2
) {
6259 if (vha
->flags
.init_done
)
6260 fc_host_supported_classes(vha
->host
) =
6261 FC_COS_CLASS2
| FC_COS_CLASS3
;
6263 nv
->firmware_options_2
|= __constant_cpu_to_le32(BIT_8
);
6265 if (vha
->flags
.init_done
)
6266 fc_host_supported_classes(vha
->host
) = FC_COS_CLASS3
;
6268 nv
->firmware_options_2
&= ~__constant_cpu_to_le32(BIT_8
);
6273 qlt_24xx_config_nvram_stage2(struct scsi_qla_host
*vha
,
6274 struct init_cb_24xx
*icb
)
6276 struct qla_hw_data
*ha
= vha
->hw
;
6278 if (ha
->tgt
.node_name_set
) {
6279 memcpy(icb
->node_name
, ha
->tgt
.tgt_node_name
, WWN_SIZE
);
6280 icb
->firmware_options_1
|= __constant_cpu_to_le32(BIT_14
);
6285 qlt_81xx_config_nvram_stage1(struct scsi_qla_host
*vha
, struct nvram_81xx
*nv
)
6287 struct qla_hw_data
*ha
= vha
->hw
;
6289 if (!QLA_TGT_MODE_ENABLED())
6292 if (qla_tgt_mode_enabled(vha
)) {
6293 if (!ha
->tgt
.saved_set
) {
6294 /* We save only once */
6295 ha
->tgt
.saved_exchange_count
= nv
->exchange_count
;
6296 ha
->tgt
.saved_firmware_options_1
=
6297 nv
->firmware_options_1
;
6298 ha
->tgt
.saved_firmware_options_2
=
6299 nv
->firmware_options_2
;
6300 ha
->tgt
.saved_firmware_options_3
=
6301 nv
->firmware_options_3
;
6302 ha
->tgt
.saved_set
= 1;
6305 nv
->exchange_count
= __constant_cpu_to_le16(0xFFFF);
6307 /* Enable target mode */
6308 nv
->firmware_options_1
|= __constant_cpu_to_le32(BIT_4
);
6310 /* Disable ini mode, if requested */
6311 if (!qla_ini_mode_enabled(vha
))
6312 nv
->firmware_options_1
|=
6313 __constant_cpu_to_le32(BIT_5
);
6315 /* Disable Full Login after LIP */
6316 nv
->firmware_options_1
&= __constant_cpu_to_le32(~BIT_13
);
6317 /* Enable initial LIP */
6318 nv
->firmware_options_1
&= __constant_cpu_to_le32(~BIT_9
);
6319 if (ql2xtgt_tape_enable
)
6320 /* Enable FC tape support */
6321 nv
->firmware_options_2
|= cpu_to_le32(BIT_12
);
6323 /* Disable FC tape support */
6324 nv
->firmware_options_2
&= cpu_to_le32(~BIT_12
);
6326 /* Disable Full Login after LIP */
6327 nv
->host_p
&= __constant_cpu_to_le32(~BIT_10
);
6328 /* Enable target PRLI control */
6329 nv
->firmware_options_2
|= __constant_cpu_to_le32(BIT_14
);
6331 if (ha
->tgt
.saved_set
) {
6332 nv
->exchange_count
= ha
->tgt
.saved_exchange_count
;
6333 nv
->firmware_options_1
=
6334 ha
->tgt
.saved_firmware_options_1
;
6335 nv
->firmware_options_2
=
6336 ha
->tgt
.saved_firmware_options_2
;
6337 nv
->firmware_options_3
=
6338 ha
->tgt
.saved_firmware_options_3
;
6343 /* out-of-order frames reassembly */
6344 nv
->firmware_options_3
|= BIT_6
|BIT_9
;
6346 if (ha
->tgt
.enable_class_2
) {
6347 if (vha
->flags
.init_done
)
6348 fc_host_supported_classes(vha
->host
) =
6349 FC_COS_CLASS2
| FC_COS_CLASS3
;
6351 nv
->firmware_options_2
|= __constant_cpu_to_le32(BIT_8
);
6353 if (vha
->flags
.init_done
)
6354 fc_host_supported_classes(vha
->host
) = FC_COS_CLASS3
;
6356 nv
->firmware_options_2
&= ~__constant_cpu_to_le32(BIT_8
);
6361 qlt_81xx_config_nvram_stage2(struct scsi_qla_host
*vha
,
6362 struct init_cb_81xx
*icb
)
6364 struct qla_hw_data
*ha
= vha
->hw
;
6366 if (!QLA_TGT_MODE_ENABLED())
6369 if (ha
->tgt
.node_name_set
) {
6370 memcpy(icb
->node_name
, ha
->tgt
.tgt_node_name
, WWN_SIZE
);
6371 icb
->firmware_options_1
|= __constant_cpu_to_le32(BIT_14
);
6376 qlt_83xx_iospace_config(struct qla_hw_data
*ha
)
6378 if (!QLA_TGT_MODE_ENABLED())
6381 ha
->msix_count
+= 1; /* For ATIO Q */
6385 qlt_24xx_process_response_error(struct scsi_qla_host
*vha
,
6386 struct sts_entry_24xx
*pkt
)
6388 switch (pkt
->entry_type
) {
6389 case ABTS_RECV_24XX
:
6390 case ABTS_RESP_24XX
:
6392 case NOTIFY_ACK_TYPE
:
6401 qlt_modify_vp_config(struct scsi_qla_host
*vha
,
6402 struct vp_config_entry_24xx
*vpmod
)
6404 if (qla_tgt_mode_enabled(vha
))
6405 vpmod
->options_idx1
&= ~BIT_5
;
6406 /* Disable ini mode, if requested */
6407 if (!qla_ini_mode_enabled(vha
))
6408 vpmod
->options_idx1
&= ~BIT_4
;
6412 qlt_probe_one_stage1(struct scsi_qla_host
*base_vha
, struct qla_hw_data
*ha
)
6414 if (!QLA_TGT_MODE_ENABLED())
6417 if (ha
->mqenable
|| IS_QLA83XX(ha
) || IS_QLA27XX(ha
)) {
6418 ISP_ATIO_Q_IN(base_vha
) = &ha
->mqiobase
->isp25mq
.atio_q_in
;
6419 ISP_ATIO_Q_OUT(base_vha
) = &ha
->mqiobase
->isp25mq
.atio_q_out
;
6421 ISP_ATIO_Q_IN(base_vha
) = &ha
->iobase
->isp24
.atio_q_in
;
6422 ISP_ATIO_Q_OUT(base_vha
) = &ha
->iobase
->isp24
.atio_q_out
;
6425 mutex_init(&base_vha
->vha_tgt
.tgt_mutex
);
6426 mutex_init(&base_vha
->vha_tgt
.tgt_host_action_mutex
);
6427 qlt_clear_mode(base_vha
);
6431 qla83xx_msix_atio_q(int irq
, void *dev_id
)
6433 struct rsp_que
*rsp
;
6434 scsi_qla_host_t
*vha
;
6435 struct qla_hw_data
*ha
;
6436 unsigned long flags
;
6438 rsp
= (struct rsp_que
*) dev_id
;
6440 vha
= pci_get_drvdata(ha
->pdev
);
6442 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
6444 qlt_24xx_process_atio_queue(vha
);
6445 qla24xx_process_response_queue(vha
, rsp
);
6447 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
6453 qlt_mem_alloc(struct qla_hw_data
*ha
)
6455 if (!QLA_TGT_MODE_ENABLED())
6458 ha
->tgt
.tgt_vp_map
= kzalloc(sizeof(struct qla_tgt_vp_map
) *
6459 MAX_MULTI_ID_FABRIC
, GFP_KERNEL
);
6460 if (!ha
->tgt
.tgt_vp_map
)
6463 ha
->tgt
.atio_ring
= dma_alloc_coherent(&ha
->pdev
->dev
,
6464 (ha
->tgt
.atio_q_length
+ 1) * sizeof(struct atio_from_isp
),
6465 &ha
->tgt
.atio_dma
, GFP_KERNEL
);
6466 if (!ha
->tgt
.atio_ring
) {
6467 kfree(ha
->tgt
.tgt_vp_map
);
6474 qlt_mem_free(struct qla_hw_data
*ha
)
6476 if (!QLA_TGT_MODE_ENABLED())
6479 if (ha
->tgt
.atio_ring
) {
6480 dma_free_coherent(&ha
->pdev
->dev
, (ha
->tgt
.atio_q_length
+ 1) *
6481 sizeof(struct atio_from_isp
), ha
->tgt
.atio_ring
,
6484 kfree(ha
->tgt
.tgt_vp_map
);
6487 /* vport_slock to be held by the caller */
6489 qlt_update_vp_map(struct scsi_qla_host
*vha
, int cmd
)
6491 if (!QLA_TGT_MODE_ENABLED())
6496 vha
->hw
->tgt
.tgt_vp_map
[vha
->vp_idx
].vha
= vha
;
6499 vha
->hw
->tgt
.tgt_vp_map
[vha
->d_id
.b
.al_pa
].idx
= vha
->vp_idx
;
6502 vha
->hw
->tgt
.tgt_vp_map
[vha
->vp_idx
].vha
= NULL
;
6505 vha
->hw
->tgt
.tgt_vp_map
[vha
->d_id
.b
.al_pa
].idx
= 0;
6510 static int __init
qlt_parse_ini_mode(void)
6512 if (strcasecmp(qlini_mode
, QLA2XXX_INI_MODE_STR_EXCLUSIVE
) == 0)
6513 ql2x_ini_mode
= QLA2XXX_INI_MODE_EXCLUSIVE
;
6514 else if (strcasecmp(qlini_mode
, QLA2XXX_INI_MODE_STR_DISABLED
) == 0)
6515 ql2x_ini_mode
= QLA2XXX_INI_MODE_DISABLED
;
6516 else if (strcasecmp(qlini_mode
, QLA2XXX_INI_MODE_STR_ENABLED
) == 0)
6517 ql2x_ini_mode
= QLA2XXX_INI_MODE_ENABLED
;
6524 int __init
qlt_init(void)
6528 if (!qlt_parse_ini_mode()) {
6529 ql_log(ql_log_fatal
, NULL
, 0xe06b,
6530 "qlt_parse_ini_mode() failed\n");
6534 if (!QLA_TGT_MODE_ENABLED())
6537 qla_tgt_mgmt_cmd_cachep
= kmem_cache_create("qla_tgt_mgmt_cmd_cachep",
6538 sizeof(struct qla_tgt_mgmt_cmd
), __alignof__(struct
6539 qla_tgt_mgmt_cmd
), 0, NULL
);
6540 if (!qla_tgt_mgmt_cmd_cachep
) {
6541 ql_log(ql_log_fatal
, NULL
, 0xe06d,
6542 "kmem_cache_create for qla_tgt_mgmt_cmd_cachep failed\n");
6546 qla_tgt_mgmt_cmd_mempool
= mempool_create(25, mempool_alloc_slab
,
6547 mempool_free_slab
, qla_tgt_mgmt_cmd_cachep
);
6548 if (!qla_tgt_mgmt_cmd_mempool
) {
6549 ql_log(ql_log_fatal
, NULL
, 0xe06e,
6550 "mempool_create for qla_tgt_mgmt_cmd_mempool failed\n");
6552 goto out_mgmt_cmd_cachep
;
6555 qla_tgt_wq
= alloc_workqueue("qla_tgt_wq", 0, 0);
6557 ql_log(ql_log_fatal
, NULL
, 0xe06f,
6558 "alloc_workqueue for qla_tgt_wq failed\n");
6560 goto out_cmd_mempool
;
6563 * Return 1 to signal that initiator-mode is being disabled
6565 return (ql2x_ini_mode
== QLA2XXX_INI_MODE_DISABLED
) ? 1 : 0;
6568 mempool_destroy(qla_tgt_mgmt_cmd_mempool
);
6569 out_mgmt_cmd_cachep
:
6570 kmem_cache_destroy(qla_tgt_mgmt_cmd_cachep
);
6576 if (!QLA_TGT_MODE_ENABLED())
6579 destroy_workqueue(qla_tgt_wq
);
6580 mempool_destroy(qla_tgt_mgmt_cmd_mempool
);
6581 kmem_cache_destroy(qla_tgt_mgmt_cmd_cachep
);