projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
scsi: qla2xxx: Enable type checking for the SRB free and done callback functions
[linux-2.6-block.git] / drivers / scsi / qla2xxx / qla_target.c
CommitLineData
8e8e69d6 1// SPDX-License-Identifier: GPL-2.0-only
2d70c103
NB		 2/*
3 * qla_target.c SCSI LLD infrastructure for QLogic 22xx/23xx/24xx/25xx
4 *
5 * based on qla2x00t.c code:
6 *
7 * Copyright (C) 2004 - 2010 Vladislav Bolkhovitin <vst@vlnb.net>
8 * Copyright (C) 2004 - 2005 Leonid Stoljar
9 * Copyright (C) 2006 Nathaniel Clark <nate@misrule.us>
10 * Copyright (C) 2006 - 2010 ID7 Ltd.
11 *
12 * Forward port and refactoring to modern qla2xxx and target/configfs
13 *
4c76251e 14 * Copyright (C) 2010-2013 Nicholas A. Bellinger <nab@kernel.org>
2d70c103
NB		 15 */
16
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/types.h>
2d70c103
NB		 20#include <linux/blkdev.h>
21#include <linux/interrupt.h>
22#include <linux/pci.h>
23#include <linux/delay.h>
24#include <linux/list.h>
25#include <linux/workqueue.h>
26#include <asm/unaligned.h>
27#include <scsi/scsi.h>
28#include <scsi/scsi_host.h>
29#include <scsi/scsi_tcq.h>
30#include <target/target_core_base.h>
31#include <target/target_core_fabric.h>
32
33#include "qla_def.h"
34#include "qla_target.h"
35
d154f350
AE		 36static int ql2xtgt_tape_enable;
37module_param(ql2xtgt_tape_enable, int, S_IRUGO|S_IWUSR);
38MODULE_PARM_DESC(ql2xtgt_tape_enable,
39 "Enables Sequence level error recovery (aka FC Tape). Default is 0 - no SLER. 1 - Enable SLER.");
40
2d70c103
NB		 41static char *qlini_mode = QLA2XXX_INI_MODE_STR_ENABLED;
42module_param(qlini_mode, charp, S_IRUGO);
43MODULE_PARM_DESC(qlini_mode,
44 "Determines when initiator mode will be enabled. Possible values: "
45 "\"exclusive\" - initiator mode will be enabled on load, "
46 "disabled on enabling target mode and then on disabling target mode "
47 "enabled back; "
48 "\"disabled\" - initiator mode will never be enabled; "
ead03855
QT		 49 "\"dual\" - Initiator Modes will be enabled. Target Mode can be activated "
50 "when ready "
2d70c103
NB		 51 "\"enabled\" (default) - initiator mode will always stay enabled.");
52
99e1b683 53static int ql_dm_tgt_ex_pct = 0;
ead03855
QT		 54module_param(ql_dm_tgt_ex_pct, int, S_IRUGO|S_IWUSR);
55MODULE_PARM_DESC(ql_dm_tgt_ex_pct,
56 "For Dual Mode (qlini_mode=dual), this parameter determines "
57 "the percentage of exchanges/cmds FW will allocate resources "
58 "for Target mode.");
59
09620eeb
QT		 60int ql2xuctrlirq = 1;
61module_param(ql2xuctrlirq, int, 0644);
62MODULE_PARM_DESC(ql2xuctrlirq,
63 "User to control IRQ placement via smp_affinity."
64 "Valid with qlini_mode=disabled."
65 "1(default): enable");
66
aa230bc5 67int ql2x_ini_mode = QLA2XXX_INI_MODE_EXCLUSIVE;
2d70c103 68
7cf95f7e
QT		 69static int qla_sam_status = SAM_STAT_BUSY;
70static int tc_sam_status = SAM_STAT_TASK_SET_FULL; /* target core */
33e79977 71
2d70c103
NB		 72/*
73 * From scsi/fc/fc_fcp.h
74 */
75enum fcp_resp_rsp_codes {
76 FCP_TMF_CMPL = 0,
77 FCP_DATA_LEN_INVALID = 1,
78 FCP_CMND_FIELDS_INVALID = 2,
79 FCP_DATA_PARAM_MISMATCH = 3,
80 FCP_TMF_REJECTED = 4,
81 FCP_TMF_FAILED = 5,
82 FCP_TMF_INVALID_LUN = 9,
83};
84
85/*
86 * fc_pri_ta from scsi/fc/fc_fcp.h
87 */
88#define FCP_PTA_SIMPLE 0 /* simple task attribute */
89#define FCP_PTA_HEADQ 1 /* head of queue task attribute */
90#define FCP_PTA_ORDERED 2 /* ordered task attribute */
6efb3c0a 91#define FCP_PTA_ACA 4 /* auto. contingent allegiance */
2d70c103
NB		 92#define FCP_PTA_MASK 7 /* mask for task attribute field */
93#define FCP_PRI_SHIFT 3 /* priority field starts in bit 3 */
94#define FCP_PRI_RESVD_MASK 0x80 /* reserved bits in priority field */
95
96/*
97 * This driver calls qla2x00_alloc_iocbs() and qla2x00_issue_marker(), which
98 * must be called under HW lock and could unlock/lock it inside.
99 * It isn't an issue, since in the current implementation on the time when
100 * those functions are called:
101 *
102 * - Either context is IRQ and only IRQ handler can modify HW data,
103 * including rings related fields,
104 *
105 * - Or access to target mode variables from struct qla_tgt doesn't
106 * cross those functions boundaries, except tgt_stop, which
107 * additionally protected by irq_cmd_count.
108 */
109/* Predefs for callbacks handed to qla2xxx LLD */
110static void qlt_24xx_atio_pkt(struct scsi_qla_host *ha,
2f424b9b 111 struct atio_from_isp *pkt, uint8_t);
82de802a
QT		 112static void qlt_response_pkt(struct scsi_qla_host *ha, struct rsp_que *rsp,
113 response_t *pkt);
5d964837 114static int qlt_issue_task_mgmt(struct fc_port *sess, u64 lun,
2d70c103 115 int fn, void *iocb, int flags);
82de802a 116static void qlt_send_term_exchange(struct qla_qpair *, struct qla_tgt_cmd
a07100e0 117 *cmd, struct atio_from_isp *atio, int ha_locked, int ul_abort);
33e79977
QT		 118static void qlt_alloc_qfull_cmd(struct scsi_qla_host *vha,
119 struct atio_from_isp *atio, uint16_t status, int qfull);
55a9066f 120static void qlt_disable_vha(struct scsi_qla_host *vha);
b2032fd5 121static void qlt_clear_tgt_db(struct qla_tgt *tgt);
82de802a 122static void qlt_send_notify_ack(struct qla_qpair *qpair,
a6ca8878
AP		 123 struct imm_ntfy_from_isp *ntfy,
124 uint32_t add_flags, uint16_t resp_code, int resp_code_valid,
125 uint16_t srr_flags, uint16_t srr_reject_code, uint8_t srr_explan);
b7bd104e
AP		 126static void qlt_send_term_imm_notif(struct scsi_qla_host *vha,
127 struct imm_ntfy_from_isp *imm, int ha_locked);
726b8548
QT		 128static struct fc_port *qlt_create_sess(struct scsi_qla_host *vha,
129 fc_port_t *fcport, bool local);
130void qlt_unreg_sess(struct fc_port *sess);
8f6fc8d4
QT		 131static void qlt_24xx_handle_abts(struct scsi_qla_host *,
132 struct abts_recv_from_24xx *);
82de802a
QT		 133static void qlt_send_busy(struct qla_qpair *, struct atio_from_isp *,
134 uint16_t);
6b0431d6
QT		 135static int qlt_check_reserve_free_req(struct qla_qpair *qpair, uint32_t);
136static inline uint32_t qlt_make_handle(struct qla_qpair *);
8f6fc8d4 137
2d70c103
NB		 138/*
139 * Global Variables
140 */
2d70c103 141static struct kmem_cache *qla_tgt_mgmt_cmd_cachep;
b5d15312 142struct kmem_cache *qla_tgt_plogi_cachep;
2d70c103
NB		 143static mempool_t *qla_tgt_mgmt_cmd_mempool;
144static struct workqueue_struct *qla_tgt_wq;
145static DEFINE_MUTEX(qla_tgt_mutex);
146static LIST_HEAD(qla_tgt_glist);
147
be25152c
QT		 148static const char *prot_op_str(u32 prot_op)
149{
150 switch (prot_op) {
151 case TARGET_PROT_NORMAL: return "NORMAL";
152 case TARGET_PROT_DIN_INSERT: return "DIN_INSERT";
153 case TARGET_PROT_DOUT_INSERT: return "DOUT_INSERT";
154 case TARGET_PROT_DIN_STRIP: return "DIN_STRIP";
155 case TARGET_PROT_DOUT_STRIP: return "DOUT_STRIP";
156 case TARGET_PROT_DIN_PASS: return "DIN_PASS";
157 case TARGET_PROT_DOUT_PASS: return "DOUT_PASS";
158 default: return "UNKNOWN";
159 }
160}
161
df673274
AP		 162/* This API intentionally takes dest as a parameter, rather than returning
163 * int value to avoid caller forgetting to issue wmb() after the store */
164void qlt_do_generation_tick(struct scsi_qla_host *vha, int *dest)
165{
166 scsi_qla_host_t *base_vha = pci_get_drvdata(vha->hw->pdev);
167 *dest = atomic_inc_return(&base_vha->generation_tick);
168 /* memory barrier */
169 wmb();
170}
171
2d70c103
NB		 172/* Might release hw lock, then reaquire!! */
173static inline int qlt_issue_marker(struct scsi_qla_host *vha, int vha_locked)
174{
175 /* Send marker if required */
176 if (unlikely(vha->marker_needed != 0)) {
177 int rc = qla2x00_issue_marker(vha, vha_locked);
bd432bb5 178
2d70c103
NB		 179 if (rc != QLA_SUCCESS) {
180 ql_dbg(ql_dbg_tgt, vha, 0xe03d,
181 "qla_target(%d): issue_marker() failed\n",
182 vha->vp_idx);
183 }
184 return rc;
185 }
186 return QLA_SUCCESS;
187}
188
189static inline
190struct scsi_qla_host *qlt_find_host_by_d_id(struct scsi_qla_host *vha,
df95f39a 191 be_id_t d_id)
2d70c103 192{
482c9dc7 193 struct scsi_qla_host *host;
aa20e38b 194 uint32_t key;
2d70c103 195
df95f39a
BVA		 196 if (vha->d_id.b.area == d_id.area &&
197 vha->d_id.b.domain == d_id.domain &&
198 vha->d_id.b.al_pa == d_id.al_pa)
2d70c103
NB		 199 return vha;
200
aa20e38b 201 key = be_to_port_id(d_id).b24;
2d70c103 202
482c9dc7
QT		 203 host = btree_lookup32(&vha->hw->tgt.host_map, key);
204 if (!host)
604e2e57 205 ql_dbg(ql_dbg_tgt_mgt + ql_dbg_verbose, vha, 0xf005,
83548fe2 206 "Unable to find host %06x\n", key);
482c9dc7
QT		 207
208 return host;
2d70c103
NB		 209}
210
211static inline
212struct scsi_qla_host *qlt_find_host_by_vp_idx(struct scsi_qla_host *vha,
213 uint16_t vp_idx)
214{
215 struct qla_hw_data *ha = vha->hw;
216
217 if (vha->vp_idx == vp_idx)
218 return vha;
219
220 BUG_ON(ha->tgt.tgt_vp_map == NULL);
221 if (likely(test_bit(vp_idx, ha->vp_idx_map)))
222 return ha->tgt.tgt_vp_map[vp_idx].vha;
223
224 return NULL;
225}
226
33e79977
QT		 227static inline void qlt_incr_num_pend_cmds(struct scsi_qla_host *vha)
228{
229 unsigned long flags;
230
231 spin_lock_irqsave(&vha->hw->tgt.q_full_lock, flags);
232
233 vha->hw->tgt.num_pend_cmds++;
fc90adaf
JC		 234 if (vha->hw->tgt.num_pend_cmds > vha->qla_stats.stat_max_pend_cmds)
235 vha->qla_stats.stat_max_pend_cmds =
33e79977
QT		 236 vha->hw->tgt.num_pend_cmds;
237 spin_unlock_irqrestore(&vha->hw->tgt.q_full_lock, flags);
238}
239static inline void qlt_decr_num_pend_cmds(struct scsi_qla_host *vha)
240{
241 unsigned long flags;
242
243 spin_lock_irqsave(&vha->hw->tgt.q_full_lock, flags);
244 vha->hw->tgt.num_pend_cmds--;
245 spin_unlock_irqrestore(&vha->hw->tgt.q_full_lock, flags);
246}
247
41dc529a
QT		 248
249static void qlt_queue_unknown_atio(scsi_qla_host_t *vha,
82de802a 250 struct atio_from_isp *atio, uint8_t ha_locked)
41dc529a
QT		 251{
252 struct qla_tgt_sess_op *u;
253 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
254 unsigned long flags;
255
256 if (tgt->tgt_stop) {
83548fe2
QT		 257 ql_dbg(ql_dbg_async, vha, 0x502c,
258 "qla_target(%d): dropping unknown ATIO_TYPE7, because tgt is being stopped",
259 vha->vp_idx);
41dc529a
QT		 260 goto out_term;
261 }
262
263 u = kzalloc(sizeof(*u), GFP_ATOMIC);
83548fe2 264 if (u == NULL)
41dc529a 265 goto out_term;
41dc529a
QT		 266
267 u->vha = vha;
268 memcpy(&u->atio, atio, sizeof(*atio));
269 INIT_LIST_HEAD(&u->cmd_list);
270
271 spin_lock_irqsave(&vha->cmd_list_lock, flags);
272 list_add_tail(&u->cmd_list, &vha->unknown_atio_list);
273 spin_unlock_irqrestore(&vha->cmd_list_lock, flags);
274
275 schedule_delayed_work(&vha->unknown_atio_work, 1);
276
277out:
278 return;
279
280out_term:
82de802a 281 qlt_send_term_exchange(vha->hw->base_qpair, NULL, atio, ha_locked, 0);
41dc529a
QT		 282 goto out;
283}
284
285static void qlt_try_to_dequeue_unknown_atios(struct scsi_qla_host *vha,
286 uint8_t ha_locked)
287{
288 struct qla_tgt_sess_op *u, *t;
289 scsi_qla_host_t *host;
290 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
291 unsigned long flags;
292 uint8_t queued = 0;
293
294 list_for_each_entry_safe(u, t, &vha->unknown_atio_list, cmd_list) {
295 if (u->aborted) {
83548fe2
QT		 296 ql_dbg(ql_dbg_async, vha, 0x502e,
297 "Freeing unknown %s %p, because of Abort\n",
41dc529a 298 "ATIO_TYPE7", u);
82de802a
QT		 299 qlt_send_term_exchange(vha->hw->base_qpair, NULL,
300 &u->atio, ha_locked, 0);
41dc529a
QT		 301 goto abort;
302 }
303
304 host = qlt_find_host_by_d_id(vha, u->atio.u.isp24.fcp_hdr.d_id);
305 if (host != NULL) {
604e2e57 306 ql_dbg(ql_dbg_async + ql_dbg_verbose, vha, 0x502f,
83548fe2 307 "Requeuing unknown ATIO_TYPE7 %p\n", u);
41dc529a
QT		 308 qlt_24xx_atio_pkt(host, &u->atio, ha_locked);
309 } else if (tgt->tgt_stop) {
604e2e57 310 ql_dbg(ql_dbg_async + ql_dbg_verbose, vha, 0x503a,
83548fe2
QT		 311 "Freeing unknown %s %p, because tgt is being stopped\n",
312 "ATIO_TYPE7", u);
82de802a
QT		 313 qlt_send_term_exchange(vha->hw->base_qpair, NULL,
314 &u->atio, ha_locked, 0);
41dc529a 315 } else {
604e2e57 316 ql_dbg(ql_dbg_async + ql_dbg_verbose, vha, 0x503d,
83548fe2 317 "Reschedule u %p, vha %p, host %p\n", u, vha, host);
41dc529a
QT		 318 if (!queued) {
319 queued = 1;
320 schedule_delayed_work(&vha->unknown_atio_work,
321 1);
322 }
323 continue;
324 }
325
326abort:
327 spin_lock_irqsave(&vha->cmd_list_lock, flags);
328 list_del(&u->cmd_list);
329 spin_unlock_irqrestore(&vha->cmd_list_lock, flags);
330 kfree(u);
331 }
332}
333
334void qlt_unknown_atio_work_fn(struct work_struct *work)
335{
336 struct scsi_qla_host *vha = container_of(to_delayed_work(work),
337 struct scsi_qla_host, unknown_atio_work);
338
339 qlt_try_to_dequeue_unknown_atios(vha, 0);
340}
341
3bb67df5 342static bool qlt_24xx_atio_pkt_all_vps(struct scsi_qla_host *vha,
2f424b9b 343 struct atio_from_isp *atio, uint8_t ha_locked)
2d70c103 344{
f83adb61
QT		 345 ql_dbg(ql_dbg_tgt, vha, 0xe072,
346 "%s: qla_target(%d): type %x ox_id %04x\n",
347 __func__, vha->vp_idx, atio->u.raw.entry_type,
348 be16_to_cpu(atio->u.isp24.fcp_hdr.ox_id));
349
2d70c103
NB		 350 switch (atio->u.raw.entry_type) {
351 case ATIO_TYPE7:
352 {
353 struct scsi_qla_host *host = qlt_find_host_by_d_id(vha,
354 atio->u.isp24.fcp_hdr.d_id);
355 if (unlikely(NULL == host)) {
356 ql_dbg(ql_dbg_tgt, vha, 0xe03e,
357 "qla_target(%d): Received ATIO_TYPE7 "
358 "with unknown d_id %x:%x:%x\n", vha->vp_idx,
df95f39a
BVA		 359 atio->u.isp24.fcp_hdr.d_id.domain,
360 atio->u.isp24.fcp_hdr.d_id.area,
361 atio->u.isp24.fcp_hdr.d_id.al_pa);
41dc529a
QT		 362
363
364 qlt_queue_unknown_atio(vha, atio, ha_locked);
2d70c103
NB		 365 break;
366 }
41dc529a
QT		 367 if (unlikely(!list_empty(&vha->unknown_atio_list)))
368 qlt_try_to_dequeue_unknown_atios(vha, ha_locked);
369
2f424b9b 370 qlt_24xx_atio_pkt(host, atio, ha_locked);
2d70c103
NB		 371 break;
372 }
373
374 case IMMED_NOTIFY_TYPE:
375 {
376 struct scsi_qla_host *host = vha;
377 struct imm_ntfy_from_isp *entry =
378 (struct imm_ntfy_from_isp *)atio;
379
82de802a
QT		 380 qlt_issue_marker(vha, ha_locked);
381
2d70c103
NB		 382 if ((entry->u.isp24.vp_index != 0xFF) &&
383 (entry->u.isp24.nport_handle != 0xFFFF)) {
384 host = qlt_find_host_by_vp_idx(vha,
385 entry->u.isp24.vp_index);
386 if (unlikely(!host)) {
387 ql_dbg(ql_dbg_tgt, vha, 0xe03f,
388 "qla_target(%d): Received "
389 "ATIO (IMMED_NOTIFY_TYPE) "
390 "with unknown vp_index %d\n",
391 vha->vp_idx, entry->u.isp24.vp_index);
392 break;
393 }
394 }
2f424b9b 395 qlt_24xx_atio_pkt(host, atio, ha_locked);
2d70c103
NB		 396 break;
397 }
398
41dc529a
QT		 399 case VP_RPT_ID_IOCB_TYPE:
400 qla24xx_report_id_acquisition(vha,
401 (struct vp_rpt_id_entry_24xx *)atio);
402 break;
403
404 case ABTS_RECV_24XX:
405 {
406 struct abts_recv_from_24xx *entry =
407 (struct abts_recv_from_24xx *)atio;
408 struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
409 entry->vp_index);
8f6fc8d4
QT		 410 unsigned long flags;
411
41dc529a 412 if (unlikely(!host)) {
83548fe2 413 ql_dbg(ql_dbg_tgt, vha, 0xe00a,
41dc529a
QT		 414 "qla_target(%d): Response pkt (ABTS_RECV_24XX) "
415 "received, with unknown vp_index %d\n",
416 vha->vp_idx, entry->vp_index);
417 break;
418 }
8f6fc8d4
QT		 419 if (!ha_locked)
420 spin_lock_irqsave(&host->hw->hardware_lock, flags);
421 qlt_24xx_handle_abts(host, (struct abts_recv_from_24xx *)atio);
422 if (!ha_locked)
423 spin_unlock_irqrestore(&host->hw->hardware_lock, flags);
41dc529a 424 break;
41dc529a
QT		 425 }
426
427 /* case PUREX_IOCB_TYPE: ql2xmvasynctoatio */
428
2d70c103
NB		 429 default:
430 ql_dbg(ql_dbg_tgt, vha, 0xe040,
431 "qla_target(%d): Received unknown ATIO atio "
432 "type %x\n", vha->vp_idx, atio->u.raw.entry_type);
433 break;
434 }
435
3bb67df5 436 return false;
2d70c103
NB		 437}
438
82de802a
QT		 439void qlt_response_pkt_all_vps(struct scsi_qla_host *vha,
440 struct rsp_que *rsp, response_t *pkt)
2d70c103
NB		 441{
442 switch (pkt->entry_type) {
f83adb61
QT		 443 case CTIO_CRC2:
444 ql_dbg(ql_dbg_tgt, vha, 0xe073,
445 "qla_target(%d):%s: CRC2 Response pkt\n",
446 vha->vp_idx, __func__);
81881861 447 /* fall through */
2d70c103
NB		 448 case CTIO_TYPE7:
449 {
450 struct ctio7_from_24xx *entry = (struct ctio7_from_24xx *)pkt;
451 struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
452 entry->vp_index);
453 if (unlikely(!host)) {
454 ql_dbg(ql_dbg_tgt, vha, 0xe041,
455 "qla_target(%d): Response pkt (CTIO_TYPE7) "
456 "received, with unknown vp_index %d\n",
457 vha->vp_idx, entry->vp_index);
458 break;
459 }
82de802a 460 qlt_response_pkt(host, rsp, pkt);
2d70c103
NB		 461 break;
462 }
463
464 case IMMED_NOTIFY_TYPE:
465 {
466 struct scsi_qla_host *host = vha;
467 struct imm_ntfy_from_isp *entry =
468 (struct imm_ntfy_from_isp *)pkt;
469
470 host = qlt_find_host_by_vp_idx(vha, entry->u.isp24.vp_index);
471 if (unlikely(!host)) {
472 ql_dbg(ql_dbg_tgt, vha, 0xe042,
473 "qla_target(%d): Response pkt (IMMED_NOTIFY_TYPE) "
474 "received, with unknown vp_index %d\n",
475 vha->vp_idx, entry->u.isp24.vp_index);
476 break;
477 }
82de802a 478 qlt_response_pkt(host, rsp, pkt);
2d70c103
NB		 479 break;
480 }
481
482 case NOTIFY_ACK_TYPE:
483 {
484 struct scsi_qla_host *host = vha;
485 struct nack_to_isp *entry = (struct nack_to_isp *)pkt;
486
487 if (0xFF != entry->u.isp24.vp_index) {
488 host = qlt_find_host_by_vp_idx(vha,
489 entry->u.isp24.vp_index);
490 if (unlikely(!host)) {
491 ql_dbg(ql_dbg_tgt, vha, 0xe043,
492 "qla_target(%d): Response "
493 "pkt (NOTIFY_ACK_TYPE) "
494 "received, with unknown "
495 "vp_index %d\n", vha->vp_idx,
496 entry->u.isp24.vp_index);
497 break;
498 }
499 }
82de802a 500 qlt_response_pkt(host, rsp, pkt);
2d70c103
NB		 501 break;
502 }
503
504 case ABTS_RECV_24XX:
505 {
506 struct abts_recv_from_24xx *entry =
507 (struct abts_recv_from_24xx *)pkt;
508 struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
509 entry->vp_index);
510 if (unlikely(!host)) {
511 ql_dbg(ql_dbg_tgt, vha, 0xe044,
512 "qla_target(%d): Response pkt "
513 "(ABTS_RECV_24XX) received, with unknown "
514 "vp_index %d\n", vha->vp_idx, entry->vp_index);
515 break;
516 }
82de802a 517 qlt_response_pkt(host, rsp, pkt);
2d70c103
NB		 518 break;
519 }
520
521 case ABTS_RESP_24XX:
522 {
523 struct abts_resp_to_24xx *entry =
524 (struct abts_resp_to_24xx *)pkt;
525 struct scsi_qla_host *host = qlt_find_host_by_vp_idx(vha,
526 entry->vp_index);
527 if (unlikely(!host)) {
528 ql_dbg(ql_dbg_tgt, vha, 0xe045,
529 "qla_target(%d): Response pkt "
530 "(ABTS_RECV_24XX) received, with unknown "
531 "vp_index %d\n", vha->vp_idx, entry->vp_index);
532 break;
533 }
82de802a 534 qlt_response_pkt(host, rsp, pkt);
2d70c103
NB		 535 break;
536 }
2d70c103 537 default:
82de802a 538 qlt_response_pkt(vha, rsp, pkt);
2d70c103
NB		 539 break;
540 }
541
542}
543
b7bd104e
AP		 544/*
545 * All qlt_plogi_ack_t operations are protected by hardware_lock
546 */
726b8548
QT		 547static int qla24xx_post_nack_work(struct scsi_qla_host *vha, fc_port_t *fcport,
548 struct imm_ntfy_from_isp *ntfy, int type)
549{
550 struct qla_work_evt *e;
bd432bb5 551
726b8548
QT		 552 e = qla2x00_alloc_work(vha, QLA_EVT_NACK);
553 if (!e)
554 return QLA_FUNCTION_FAILED;
555
556 e->u.nack.fcport = fcport;
557 e->u.nack.type = type;
558 memcpy(e->u.nack.iocb, ntfy, sizeof(struct imm_ntfy_from_isp));
559 return qla2x00_post_work(vha, e);
560}
561
6c18a43e 562static void qla2x00_async_nack_sp_done(srb_t *sp, int res)
726b8548 563{
25ff6af1 564 struct scsi_qla_host *vha = sp->vha;
726b8548
QT		 565 unsigned long flags;
566
83548fe2
QT		 567 ql_dbg(ql_dbg_disc, vha, 0x20f2,
568 "Async done-%s res %x %8phC type %d\n",
569 sp->name, res, sp->fcport->port_name, sp->type);
726b8548
QT		 570
571 spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
572 sp->fcport->flags &= ~FCF_ASYNC_SENT;
7c3f8fd1 573 sp->fcport->chip_reset = vha->hw->base_qpair->chip_reset;
726b8548
QT		 574
575 switch (sp->type) {
576 case SRB_NACK_PLOGI:
577 sp->fcport->login_gen++;
578 sp->fcport->fw_login_state = DSC_LS_PLOGI_COMP;
579 sp->fcport->logout_on_delete = 1;
5b33469a 580 sp->fcport->plogi_nack_done_deadline = jiffies + HZ;
3515832c 581 sp->fcport->send_els_logo = 0;
726b8548
QT		 582 break;
583
584 case SRB_NACK_PRLI:
585 sp->fcport->fw_login_state = DSC_LS_PRLI_COMP;
586 sp->fcport->deleted = 0;
3515832c 587 sp->fcport->send_els_logo = 0;
726b8548
QT		 588
589 if (!sp->fcport->login_succ &&
590 !IS_SW_RESV_ADDR(sp->fcport->d_id)) {
591 sp->fcport->login_succ = 1;
592
593 vha->fcport_count++;
0aca7784 594 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
cd4ed6b4 595 qla24xx_sched_upd_fcport(sp->fcport);
0aca7784 596 spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
29528491
QT		 597 } else {
598 sp->fcport->login_retry = 0;
599 sp->fcport->disc_state = DSC_LOGIN_COMPLETE;
600 sp->fcport->deleted = 0;
601 sp->fcport->logout_on_delete = 1;
726b8548
QT		 602 }
603 break;
604
605 case SRB_NACK_LOGO:
606 sp->fcport->login_gen++;
607 sp->fcport->fw_login_state = DSC_LS_PORT_UNAVAIL;
608 qlt_logo_completion_handler(sp->fcport, MBS_COMMAND_COMPLETE);
609 break;
610 }
611 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
612
25ff6af1 613 sp->free(sp);
726b8548
QT		 614}
615
616int qla24xx_async_notify_ack(scsi_qla_host_t *vha, fc_port_t *fcport,
617 struct imm_ntfy_from_isp *ntfy, int type)
618{
619 int rval = QLA_FUNCTION_FAILED;
620 srb_t *sp;
621 char *c = NULL;
622
623 fcport->flags |= FCF_ASYNC_SENT;
624 switch (type) {
625 case SRB_NACK_PLOGI:
626 fcport->fw_login_state = DSC_LS_PLOGI_PEND;
627 c = "PLOGI";
628 break;
629 case SRB_NACK_PRLI:
630 fcport->fw_login_state = DSC_LS_PRLI_PEND;
ec7193e2 631 fcport->deleted = 0;
726b8548
QT		 632 c = "PRLI";
633 break;
634 case SRB_NACK_LOGO:
635 fcport->fw_login_state = DSC_LS_LOGO_PEND;
636 c = "LOGO";
637 break;
638 }
639
640 sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
641 if (!sp)
642 goto done;
643
644 sp->type = type;
645 sp->name = "nack";
646
e74e7d95 647 sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
726b8548
QT		 648 qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha)+2);
649
650 sp->u.iocb_cmd.u.nack.ntfy = ntfy;
726b8548
QT		 651 sp->done = qla2x00_async_nack_sp_done;
652
83548fe2
QT		 653 ql_dbg(ql_dbg_disc, vha, 0x20f4,
654 "Async-%s %8phC hndl %x %s\n",
655 sp->name, fcport->port_name, sp->handle, c);
726b8548 656
f233e8c0
BK		 657 rval = qla2x00_start_sp(sp);
658 if (rval != QLA_SUCCESS)
659 goto done_free_sp;
660
726b8548
QT		 661 return rval;
662
663done_free_sp:
25ff6af1 664 sp->free(sp);
726b8548
QT		 665done:
666 fcport->flags &= ~FCF_ASYNC_SENT;
667 return rval;
668}
669
670void qla24xx_do_nack_work(struct scsi_qla_host *vha, struct qla_work_evt *e)
671{
672 fc_port_t *t;
726b8548
QT		 673
674 switch (e->u.nack.type) {
675 case SRB_NACK_PRLI:
1021f0bc
QT		 676 t = e->u.nack.fcport;
677 flush_work(&t->del_work);
678 flush_work(&t->free_work);
726b8548
QT		 679 mutex_lock(&vha->vha_tgt.tgt_mutex);
680 t = qlt_create_sess(vha, e->u.nack.fcport, 0);
681 mutex_unlock(&vha->vha_tgt.tgt_mutex);
682 if (t) {
83548fe2 683 ql_log(ql_log_info, vha, 0xd034,
726b8548 684 "%s create sess success %p", __func__, t);
726b8548
QT		 685 /* create sess has an extra kref */
686 vha->hw->tgt.tgt_ops->put_sess(e->u.nack.fcport);
726b8548
QT		 687 }
688 break;
689 }
690 qla24xx_async_notify_ack(vha, e->u.nack.fcport,
845bbb09 691 (struct imm_ntfy_from_isp *)e->u.nack.iocb, e->u.nack.type);
726b8548
QT		 692}
693
694void qla24xx_delete_sess_fn(struct work_struct *work)
695{
696 fc_port_t *fcport = container_of(work, struct fc_port, del_work);
697 struct qla_hw_data *ha = fcport->vha->hw;
726b8548
QT		 698
699 if (fcport->se_sess) {
700 ha->tgt.tgt_ops->shutdown_sess(fcport);
701 ha->tgt.tgt_ops->put_sess(fcport);
702 } else {
703 qlt_unreg_sess(fcport);
704 }
726b8548
QT		 705}
706
707/*
708 * Called from qla2x00_reg_remote_port()
709 */
710void qlt_fc_port_added(struct scsi_qla_host *vha, fc_port_t *fcport)
711{
712 struct qla_hw_data *ha = vha->hw;
713 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
714 struct fc_port *sess = fcport;
715 unsigned long flags;
716
717 if (!vha->hw->tgt.tgt_ops)
718 return;
719
720 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
721 if (tgt->tgt_stop) {
722 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
723 return;
724 }
725
726 if (fcport->disc_state == DSC_DELETE_PEND) {
727 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
728 return;
729 }
730
731 if (!sess->se_sess) {
732 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
733
734 mutex_lock(&vha->vha_tgt.tgt_mutex);
735 sess = qlt_create_sess(vha, fcport, false);
736 mutex_unlock(&vha->vha_tgt.tgt_mutex);
737
738 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
739 } else {
740 if (fcport->fw_login_state == DSC_LS_PRLI_COMP) {
741 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
742 return;
743 }
744
745 if (!kref_get_unless_zero(&sess->sess_kref)) {
83548fe2 746 ql_dbg(ql_dbg_disc, vha, 0x2107,
726b8548
QT		 747 "%s: kref_get fail sess %8phC \n",
748 __func__, sess->port_name);
749 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
750 return;
751 }
752
753 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf04c,
754 "qla_target(%u): %ssession for port %8phC "
755 "(loop ID %d) reappeared\n", vha->vp_idx,
756 sess->local ? "local " : "", sess->port_name, sess->loop_id);
757
758 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf007,
759 "Reappeared sess %p\n", sess);
760
761 ha->tgt.tgt_ops->update_sess(sess, fcport->d_id,
762 fcport->loop_id,
763 (fcport->flags & FCF_CONF_COMP_SUPPORTED));
764 }
765
766 if (sess && sess->local) {
767 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf04d,
768 "qla_target(%u): local session for "
769 "port %8phC (loop ID %d) became global\n", vha->vp_idx,
770 fcport->port_name, sess->loop_id);
771 sess->local = 0;
772 }
726b8548 773 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
300ec741
BVA		 774
775 ha->tgt.tgt_ops->put_sess(sess);
726b8548 776}
b7bd104e
AP		 777
778/*
779 * This is a zero-base ref-counting solution, since hardware_lock
780 * guarantees that ref_count is not modified concurrently.
781 * Upon successful return content of iocb is undefined
782 */
5d964837 783static struct qlt_plogi_ack_t *
b7bd104e
AP		 784qlt_plogi_ack_find_add(struct scsi_qla_host *vha, port_id_t *id,
785 struct imm_ntfy_from_isp *iocb)
786{
5d964837 787 struct qlt_plogi_ack_t *pla;
b7bd104e 788
57bf595a
BVA		 789 lockdep_assert_held(&vha->hw->hardware_lock);
790
b7bd104e
AP		 791 list_for_each_entry(pla, &vha->plogi_ack_list, list) {
792 if (pla->id.b24 == id->b24) {
48acad09
QT		 793 ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x210d,
794 "%s %d %8phC Term INOT due to new INOT",
795 __func__, __LINE__,
796 pla->iocb.u.isp24.port_name);
b7bd104e 797 qlt_send_term_imm_notif(vha, &pla->iocb, 1);
5d964837 798 memcpy(&pla->iocb, iocb, sizeof(pla->iocb));
b7bd104e
AP		 799 return pla;
800 }
801 }
802
803 pla = kmem_cache_zalloc(qla_tgt_plogi_cachep, GFP_ATOMIC);
804 if (!pla) {
805 ql_dbg(ql_dbg_async, vha, 0x5088,
806 "qla_target(%d): Allocation of plogi_ack failed\n",
807 vha->vp_idx);
808 return NULL;
809 }
810
5d964837 811 memcpy(&pla->iocb, iocb, sizeof(pla->iocb));
b7bd104e
AP		 812 pla->id = *id;
813 list_add_tail(&pla->list, &vha->plogi_ack_list);
814
815 return pla;
816}
817
726b8548 818void qlt_plogi_ack_unref(struct scsi_qla_host *vha,
5d964837 819 struct qlt_plogi_ack_t *pla)
b7bd104e 820{
5d964837 821 struct imm_ntfy_from_isp *iocb = &pla->iocb;
726b8548
QT		 822 port_id_t port_id;
823 uint16_t loop_id;
824 fc_port_t *fcport = pla->fcport;
825
b7bd104e
AP		 826 BUG_ON(!pla->ref_count);
827 pla->ref_count--;
828
829 if (pla->ref_count)
830 return;
831
726b8548 832 ql_dbg(ql_dbg_disc, vha, 0x5089,
b7bd104e 833 "Sending PLOGI ACK to wwn %8phC s_id %02x:%02x:%02x loop_id %#04x"
5d964837
QT		 834 " exch %#x ox_id %#x\n", iocb->u.isp24.port_name,
835 iocb->u.isp24.port_id[2], iocb->u.isp24.port_id[1],
836 iocb->u.isp24.port_id[0],
837 le16_to_cpu(iocb->u.isp24.nport_handle),
838 iocb->u.isp24.exchange_address, iocb->ox_id);
726b8548
QT		 839
840 port_id.b.domain = iocb->u.isp24.port_id[2];
841 port_id.b.area = iocb->u.isp24.port_id[1];
842 port_id.b.al_pa = iocb->u.isp24.port_id[0];
843 port_id.b.rsvd_1 = 0;
844
845 loop_id = le16_to_cpu(iocb->u.isp24.nport_handle);
846
847 fcport->loop_id = loop_id;
848 fcport->d_id = port_id;
9cd883f0
QT		 849 if (iocb->u.isp24.status_subcode == ELS_PLOGI)
850 qla24xx_post_nack_work(vha, fcport, iocb, SRB_NACK_PLOGI);
851 else
852 qla24xx_post_nack_work(vha, fcport, iocb, SRB_NACK_PRLI);
726b8548
QT		 853
854 list_for_each_entry(fcport, &vha->vp_fcports, list) {
855 if (fcport->plogi_link[QLT_PLOGI_LINK_SAME_WWN] == pla)
856 fcport->plogi_link[QLT_PLOGI_LINK_SAME_WWN] = NULL;
857 if (fcport->plogi_link[QLT_PLOGI_LINK_CONFLICT] == pla)
858 fcport->plogi_link[QLT_PLOGI_LINK_CONFLICT] = NULL;
859 }
b7bd104e
AP		 860
861 list_del(&pla->list);
862 kmem_cache_free(qla_tgt_plogi_cachep, pla);
863}
864
726b8548 865void
5d964837
QT		 866qlt_plogi_ack_link(struct scsi_qla_host *vha, struct qlt_plogi_ack_t *pla,
867 struct fc_port *sess, enum qlt_plogi_link_t link)
b7bd104e 868{
5d964837 869 struct imm_ntfy_from_isp *iocb = &pla->iocb;
b7bd104e
AP		 870 /* Inc ref_count first because link might already be pointing at pla */
871 pla->ref_count++;
872
726b8548
QT		 873 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf097,
874 "Linking sess %p [%d] wwn %8phC with PLOGI ACK to wwn %8phC"
875 " s_id %02x:%02x:%02x, ref=%d pla %p link %d\n",
876 sess, link, sess->port_name,
877 iocb->u.isp24.port_name, iocb->u.isp24.port_id[2],
878 iocb->u.isp24.port_id[1], iocb->u.isp24.port_id[0],
879 pla->ref_count, pla, link);
880
5ef696aa
QT		 881 if (link == QLT_PLOGI_LINK_CONFLICT) {
882 switch (sess->disc_state) {
883 case DSC_DELETED:
884 case DSC_DELETE_PEND:
885 pla->ref_count--;
886 return;
887 default:
888 break;
889 }
890 }
891
b7bd104e
AP		 892 if (sess->plogi_link[link])
893 qlt_plogi_ack_unref(vha, sess->plogi_link[link]);
894
726b8548
QT		 895 if (link == QLT_PLOGI_LINK_SAME_WWN)
896 pla->fcport = sess;
b7bd104e
AP		 897
898 sess->plogi_link[link] = pla;
899}
900
71cdc079
AP		 901typedef struct {
902 /* These fields must be initialized by the caller */
903 port_id_t id;
904 /*
905 * number of cmds dropped while we were waiting for
906 * initiator to ack LOGO initialize to 1 if LOGO is
907 * triggered by a command, otherwise, to 0
908 */
909 int cmd_count;
910
911 /* These fields are used by callee */
912 struct list_head list;
913} qlt_port_logo_t;
914
915static void
916qlt_send_first_logo(struct scsi_qla_host *vha, qlt_port_logo_t *logo)
917{
918 qlt_port_logo_t *tmp;
919 int res;
920
921 mutex_lock(&vha->vha_tgt.tgt_mutex);
922
923 list_for_each_entry(tmp, &vha->logo_list, list) {
924 if (tmp->id.b24 == logo->id.b24) {
925 tmp->cmd_count += logo->cmd_count;
926 mutex_unlock(&vha->vha_tgt.tgt_mutex);
927 return;
928 }
929 }
930
931 list_add_tail(&logo->list, &vha->logo_list);
932
933 mutex_unlock(&vha->vha_tgt.tgt_mutex);
934
935 res = qla24xx_els_dcmd_iocb(vha, ELS_DCMD_LOGO, logo->id);
936
937 mutex_lock(&vha->vha_tgt.tgt_mutex);
938 list_del(&logo->list);
939 mutex_unlock(&vha->vha_tgt.tgt_mutex);
940
b7bd104e
AP		 941 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf098,
942 "Finished LOGO to %02x:%02x:%02x, dropped %d cmds, res = %#x\n",
943 logo->id.b.domain, logo->id.b.area, logo->id.b.al_pa,
944 logo->cmd_count, res);
71cdc079
AP		 945}
946
9dd9686b 947void qlt_free_session_done(struct work_struct *work)
2d70c103 948{
5d964837 949 struct fc_port *sess = container_of(work, struct fc_port,
2d70c103
NB		 950 free_work);
951 struct qla_tgt *tgt = sess->tgt;
952 struct scsi_qla_host *vha = sess->vha;
953 struct qla_hw_data *ha = vha->hw;
a6ca8878
AP		 954 unsigned long flags;
955 bool logout_started = false;
41dc529a 956 scsi_qla_host_t *base_vha;
9cd883f0
QT		 957 struct qlt_plogi_ack_t *own =
958 sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN];
a6ca8878
AP		 959
960 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf084,
961 "%s: se_sess %p / sess %p from port %8phC loop_id %#04x"
b7bd104e 962 " s_id %02x:%02x:%02x logout %d keep %d els_logo %d\n",
a6ca8878 963 __func__, sess->se_sess, sess, sess->port_name, sess->loop_id,
37cacc0a 964 sess->d_id.b.domain, sess->d_id.b.area, sess->d_id.b.al_pa,
a6ca8878 965 sess->logout_on_delete, sess->keep_nport_handle,
b7bd104e 966 sess->send_els_logo);
2d70c103 967
726b8548 968 if (!IS_SW_RESV_ADDR(sess->d_id)) {
2137490f
QT		 969 qla2x00_mark_device_lost(vha, sess, 0, 0);
970
41dc529a
QT		 971 if (sess->send_els_logo) {
972 qlt_port_logo_t logo;
71cdc079 973
41dc529a
QT		 974 logo.id = sess->d_id;
975 logo.cmd_count = 0;
cb97f2c2
QT		 976 if (!own)
977 qlt_send_first_logo(vha, &logo);
a2390348 978 sess->send_els_logo = 0;
41dc529a
QT		 979 }
980
ba743f91 981 if (sess->logout_on_delete && sess->loop_id != FC_NO_LOOP_ID) {
41dc529a
QT		 982 int rc;
983
9cd883f0
QT		 984 if (!own ||
985 (own &&
986 (own->iocb.u.isp24.status_subcode == ELS_PLOGI))) {
987 rc = qla2x00_post_async_logout_work(vha, sess,
988 NULL);
989 if (rc != QLA_SUCCESS)
990 ql_log(ql_log_warn, vha, 0xf085,
991 "Schedule logo failed sess %p rc %d\n",
992 sess, rc);
993 else
994 logout_started = true;
995 } else if (own && (own->iocb.u.isp24.status_subcode ==
996 ELS_PRLI) && ha->flags.rida_fmt2) {
997 rc = qla2x00_post_async_prlo_work(vha, sess,
998 NULL);
999 if (rc != QLA_SUCCESS)
1000 ql_log(ql_log_warn, vha, 0xf085,
1001 "Schedule PRLO failed sess %p rc %d\n",
1002 sess, rc);
1003 else
1004 logout_started = true;
1005 }
baf23edd
QT		 1006 } /* if sess->logout_on_delete */
1007
1008 if (sess->nvme_flag & NVME_FLAG_REGISTERED &&
1009 !(sess->nvme_flag & NVME_FLAG_DELETING)) {
1010 sess->nvme_flag |= NVME_FLAG_DELETING;
1011 qla_nvme_unregister_remote_port(sess);
41dc529a 1012 }
726b8548 1013 }
a6ca8878 1014
2d70c103
NB		 1015 /*
1016 * Release the target session for FC Nexus from fabric module code.
1017 */
1018 if (sess->se_sess != NULL)
1019 ha->tgt.tgt_ops->free_session(sess);
1020
a6ca8878
AP		 1021 if (logout_started) {
1022 bool traced = false;
1023
6aa7de05 1024 while (!READ_ONCE(sess->logout_completed)) {
a6ca8878
AP		 1025 if (!traced) {
1026 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf086,
1027 "%s: waiting for sess %p logout\n",
1028 __func__, sess);
1029 traced = true;
1030 }
1031 msleep(100);
1032 }
1033
726b8548 1034 ql_dbg(ql_dbg_disc, vha, 0xf087,
9cd883f0 1035 "%s: sess %p logout completed\n", __func__, sess);
41dc529a
QT		 1036 }
1037
1038 if (sess->logo_ack_needed) {
1039 sess->logo_ack_needed = 0;
1040 qla24xx_async_notify_ack(vha, sess,
1041 (struct imm_ntfy_from_isp *)sess->iocb, SRB_NACK_LOGO);
a6ca8878
AP		 1042 }
1043
726b8548
QT		 1044 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
1045 if (sess->se_sess) {
1046 sess->se_sess = NULL;
1047 if (tgt && !IS_SW_RESV_ADDR(sess->d_id))
1048 tgt->sess_count--;
1049 }
1050
1051 sess->disc_state = DSC_DELETED;
1052 sess->fw_login_state = DSC_LS_PORT_UNAVAIL;
1053 sess->deleted = QLA_SESS_DELETED;
726b8548
QT		 1054
1055 if (sess->login_succ && !IS_SW_RESV_ADDR(sess->d_id)) {
1056 vha->fcport_count--;
1057 sess->login_succ = 0;
1058 }
1059
ba743f91 1060 qla2x00_clear_loop_id(sess);
726b8548
QT		 1061
1062 if (sess->conflict) {
1063 sess->conflict->login_pause = 0;
1064 sess->conflict = NULL;
1065 if (!test_bit(UNLOADING, &vha->dpc_flags))
1066 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1067 }
1068
b7bd104e 1069 {
5d964837 1070 struct qlt_plogi_ack_t *con =
b7bd104e 1071 sess->plogi_link[QLT_PLOGI_LINK_CONFLICT];
5d964837 1072 struct imm_ntfy_from_isp *iocb;
bd432bb5 1073
48acad09 1074 own = sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN];
b7bd104e
AP		 1075
1076 if (con) {
5d964837 1077 iocb = &con->iocb;
b7bd104e 1078 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf099,
5d964837
QT		 1079 "se_sess %p / sess %p port %8phC is gone,"
1080 " %s (ref=%d), releasing PLOGI for %8phC (ref=%d)\n",
1081 sess->se_sess, sess, sess->port_name,
1082 own ? "releasing own PLOGI" : "no own PLOGI pending",
1083 own ? own->ref_count : -1,
1084 iocb->u.isp24.port_name, con->ref_count);
b7bd104e 1085 qlt_plogi_ack_unref(vha, con);
726b8548 1086 sess->plogi_link[QLT_PLOGI_LINK_CONFLICT] = NULL;
b7bd104e
AP		 1087 } else {
1088 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf09a,
1089 "se_sess %p / sess %p port %8phC is gone, %s (ref=%d)\n",
1090 sess->se_sess, sess, sess->port_name,
1091 own ? "releasing own PLOGI" :
1092 "no own PLOGI pending",
1093 own ? own->ref_count : -1);
1094 }
1095
726b8548
QT		 1096 if (own) {
1097 sess->fw_login_state = DSC_LS_PLOGI_PEND;
b7bd104e 1098 qlt_plogi_ack_unref(vha, own);
726b8548
QT		 1099 sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN] = NULL;
1100 }
b7bd104e 1101 }
1ae634eb 1102
5d964837
QT		 1103 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
1104
2d70c103 1105 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf001,
726b8548
QT		 1106 "Unregistration of sess %p %8phC finished fcp_cnt %d\n",
1107 sess, sess->port_name, vha->fcport_count);
2d70c103 1108
726b8548 1109 if (tgt && (tgt->sess_count == 0))
2d70c103 1110 wake_up_all(&tgt->waitQ);
726b8548
QT		 1111
1112 if (vha->fcport_count == 0)
1113 wake_up_all(&vha->fcport_waitQ);
1114
41dc529a 1115 base_vha = pci_get_drvdata(ha->pdev);
1ae634eb
QT		 1116
1117 sess->free_pending = 0;
1118
41dc529a
QT		 1119 if (test_bit(PFLG_DRIVER_REMOVING, &base_vha->pci_flags))
1120 return;
1121
a4239945
QT		 1122 if ((!tgt || !tgt->tgt_stop) && !LOOP_TRANSITION(vha)) {
1123 switch (vha->host->active_mode) {
1124 case MODE_INITIATOR:
1125 case MODE_DUAL:
1126 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
1127 qla2xxx_wake_dpc(vha);
1128 break;
1129 case MODE_TARGET:
1130 default:
1131 /* no-op */
1132 break;
1133 }
726b8548 1134 }
2d70c103
NB		 1135}
1136
7560151b 1137/* ha->tgt.sess_lock supposed to be held on entry */
5d964837 1138void qlt_unreg_sess(struct fc_port *sess)
2d70c103
NB		 1139{
1140 struct scsi_qla_host *vha = sess->vha;
1ae634eb 1141 unsigned long flags;
2d70c103 1142
83548fe2 1143 ql_dbg(ql_dbg_disc, sess->vha, 0x210a,
5d964837
QT		 1144 "%s sess %p for deletion %8phC\n",
1145 __func__, sess, sess->port_name);
1146
1ae634eb
QT		 1147 spin_lock_irqsave(&sess->vha->work_lock, flags);
1148 if (sess->free_pending) {
1149 spin_unlock_irqrestore(&sess->vha->work_lock, flags);
1150 return;
1151 }
1152 sess->free_pending = 1;
1153 spin_unlock_irqrestore(&sess->vha->work_lock, flags);
1154
36c78452
QT		 1155 if (sess->se_sess)
1156 vha->hw->tgt.tgt_ops->clear_nacl_from_fcport_map(sess);
2d70c103 1157
a6ca8878 1158 sess->deleted = QLA_SESS_DELETION_IN_PROGRESS;
726b8548
QT		 1159 sess->disc_state = DSC_DELETE_PEND;
1160 sess->last_rscn_gen = sess->rscn_gen;
1161 sess->last_login_gen = sess->login_gen;
2d70c103 1162
baf23edd
QT		 1163 INIT_WORK(&sess->free_work, qlt_free_session_done);
1164 schedule_work(&sess->free_work);
2d70c103 1165}
5d964837 1166EXPORT_SYMBOL(qlt_unreg_sess);
7560151b 1167
2d70c103
NB		 1168static int qlt_reset(struct scsi_qla_host *vha, void *iocb, int mcmd)
1169{
1170 struct qla_hw_data *ha = vha->hw;
5d964837 1171 struct fc_port *sess = NULL;
2d70c103
NB		 1172 uint16_t loop_id;
1173 int res = 0;
1174 struct imm_ntfy_from_isp *n = (struct imm_ntfy_from_isp *)iocb;
7560151b 1175 unsigned long flags;
2d70c103
NB		 1176
1177 loop_id = le16_to_cpu(n->u.isp24.nport_handle);
1178 if (loop_id == 0xFFFF) {
2d70c103 1179 /* Global event */
b2032fd5 1180 atomic_inc(&vha->vha_tgt.qla_tgt->tgt_global_resets_count);
7560151b 1181 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
b2032fd5 1182 qlt_clear_tgt_db(vha->vha_tgt.qla_tgt);
7560151b 1183 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2d70c103 1184 } else {
7560151b 1185 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
2d70c103 1186 sess = ha->tgt.tgt_ops->find_sess_by_loop_id(vha, loop_id);
7560151b 1187 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2d70c103
NB		 1188 }
1189
1190 ql_dbg(ql_dbg_tgt, vha, 0xe000,
1191 "Using sess for qla_tgt_reset: %p\n", sess);
1192 if (!sess) {
1193 res = -ESRCH;
1194 return res;
1195 }
1196
1197 ql_dbg(ql_dbg_tgt, vha, 0xe047,
7b833558
OK		 1198 "scsi(%ld): resetting (session %p from port %8phC mcmd %x, "
1199 "loop_id %d)\n", vha->host_no, sess, sess->port_name,
2d70c103
NB		 1200 mcmd, loop_id);
1201
bb1181c9 1202 return qlt_issue_task_mgmt(sess, 0, mcmd, iocb, QLA24XX_MGMT_SEND_NACK);
2d70c103
NB		 1203}
1204
726b8548
QT		 1205static void qla24xx_chk_fcp_state(struct fc_port *sess)
1206{
7c3f8fd1 1207 if (sess->chip_reset != sess->vha->hw->base_qpair->chip_reset) {
726b8548
QT		 1208 sess->logout_on_delete = 0;
1209 sess->logo_ack_needed = 0;
1210 sess->fw_login_state = DSC_LS_PORT_UNAVAIL;
726b8548
QT		 1211 }
1212}
1213
94cff6e1 1214void qlt_schedule_sess_for_deletion(struct fc_port *sess)
2d70c103
NB		 1215{
1216 struct qla_tgt *tgt = sess->tgt;
d8630bb9 1217 unsigned long flags;
cd4ed6b4 1218 u16 sec;
2d70c103 1219
cd4ed6b4
QT		 1220 switch (sess->disc_state) {
1221 case DSC_DELETE_PEND:
726b8548 1222 return;
cd4ed6b4 1223 case DSC_DELETED:
726b8548
QT		 1224 if (tgt && tgt->tgt_stop && (tgt->sess_count == 0))
1225 wake_up_all(&tgt->waitQ);
1226 if (sess->vha->fcport_count == 0)
1227 wake_up_all(&sess->vha->fcport_waitQ);
1228
1229 if (!sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN] &&
1230 !sess->plogi_link[QLT_PLOGI_LINK_CONFLICT])
a6ca8878 1231 return;
cd4ed6b4
QT		 1232 break;
1233 case DSC_UPD_FCPORT:
1234 /*
1235 * This port is not done reporting to upper layer.
1236 * let it finish
1237 */
1238 sess->next_disc_state = DSC_DELETE_PEND;
1239 sec = jiffies_to_msecs(jiffies -
1240 sess->jiffies_at_registration)/1000;
1241 if (sess->sec_since_registration < sec && sec && !(sec % 5)) {
1242 sess->sec_since_registration = sec;
1243 ql_dbg(ql_dbg_disc, sess->vha, 0xffff,
1244 "%s %8phC : Slow Rport registration(%d Sec)\n",
1245 __func__, sess->port_name, sec);
1246 }
1247 return;
1248 default:
1249 break;
a6ca8878 1250 }
2d70c103 1251
49d7bd36 1252 spin_lock_irqsave(&sess->vha->work_lock, flags);
d8630bb9 1253 if (sess->deleted == QLA_SESS_DELETION_IN_PROGRESS) {
49d7bd36 1254 spin_unlock_irqrestore(&sess->vha->work_lock, flags);
d8630bb9
QT		 1255 return;
1256 }
726b8548 1257 sess->deleted = QLA_SESS_DELETION_IN_PROGRESS;
49d7bd36 1258 spin_unlock_irqrestore(&sess->vha->work_lock, flags);
d8630bb9
QT		 1259
1260 sess->disc_state = DSC_DELETE_PEND;
1261
726b8548 1262 qla24xx_chk_fcp_state(sess);
2d70c103 1263
726b8548 1264 ql_dbg(ql_dbg_tgt, sess->vha, 0xe001,
5c640053
QT		 1265 "Scheduling sess %p for deletion %8phC\n",
1266 sess, sess->port_name);
2d70c103 1267
a01c77d2 1268 INIT_WORK(&sess->del_work, qla24xx_delete_sess_fn);
1c6cacf4 1269 WARN_ON(!queue_work(sess->vha->hw->wq, &sess->del_work));
726b8548 1270}
2d70c103 1271
c5701042 1272static void qlt_clear_tgt_db(struct qla_tgt *tgt)
2d70c103 1273{
5d964837
QT		 1274 struct fc_port *sess;
1275 scsi_qla_host_t *vha = tgt->vha;
2d70c103 1276
5d964837
QT		 1277 list_for_each_entry(sess, &vha->vp_fcports, list) {
1278 if (sess->se_sess)
94cff6e1 1279 qlt_schedule_sess_for_deletion(sess);
5d964837 1280 }
2d70c103
NB		 1281
1282 /* At this point tgt could be already dead */
1283}
1284
df95f39a 1285static int qla24xx_get_loop_id(struct scsi_qla_host *vha, be_id_t s_id,
2d70c103
NB		 1286 uint16_t *loop_id)
1287{
1288 struct qla_hw_data *ha = vha->hw;
1289 dma_addr_t gid_list_dma;
9c17c3b1 1290 struct gid_list_info *gid_list, *gid;
2d70c103
NB		 1291 int res, rc, i;
1292 uint16_t entries;
1293
1294 gid_list = dma_alloc_coherent(&ha->pdev->dev, qla2x00_gid_list_size(ha),
1295 &gid_list_dma, GFP_KERNEL);
1296 if (!gid_list) {
1297 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf044,
1298 "qla_target(%d): DMA Alloc failed of %u\n",
1299 vha->vp_idx, qla2x00_gid_list_size(ha));
1300 return -ENOMEM;
1301 }
1302
1303 /* Get list of logged in devices */
15f30a57 1304 rc = qla24xx_gidlist_wait(vha, gid_list, gid_list_dma, &entries);
2d70c103
NB		 1305 if (rc != QLA_SUCCESS) {
1306 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf045,
1307 "qla_target(%d): get_id_list() failed: %x\n",
1308 vha->vp_idx, rc);
71cdc079 1309 res = -EBUSY;
2d70c103
NB		 1310 goto out_free_id_list;
1311 }
1312
9c17c3b1 1313 gid = gid_list;
71cdc079 1314 res = -ENOENT;
2d70c103 1315 for (i = 0; i < entries; i++) {
df95f39a
BVA		 1316 if (gid->al_pa == s_id.al_pa &&
1317 gid->area == s_id.area &&
1318 gid->domain == s_id.domain) {
2d70c103
NB		 1319 *loop_id = le16_to_cpu(gid->loop_id);
1320 res = 0;
1321 break;
1322 }
9c17c3b1 1323 gid = (void *)gid + ha->gid_list_info_size;
2d70c103
NB		 1324 }
1325
1326out_free_id_list:
1327 dma_free_coherent(&ha->pdev->dev, qla2x00_gid_list_size(ha),
1328 gid_list, gid_list_dma);
1329 return res;
1330}
1331
2d70c103
NB		 1332/*
1333 * Adds an extra ref to allow to drop hw lock after adding sess to the list.
1334 * Caller must put it.
1335 */
5d964837 1336static struct fc_port *qlt_create_sess(
2d70c103
NB		 1337 struct scsi_qla_host *vha,
1338 fc_port_t *fcport,
1339 bool local)
1340{
1341 struct qla_hw_data *ha = vha->hw;
726b8548 1342 struct fc_port *sess = fcport;
2d70c103 1343 unsigned long flags;
2d70c103 1344
726b8548
QT		 1345 if (vha->vha_tgt.qla_tgt->tgt_stop)
1346 return NULL;
2d70c103 1347
726b8548
QT		 1348 if (fcport->se_sess) {
1349 if (!kref_get_unless_zero(&sess->sess_kref)) {
83548fe2 1350 ql_dbg(ql_dbg_disc, vha, 0x20f6,
726b8548
QT		 1351 "%s: kref_get_unless_zero failed for %8phC\n",
1352 __func__, sess->port_name);
1353 return NULL;
2d70c103 1354 }
726b8548 1355 return fcport;
2d70c103 1356 }
0e8cd71c 1357 sess->tgt = vha->vha_tgt.qla_tgt;
2d70c103 1358 sess->local = local;
a6ca8878 1359
726b8548
QT		 1360 /*
1361 * Under normal circumstances we want to logout from firmware when
a6ca8878
AP		 1362 * session eventually ends and release corresponding nport handle.
1363 * In the exception cases (e.g. when new PLOGI is waiting) corresponding
726b8548
QT		 1364 * code will adjust these flags as necessary.
1365 */
a6ca8878
AP		 1366 sess->logout_on_delete = 1;
1367 sess->keep_nport_handle = 0;
726b8548 1368 sess->logout_completed = 0;
2d70c103 1369
726b8548
QT		 1370 if (ha->tgt.tgt_ops->check_initiator_node_acl(vha,
1371 &fcport->port_name[0], sess) < 0) {
83548fe2 1372 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf015,
726b8548
QT		 1373 "(%d) %8phC check_initiator_node_acl failed\n",
1374 vha->vp_idx, fcport->port_name);
1375 return NULL;
1376 } else {
1377 kref_init(&fcport->sess_kref);
1378 /*
1379 * Take an extra reference to ->sess_kref here to handle
1380 * fc_port access across ->tgt.sess_lock reaquire.
1381 */
1382 if (!kref_get_unless_zero(&sess->sess_kref)) {
83548fe2 1383 ql_dbg(ql_dbg_disc, vha, 0x20f7,
726b8548
QT		 1384 "%s: kref_get_unless_zero failed for %8phC\n",
1385 __func__, sess->port_name);
1386 return NULL;
1387 }
2d70c103 1388
726b8548
QT		 1389 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
1390 if (!IS_SW_RESV_ADDR(sess->d_id))
1391 vha->vha_tgt.qla_tgt->sess_count++;
2d70c103 1392
726b8548
QT		 1393 qlt_do_generation_tick(vha, &sess->generation);
1394 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
1395 }
1396
1397 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf006,
1398 "Adding sess %p se_sess %p to tgt %p sess_count %d\n",
1399 sess, sess->se_sess, vha->vha_tgt.qla_tgt,
1400 vha->vha_tgt.qla_tgt->sess_count);
2d70c103
NB		 1401
1402 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf04b,
7b833558
OK		 1403 "qla_target(%d): %ssession for wwn %8phC (loop_id %d, "
1404 "s_id %x:%x:%x, confirmed completion %ssupported) added\n",
1405 vha->vp_idx, local ? "local " : "", fcport->port_name,
37cacc0a
QT		 1406 fcport->loop_id, sess->d_id.b.domain, sess->d_id.b.area,
1407 sess->d_id.b.al_pa, sess->conf_compl_supported ? "" : "not ");
2d70c103
NB		 1408
1409 return sess;
1410}
1411
df673274
AP		 1412/*
1413 * max_gen - specifies maximum session generation
1414 * at which this deletion requestion is still valid
1415 */
1416void
1417qlt_fc_port_deleted(struct scsi_qla_host *vha, fc_port_t *fcport, int max_gen)
2d70c103 1418{
0e8cd71c 1419 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
5d964837 1420 struct fc_port *sess = fcport;
7560151b 1421 unsigned long flags;
2d70c103
NB		 1422
1423 if (!vha->hw->tgt.tgt_ops)
1424 return;
1425
b2032fd5 1426 if (!tgt)
2d70c103
NB		 1427 return;
1428
7560151b 1429 spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
2d70c103 1430 if (tgt->tgt_stop) {
7560151b 1431 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
2d70c103
NB		 1432 return;
1433 }
5d964837 1434 if (!sess->se_sess) {
7560151b 1435 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
2d70c103
NB		 1436 return;
1437 }
1438
df673274 1439 if (max_gen - sess->generation < 0) {
7560151b 1440 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
df673274
AP		 1441 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf092,
1442 "Ignoring stale deletion request for se_sess %p / sess %p"
1443 " for port %8phC, req_gen %d, sess_gen %d\n",
1444 sess->se_sess, sess, sess->port_name, max_gen,
1445 sess->generation);
1446 return;
1447 }
1448
2d70c103
NB		 1449 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf008, "qla_tgt_fc_port_deleted %p", sess);
1450
1451 sess->local = 1;
7560151b 1452 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
1c6cacf4 1453 qlt_schedule_sess_for_deletion(sess);
2d70c103
NB		 1454}
1455
1456static inline int test_tgt_sess_count(struct qla_tgt *tgt)
1457{
1458 struct qla_hw_data *ha = tgt->ha;
1459 unsigned long flags;
1460 int res;
1461 /*
1462 * We need to protect against race, when tgt is freed before or
1463 * inside wake_up()
1464 */
726b8548 1465 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
2d70c103 1466 ql_dbg(ql_dbg_tgt, tgt->vha, 0xe002,
5d964837
QT		 1467 "tgt %p, sess_count=%d\n",
1468 tgt, tgt->sess_count);
2d70c103 1469 res = (tgt->sess_count == 0);
726b8548 1470 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2d70c103
NB		 1471
1472 return res;
1473}
1474
1475/* Called by tcm_qla2xxx configfs code */
3c231bda 1476int qlt_stop_phase1(struct qla_tgt *tgt)
2d70c103
NB		 1477{
1478 struct scsi_qla_host *vha = tgt->vha;
1479 struct qla_hw_data *ha = tgt->ha;
1480 unsigned long flags;
1481
b6faaaf7 1482 mutex_lock(&ha->optrom_mutex);
3c231bda 1483 mutex_lock(&qla_tgt_mutex);
b6faaaf7 1484
2d70c103
NB		 1485 if (tgt->tgt_stop || tgt->tgt_stopped) {
1486 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf04e,
1487 "Already in tgt->tgt_stop or tgt_stopped state\n");
3c231bda 1488 mutex_unlock(&qla_tgt_mutex);
b6faaaf7 1489 mutex_unlock(&ha->optrom_mutex);
3c231bda 1490 return -EPERM;
2d70c103
NB		 1491 }
1492
3a33dc95 1493 ql_dbg(ql_dbg_tgt_mgt, vha, 0xe003, "Stopping target for host %ld(%p)\n",
2d70c103
NB		 1494 vha->host_no, vha);
1495 /*
1496 * Mutex needed to sync with qla_tgt_fc_port_[added,deleted].
1497 * Lock is needed, because we still can get an incoming packet.
1498 */
0e8cd71c 1499 mutex_lock(&vha->vha_tgt.tgt_mutex);
2d70c103 1500 tgt->tgt_stop = 1;
c5701042 1501 qlt_clear_tgt_db(tgt);
0e8cd71c 1502 mutex_unlock(&vha->vha_tgt.tgt_mutex);
3c231bda 1503 mutex_unlock(&qla_tgt_mutex);
2d70c103 1504
2d70c103
NB		 1505 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf009,
1506 "Waiting for sess works (tgt %p)", tgt);
1507 spin_lock_irqsave(&tgt->sess_work_lock, flags);
1508 while (!list_empty(&tgt->sess_works_list)) {
1509 spin_unlock_irqrestore(&tgt->sess_work_lock, flags);
1510 flush_scheduled_work();
1511 spin_lock_irqsave(&tgt->sess_work_lock, flags);
1512 }
1513 spin_unlock_irqrestore(&tgt->sess_work_lock, flags);
1514
1515 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf00a,
5d964837 1516 "Waiting for tgt %p: sess_count=%d\n", tgt, tgt->sess_count);
2d70c103 1517
b85e0957 1518 wait_event_timeout(tgt->waitQ, test_tgt_sess_count(tgt), 10*HZ);
2d70c103
NB		 1519
1520 /* Big hammer */
ead03855
QT		 1521 if (!ha->flags.host_shutting_down &&
1522 (qla_tgt_mode_enabled(vha) || qla_dual_mode_enabled(vha)))
2d70c103
NB		 1523 qlt_disable_vha(vha);
1524
1525 /* Wait for sessions to clear out (just in case) */
b85e0957 1526 wait_event_timeout(tgt->waitQ, test_tgt_sess_count(tgt), 10*HZ);
b6faaaf7
QT		 1527 mutex_unlock(&ha->optrom_mutex);
1528
3c231bda 1529 return 0;
2d70c103
NB		 1530}
1531EXPORT_SYMBOL(qlt_stop_phase1);
1532
1533/* Called by tcm_qla2xxx configfs code */
1534void qlt_stop_phase2(struct qla_tgt *tgt)
1535{
3a33dc95 1536 scsi_qla_host_t *vha = tgt->vha;
2d70c103
NB		 1537
1538 if (tgt->tgt_stopped) {
0e8cd71c 1539 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf04f,
2d70c103
NB		 1540 "Already in tgt->tgt_stopped state\n");
1541 dump_stack();
1542 return;
1543 }
3a33dc95
QT		 1544 if (!tgt->tgt_stop) {
1545 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf00b,
1546 "%s: phase1 stop is not completed\n", __func__);
1547 dump_stack();
1548 return;
1549 }
2d70c103 1550
0e8cd71c 1551 mutex_lock(&vha->vha_tgt.tgt_mutex);
2d70c103
NB		 1552 tgt->tgt_stop = 0;
1553 tgt->tgt_stopped = 1;
0e8cd71c 1554 mutex_unlock(&vha->vha_tgt.tgt_mutex);
2d70c103 1555
3a33dc95 1556 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf00c, "Stop of tgt %p finished\n",
2d70c103 1557 tgt);
0645cb83
QT		 1558
1559 switch (vha->qlini_mode) {
1560 case QLA2XXX_INI_MODE_EXCLUSIVE:
1561 vha->flags.online = 1;
1562 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1563 break;
1564 default:
1565 break;
1566 }
2d70c103
NB		 1567}
1568EXPORT_SYMBOL(qlt_stop_phase2);
1569
1570/* Called from qlt_remove_target() -> qla2x00_remove_one() */
fa492630 1571static void qlt_release(struct qla_tgt *tgt)
2d70c103 1572{
0e8cd71c 1573 scsi_qla_host_t *vha = tgt->vha;
e326d22a
QT		 1574 void *node;
1575 u64 key = 0;
1576 u16 i;
1577 struct qla_qpair_hint *h;
bdbe24de 1578 struct qla_hw_data *ha = vha->hw;
2d70c103 1579
8b21900b 1580 if (!tgt->tgt_stop && !tgt->tgt_stopped)
3a33dc95
QT		 1581 qlt_stop_phase1(tgt);
1582
8b21900b 1583 if (!tgt->tgt_stopped)
2d70c103
NB		 1584 qlt_stop_phase2(tgt);
1585
e326d22a
QT		 1586 for (i = 0; i < vha->hw->max_qpairs + 1; i++) {
1587 unsigned long flags;
1588
1589 h = &tgt->qphints[i];
1590 if (h->qpair) {
1591 spin_lock_irqsave(h->qpair->qp_lock_ptr, flags);
1592 list_del(&h->hint_elem);
1593 spin_unlock_irqrestore(h->qpair->qp_lock_ptr, flags);
1594 h->qpair = NULL;
1595 }
1596 }
1597 kfree(tgt->qphints);
bdbe24de
QT		 1598 mutex_lock(&qla_tgt_mutex);
1599 list_del(&vha->vha_tgt.qla_tgt->tgt_list_entry);
1600 mutex_unlock(&qla_tgt_mutex);
e326d22a
QT		 1601
1602 btree_for_each_safe64(&tgt->lun_qpair_map, key, node)
1603 btree_remove64(&tgt->lun_qpair_map, key);
1604
1605 btree_destroy64(&tgt->lun_qpair_map);
1606
3be63b1e
SC		 1607 if (vha->vp_idx)
1608 if (ha->tgt.tgt_ops &&
1609 ha->tgt.tgt_ops->remove_target &&
1610 vha->vha_tgt.target_lport_ptr)
1611 ha->tgt.tgt_ops->remove_target(vha);
bdbe24de 1612
0e8cd71c 1613 vha->vha_tgt.qla_tgt = NULL;
2d70c103 1614
0e8cd71c 1615 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf00d,
2d70c103
NB		 1616 "Release of tgt %p finished\n", tgt);
1617
1618 kfree(tgt);
1619}
1620
1621/* ha->hardware_lock supposed to be held on entry */
1622static int qlt_sched_sess_work(struct qla_tgt *tgt, int type,
1623 const void *param, unsigned int param_size)
1624{
1625 struct qla_tgt_sess_work_param *prm;
1626 unsigned long flags;
1627
1628 prm = kzalloc(sizeof(*prm), GFP_ATOMIC);
1629 if (!prm) {
1630 ql_dbg(ql_dbg_tgt_mgt, tgt->vha, 0xf050,
1631 "qla_target(%d): Unable to create session "
1632 "work, command will be refused", 0);
1633 return -ENOMEM;
1634 }
1635
1636 ql_dbg(ql_dbg_tgt_mgt, tgt->vha, 0xf00e,
1637 "Scheduling work (type %d, prm %p)"
1638 " to find session for param %p (size %d, tgt %p)\n",
1639 type, prm, param, param_size, tgt);
1640
1641 prm->type = type;
1642 memcpy(&prm->tm_iocb, param, param_size);
1643
1644 spin_lock_irqsave(&tgt->sess_work_lock, flags);
1645 list_add_tail(&prm->sess_works_list_entry, &tgt->sess_works_list);
1646 spin_unlock_irqrestore(&tgt->sess_work_lock, flags);
1647
1648 schedule_work(&tgt->sess_work);
1649
1650 return 0;
1651}
1652
1653/*
1654 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1655 */
82de802a 1656static void qlt_send_notify_ack(struct qla_qpair *qpair,
2d70c103
NB		 1657 struct imm_ntfy_from_isp *ntfy,
1658 uint32_t add_flags, uint16_t resp_code, int resp_code_valid,
1659 uint16_t srr_flags, uint16_t srr_reject_code, uint8_t srr_explan)
1660{
82de802a 1661 struct scsi_qla_host *vha = qpair->vha;
2d70c103
NB		 1662 struct qla_hw_data *ha = vha->hw;
1663 request_t *pkt;
1664 struct nack_to_isp *nack;
1665
ec7193e2
QT		 1666 if (!ha->flags.fw_started)
1667 return;
1668
2d70c103
NB		 1669 ql_dbg(ql_dbg_tgt, vha, 0xe004, "Sending NOTIFY_ACK (ha=%p)\n", ha);
1670
82de802a 1671 pkt = (request_t *)__qla2x00_alloc_iocbs(qpair, NULL);
2d70c103
NB		 1672 if (!pkt) {
1673 ql_dbg(ql_dbg_tgt, vha, 0xe049,
1674 "qla_target(%d): %s failed: unable to allocate "
1675 "request packet\n", vha->vp_idx, __func__);
1676 return;
1677 }
1678
0e8cd71c
SK		 1679 if (vha->vha_tgt.qla_tgt != NULL)
1680 vha->vha_tgt.qla_tgt->notify_ack_expected++;
2d70c103
NB		 1681
1682 pkt->entry_type = NOTIFY_ACK_TYPE;
1683 pkt->entry_count = 1;
1684
1685 nack = (struct nack_to_isp *)pkt;
1686 nack->ox_id = ntfy->ox_id;
1687
726b8548 1688 nack->u.isp24.handle = QLA_TGT_SKIP_HANDLE;
2d70c103
NB		 1689 nack->u.isp24.nport_handle = ntfy->u.isp24.nport_handle;
1690 if (le16_to_cpu(ntfy->u.isp24.status) == IMM_NTFY_ELS) {
1691 nack->u.isp24.flags = ntfy->u.isp24.flags &
ad950360 1692 cpu_to_le32(NOTIFY24XX_FLAGS_PUREX_IOCB);
2d70c103
NB		 1693 }
1694 nack->u.isp24.srr_rx_id = ntfy->u.isp24.srr_rx_id;
1695 nack->u.isp24.status = ntfy->u.isp24.status;
1696 nack->u.isp24.status_subcode = ntfy->u.isp24.status_subcode;
aa230bc5 1697 nack->u.isp24.fw_handle = ntfy->u.isp24.fw_handle;
2d70c103
NB		 1698 nack->u.isp24.exchange_address = ntfy->u.isp24.exchange_address;
1699 nack->u.isp24.srr_rel_offs = ntfy->u.isp24.srr_rel_offs;
1700 nack->u.isp24.srr_ui = ntfy->u.isp24.srr_ui;
1701 nack->u.isp24.srr_flags = cpu_to_le16(srr_flags);
1702 nack->u.isp24.srr_reject_code = srr_reject_code;
1703 nack->u.isp24.srr_reject_code_expl = srr_explan;
1704 nack->u.isp24.vp_index = ntfy->u.isp24.vp_index;
1705
1706 ql_dbg(ql_dbg_tgt, vha, 0xe005,
1707 "qla_target(%d): Sending 24xx Notify Ack %d\n",
1708 vha->vp_idx, nack->u.isp24.status);
1709
63163e06
HM		 1710 /* Memory Barrier */
1711 wmb();
82de802a 1712 qla2x00_start_iocbs(vha, qpair->req);
2d70c103
NB		 1713}
1714
6b0431d6
QT		 1715static int qlt_build_abts_resp_iocb(struct qla_tgt_mgmt_cmd *mcmd)
1716{
1717 struct scsi_qla_host *vha = mcmd->vha;
1718 struct qla_hw_data *ha = vha->hw;
1719 struct abts_resp_to_24xx *resp;
1720 uint32_t f_ctl, h;
1721 uint8_t *p;
1722 int rc;
1723 struct abts_recv_from_24xx *abts = &mcmd->orig_iocb.abts;
1724 struct qla_qpair *qpair = mcmd->qpair;
1725
1726 ql_dbg(ql_dbg_tgt, vha, 0xe006,
1727 "Sending task mgmt ABTS response (ha=%p, status=%x)\n",
1728 ha, mcmd->fc_tm_rsp);
1729
1730 rc = qlt_check_reserve_free_req(qpair, 1);
1731 if (rc) {
1732 ql_dbg(ql_dbg_tgt, vha, 0xe04a,
1733 "qla_target(%d): %s failed: unable to allocate request packet\n",
1734 vha->vp_idx, __func__);
1735 return -EAGAIN;
1736 }
1737
1738 resp = (struct abts_resp_to_24xx *)qpair->req->ring_ptr;
1739 memset(resp, 0, sizeof(*resp));
1740
1741 h = qlt_make_handle(qpair);
1742 if (unlikely(h == QLA_TGT_NULL_HANDLE)) {
1743 /*
1744 * CTIO type 7 from the firmware doesn't provide a way to
1745 * know the initiator's LOOP ID, hence we can't find
1746 * the session and, so, the command.
1747 */
1748 return -EAGAIN;
1749 } else {
1750 qpair->req->outstanding_cmds[h] = (srb_t *)mcmd;
1751 }
1752
1753 resp->handle = MAKE_HANDLE(qpair->req->id, h);
1754 resp->entry_type = ABTS_RESP_24XX;
1755 resp->entry_count = 1;
1756 resp->nport_handle = abts->nport_handle;
1757 resp->vp_index = vha->vp_idx;
1758 resp->sof_type = abts->sof_type;
1759 resp->exchange_address = abts->exchange_address;
1760 resp->fcp_hdr_le = abts->fcp_hdr_le;
1761 f_ctl = cpu_to_le32(F_CTL_EXCH_CONTEXT_RESP |
1762 F_CTL_LAST_SEQ | F_CTL_END_SEQ |
1763 F_CTL_SEQ_INITIATIVE);
1764 p = (uint8_t *)&f_ctl;
1765 resp->fcp_hdr_le.f_ctl[0] = *p++;
1766 resp->fcp_hdr_le.f_ctl[1] = *p++;
1767 resp->fcp_hdr_le.f_ctl[2] = *p;
1768
df95f39a
BVA		 1769 resp->fcp_hdr_le.d_id = abts->fcp_hdr_le.s_id;
1770 resp->fcp_hdr_le.s_id = abts->fcp_hdr_le.d_id;
6b0431d6
QT		 1771
1772 resp->exchange_addr_to_abort = abts->exchange_addr_to_abort;
1773 if (mcmd->fc_tm_rsp == FCP_TMF_CMPL) {
1774 resp->fcp_hdr_le.r_ctl = R_CTL_BASIC_LINK_SERV | R_CTL_B_ACC;
1775 resp->payload.ba_acct.seq_id_valid = SEQ_ID_INVALID;
1776 resp->payload.ba_acct.low_seq_cnt = 0x0000;
1777 resp->payload.ba_acct.high_seq_cnt = 0xFFFF;
1778 resp->payload.ba_acct.ox_id = abts->fcp_hdr_le.ox_id;
1779 resp->payload.ba_acct.rx_id = abts->fcp_hdr_le.rx_id;
1780 } else {
1781 resp->fcp_hdr_le.r_ctl = R_CTL_BASIC_LINK_SERV | R_CTL_B_RJT;
1782 resp->payload.ba_rjt.reason_code =
1783 BA_RJT_REASON_CODE_UNABLE_TO_PERFORM;
1784 /* Other bytes are zero */
1785 }
1786
1787 vha->vha_tgt.qla_tgt->abts_resp_expected++;
1788
1789 /* Memory Barrier */
1790 wmb();
1791 if (qpair->reqq_start_iocbs)
1792 qpair->reqq_start_iocbs(qpair);
1793 else
1794 qla2x00_start_iocbs(vha, qpair->req);
1795
1796 return rc;
1797}
1798
2d70c103
NB		 1799/*
1800 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1801 */
82de802a 1802static void qlt_24xx_send_abts_resp(struct qla_qpair *qpair,
2d70c103
NB		 1803 struct abts_recv_from_24xx *abts, uint32_t status,
1804 bool ids_reversed)
1805{
82de802a 1806 struct scsi_qla_host *vha = qpair->vha;
2d70c103
NB		 1807 struct qla_hw_data *ha = vha->hw;
1808 struct abts_resp_to_24xx *resp;
1809 uint32_t f_ctl;
1810 uint8_t *p;
1811
1812 ql_dbg(ql_dbg_tgt, vha, 0xe006,
1813 "Sending task mgmt ABTS response (ha=%p, atio=%p, status=%x\n",
1814 ha, abts, status);
1815
82de802a
QT		 1816 resp = (struct abts_resp_to_24xx *)qla2x00_alloc_iocbs_ready(qpair,
1817 NULL);
2d70c103
NB		 1818 if (!resp) {
1819 ql_dbg(ql_dbg_tgt, vha, 0xe04a,
1820 "qla_target(%d): %s failed: unable to allocate "
1821 "request packet", vha->vp_idx, __func__);
1822 return;
1823 }
1824
1825 resp->entry_type = ABTS_RESP_24XX;
6b0431d6 1826 resp->handle = QLA_TGT_SKIP_HANDLE;
2d70c103
NB		 1827 resp->entry_count = 1;
1828 resp->nport_handle = abts->nport_handle;
1829 resp->vp_index = vha->vp_idx;
1830 resp->sof_type = abts->sof_type;
1831 resp->exchange_address = abts->exchange_address;
1832 resp->fcp_hdr_le = abts->fcp_hdr_le;
ad950360 1833 f_ctl = cpu_to_le32(F_CTL_EXCH_CONTEXT_RESP |
2d70c103
NB		 1834 F_CTL_LAST_SEQ | F_CTL_END_SEQ |
1835 F_CTL_SEQ_INITIATIVE);
1836 p = (uint8_t *)&f_ctl;
1837 resp->fcp_hdr_le.f_ctl[0] = *p++;
1838 resp->fcp_hdr_le.f_ctl[1] = *p++;
1839 resp->fcp_hdr_le.f_ctl[2] = *p;
1840 if (ids_reversed) {
df95f39a
BVA		 1841 resp->fcp_hdr_le.d_id = abts->fcp_hdr_le.d_id;
1842 resp->fcp_hdr_le.s_id = abts->fcp_hdr_le.s_id;
2d70c103 1843 } else {
df95f39a
BVA		 1844 resp->fcp_hdr_le.d_id = abts->fcp_hdr_le.s_id;
1845 resp->fcp_hdr_le.s_id = abts->fcp_hdr_le.d_id;
2d70c103
NB		 1846 }
1847 resp->exchange_addr_to_abort = abts->exchange_addr_to_abort;
1848 if (status == FCP_TMF_CMPL) {
1849 resp->fcp_hdr_le.r_ctl = R_CTL_BASIC_LINK_SERV | R_CTL_B_ACC;
1850 resp->payload.ba_acct.seq_id_valid = SEQ_ID_INVALID;
1851 resp->payload.ba_acct.low_seq_cnt = 0x0000;
1852 resp->payload.ba_acct.high_seq_cnt = 0xFFFF;
1853 resp->payload.ba_acct.ox_id = abts->fcp_hdr_le.ox_id;
1854 resp->payload.ba_acct.rx_id = abts->fcp_hdr_le.rx_id;
1855 } else {
1856 resp->fcp_hdr_le.r_ctl = R_CTL_BASIC_LINK_SERV | R_CTL_B_RJT;
1857 resp->payload.ba_rjt.reason_code =
1858 BA_RJT_REASON_CODE_UNABLE_TO_PERFORM;
1859 /* Other bytes are zero */
1860 }
1861
0e8cd71c 1862 vha->vha_tgt.qla_tgt->abts_resp_expected++;
2d70c103 1863
63163e06
HM		 1864 /* Memory Barrier */
1865 wmb();
8abfa9e2
QT		 1866 if (qpair->reqq_start_iocbs)
1867 qpair->reqq_start_iocbs(qpair);
1868 else
1869 qla2x00_start_iocbs(vha, qpair->req);
2d70c103
NB		 1870}
1871
1872/*
1873 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
1874 */
1875static void qlt_24xx_retry_term_exchange(struct scsi_qla_host *vha,
6b0431d6 1876 struct qla_qpair *qpair, response_t *pkt, struct qla_tgt_mgmt_cmd *mcmd)
2d70c103
NB		 1877{
1878 struct ctio7_to_24xx *ctio;
0691094f 1879 u16 tmp;
6b0431d6 1880 struct abts_recv_from_24xx *entry;
2d70c103 1881
0691094f 1882 ctio = (struct ctio7_to_24xx *)qla2x00_alloc_iocbs_ready(qpair, NULL);
2d70c103
NB		 1883 if (ctio == NULL) {
1884 ql_dbg(ql_dbg_tgt, vha, 0xe04b,
1885 "qla_target(%d): %s failed: unable to allocate "
1886 "request packet\n", vha->vp_idx, __func__);
1887 return;
1888 }
1889
6b0431d6
QT		 1890 if (mcmd)
1891 /* abts from remote port */
1892 entry = &mcmd->orig_iocb.abts;
1893 else
1894 /* abts from this driver. */
1895 entry = (struct abts_recv_from_24xx *)pkt;
1896
2d70c103
NB		 1897 /*
1898 * We've got on entrance firmware's response on by us generated
1899 * ABTS response. So, in it ID fields are reversed.
1900 */
1901
1902 ctio->entry_type = CTIO_TYPE7;
1903 ctio->entry_count = 1;
1904 ctio->nport_handle = entry->nport_handle;
1905 ctio->handle = QLA_TGT_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK;
ad950360 1906 ctio->timeout = cpu_to_le16(QLA_TGT_TIMEOUT);
2d70c103 1907 ctio->vp_index = vha->vp_idx;
2d70c103 1908 ctio->exchange_addr = entry->exchange_addr_to_abort;
0691094f 1909 tmp = (CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_TERMINATE);
6b0431d6
QT		 1910
1911 if (mcmd) {
df95f39a 1912 ctio->initiator_id = entry->fcp_hdr_le.s_id;
6b0431d6
QT		 1913
1914 if (mcmd->flags & QLA24XX_MGMT_ABORT_IO_ATTR_VALID)
1915 tmp |= (mcmd->abort_io_attr << 9);
1916 else if (qpair->retry_term_cnt & 1)
1917 tmp |= (0x4 << 9);
1918 } else {
df95f39a 1919 ctio->initiator_id = entry->fcp_hdr_le.d_id;
6b0431d6
QT		 1920
1921 if (qpair->retry_term_cnt & 1)
1922 tmp |= (0x4 << 9);
1923 }
0691094f 1924 ctio->u.status1.flags = cpu_to_le16(tmp);
6b0431d6 1925 ctio->u.status1.ox_id = entry->fcp_hdr_le.ox_id;
0691094f 1926
6b0431d6
QT		 1927 ql_dbg(ql_dbg_tgt, vha, 0xe007,
1928 "Sending retry TERM EXCH CTIO7 flags %04xh oxid %04xh attr valid %x\n",
1929 le16_to_cpu(ctio->u.status1.flags),
1930 le16_to_cpu(ctio->u.status1.ox_id),
1931 (mcmd && mcmd->flags & QLA24XX_MGMT_ABORT_IO_ATTR_VALID) ? 1 : 0);
2d70c103 1932
63163e06
HM		 1933 /* Memory Barrier */
1934 wmb();
0691094f
QT		 1935 if (qpair->reqq_start_iocbs)
1936 qpair->reqq_start_iocbs(qpair);
1937 else
1938 qla2x00_start_iocbs(vha, qpair->req);
2d70c103 1939
6b0431d6
QT		 1940 if (mcmd)
1941 qlt_build_abts_resp_iocb(mcmd);
1942 else
1943 qlt_24xx_send_abts_resp(qpair,
1944 (struct abts_recv_from_24xx *)entry, FCP_TMF_CMPL, true);
8b2f5ff3 1945
8b2f5ff3
SN		 1946}
1947
1948/* drop cmds for the given lun
1949 * XXX only looks for cmds on the port through which lun reset was recieved
1950 * XXX does not go through the list of other port (which may have cmds
1951 * for the same lun)
1952 */
df95f39a 1953static void abort_cmds_for_lun(struct scsi_qla_host *vha, u64 lun, be_id_t s_id)
8b2f5ff3
SN		 1954{
1955 struct qla_tgt_sess_op *op;
1956 struct qla_tgt_cmd *cmd;
1957 uint32_t key;
8b631d87 1958 unsigned long flags;
8b2f5ff3
SN		 1959
1960 key = sid_to_key(s_id);
8b631d87 1961 spin_lock_irqsave(&vha->cmd_list_lock, flags);
8b2f5ff3
SN		 1962 list_for_each_entry(op, &vha->qla_sess_op_cmd_list, cmd_list) {
1963 uint32_t op_key;
f775bd14 1964 u64 op_lun;
8b2f5ff3
SN		 1965
1966 op_key = sid_to_key(op->atio.u.isp24.fcp_hdr.s_id);
1967 op_lun = scsilun_to_int(
1968 (struct scsi_lun *)&op->atio.u.isp24.fcp_cmnd.lun);
1969 if (op_key == key && op_lun == lun)
1970 op->aborted = true;
1971 }
41dc529a
QT		 1972
1973 list_for_each_entry(op, &vha->unknown_atio_list, cmd_list) {
1974 uint32_t op_key;
1975 u64 op_lun;
1976
1977 op_key = sid_to_key(op->atio.u.isp24.fcp_hdr.s_id);
1978 op_lun = scsilun_to_int(
1979 (struct scsi_lun *)&op->atio.u.isp24.fcp_cmnd.lun);
1980 if (op_key == key && op_lun == lun)
1981 op->aborted = true;
1982 }
1983
8b2f5ff3
SN		 1984 list_for_each_entry(cmd, &vha->qla_cmd_list, cmd_list) {
1985 uint32_t cmd_key;
f775bd14 1986 u64 cmd_lun;
8b2f5ff3
SN		 1987
1988 cmd_key = sid_to_key(cmd->atio.u.isp24.fcp_hdr.s_id);
1989 cmd_lun = scsilun_to_int(
1990 (struct scsi_lun *)&cmd->atio.u.isp24.fcp_cmnd.lun);
1991 if (cmd_key == key && cmd_lun == lun)
193b50b9 1992 cmd->aborted = 1;
8b2f5ff3 1993 }
8b631d87 1994 spin_unlock_irqrestore(&vha->cmd_list_lock, flags);
8b2f5ff3
SN		 1995}
1996
84905dfe
QT		 1997static struct qla_qpair_hint *qlt_find_qphint(struct scsi_qla_host *vha,
1998 uint64_t unpacked_lun)
1999{
2000 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
2001 struct qla_qpair_hint *h = NULL;
2002
2003 if (vha->flags.qpairs_available) {
2004 h = btree_lookup64(&tgt->lun_qpair_map, unpacked_lun);
2005 if (!h)
2006 h = &tgt->qphints[0];
2007 } else {
2008 h = &tgt->qphints[0];
2009 }
2010
2011 return h;
2012}
2013
2014static void qlt_do_tmr_work(struct work_struct *work)
2015{
2016 struct qla_tgt_mgmt_cmd *mcmd =
2017 container_of(work, struct qla_tgt_mgmt_cmd, work);
2018 struct qla_hw_data *ha = mcmd->vha->hw;
2019 int rc = EIO;
2020 uint32_t tag;
2021 unsigned long flags;
2022
2023 switch (mcmd->tmr_func) {
2024 case QLA_TGT_ABTS:
2025 tag = mcmd->orig_iocb.abts.exchange_addr_to_abort;
2026 break;
2027 default:
2028 tag = 0;
2029 break;
2030 }
2031
2032 rc = ha->tgt.tgt_ops->handle_tmr(mcmd, mcmd->unpacked_lun,
2033 mcmd->tmr_func, tag);
2034
2035 if (rc != 0) {
2036 spin_lock_irqsave(mcmd->qpair->qp_lock_ptr, flags);
2037 switch (mcmd->tmr_func) {
2038 case QLA_TGT_ABTS:
6b0431d6
QT		 2039 mcmd->fc_tm_rsp = FCP_TMF_REJECTED;
2040 qlt_build_abts_resp_iocb(mcmd);
84905dfe
QT		 2041 break;
2042 case QLA_TGT_LUN_RESET:
2043 case QLA_TGT_CLEAR_TS:
2044 case QLA_TGT_ABORT_TS:
2045 case QLA_TGT_CLEAR_ACA:
2046 case QLA_TGT_TARGET_RESET:
2047 qlt_send_busy(mcmd->qpair, &mcmd->orig_iocb.atio,
2048 qla_sam_status);
2049 break;
2050
2051 case QLA_TGT_ABORT_ALL:
2052 case QLA_TGT_NEXUS_LOSS_SESS:
2053 case QLA_TGT_NEXUS_LOSS:
2054 qlt_send_notify_ack(mcmd->qpair,
2055 &mcmd->orig_iocb.imm_ntfy, 0, 0, 0, 0, 0, 0);
2056 break;
2057 }
2058 spin_unlock_irqrestore(mcmd->qpair->qp_lock_ptr, flags);
2059
2060 ql_dbg(ql_dbg_tgt_mgt, mcmd->vha, 0xf052,
2061 "qla_target(%d): tgt_ops->handle_tmr() failed: %d\n",
2062 mcmd->vha->vp_idx, rc);
2063 mempool_free(mcmd, qla_tgt_mgmt_cmd_mempool);
2064 }
2065}
2066
2d70c103
NB		 2067/* ha->hardware_lock supposed to be held on entry */
2068static int __qlt_24xx_handle_abts(struct scsi_qla_host *vha,
5d964837 2069 struct abts_recv_from_24xx *abts, struct fc_port *sess)
2d70c103
NB		 2070{
2071 struct qla_hw_data *ha = vha->hw;
2072 struct qla_tgt_mgmt_cmd *mcmd;
84905dfe 2073 struct qla_qpair_hint *h = &vha->vha_tgt.qla_tgt->qphints[0];
06e97b48 2074
2d70c103
NB		 2075 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf00f,
2076 "qla_target(%d): task abort (tag=%d)\n",
2077 vha->vp_idx, abts->exchange_addr_to_abort);
2078
2079 mcmd = mempool_alloc(qla_tgt_mgmt_cmd_mempool, GFP_ATOMIC);
2080 if (mcmd == NULL) {
2081 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf051,
2082 "qla_target(%d): %s: Allocation of ABORT cmd failed",
2083 vha->vp_idx, __func__);
2084 return -ENOMEM;
2085 }
2086 memset(mcmd, 0, sizeof(*mcmd));
6b0431d6 2087 mcmd->cmd_type = TYPE_TGT_TMCMD;
2d70c103
NB		 2088 mcmd->sess = sess;
2089 memcpy(&mcmd->orig_iocb.abts, abts, sizeof(mcmd->orig_iocb.abts));
7c3f8fd1 2090 mcmd->reset_count = ha->base_qpair->chip_reset;
be92fc3f 2091 mcmd->tmr_func = QLA_TGT_ABTS;
84905dfe 2092 mcmd->qpair = h->qpair;
72fcd4eb 2093 mcmd->vha = vha;
2d70c103 2094
eb5ae233
NB		 2095 /*
2096 * LUN is looked up by target-core internally based on the passed
2097 * abts->exchange_addr_to_abort tag.
2098 */
84905dfe
QT		 2099 mcmd->se_cmd.cpuid = h->cpuid;
2100
2101 if (ha->tgt.tgt_ops->find_cmd_by_tag) {
2102 struct qla_tgt_cmd *abort_cmd;
2103
2104 abort_cmd = ha->tgt.tgt_ops->find_cmd_by_tag(sess,
2105 abts->exchange_addr_to_abort);
2106 if (abort_cmd && abort_cmd->qpair) {
2107 mcmd->qpair = abort_cmd->qpair;
2108 mcmd->se_cmd.cpuid = abort_cmd->se_cmd.cpuid;
6b0431d6
QT		 2109 mcmd->abort_io_attr = abort_cmd->atio.u.isp24.attr;
2110 mcmd->flags = QLA24XX_MGMT_ABORT_IO_ATTR_VALID;
84905dfe 2111 }
2d70c103
NB		 2112 }
2113
84905dfe
QT		 2114 INIT_WORK(&mcmd->work, qlt_do_tmr_work);
2115 queue_work_on(mcmd->se_cmd.cpuid, qla_tgt_wq, &mcmd->work);
2116
2d70c103
NB		 2117 return 0;
2118}
2119
2120/*
2121 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
2122 */
2123static void qlt_24xx_handle_abts(struct scsi_qla_host *vha,
2124 struct abts_recv_from_24xx *abts)
2125{
2126 struct qla_hw_data *ha = vha->hw;
5d964837 2127 struct fc_port *sess;
2d70c103 2128 uint32_t tag = abts->exchange_addr_to_abort;
df95f39a 2129 be_id_t s_id;
2d70c103 2130 int rc;
7560151b 2131 unsigned long flags;
2d70c103
NB		 2132
2133 if (le32_to_cpu(abts->fcp_hdr_le.parameter) & ABTS_PARAM_ABORT_SEQ) {
2134 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf053,
2135 "qla_target(%d): ABTS: Abort Sequence not "
2136 "supported\n", vha->vp_idx);
82de802a
QT		 2137 qlt_24xx_send_abts_resp(ha->base_qpair, abts, FCP_TMF_REJECTED,
2138 false);
2d70c103
NB		 2139 return;
2140 }
2141
2142 if (tag == ATIO_EXCHANGE_ADDRESS_UNKNOWN) {
2143 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf010,
2144 "qla_target(%d): ABTS: Unknown Exchange "
2145 "Address received\n", vha->vp_idx);
82de802a
QT		 2146 qlt_24xx_send_abts_resp(ha->base_qpair, abts, FCP_TMF_REJECTED,
2147 false);
2d70c103
NB		 2148 return;
2149 }
2150
2151 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf011,
2152 "qla_target(%d): task abort (s_id=%x:%x:%x, "
df95f39a
BVA		 2153 "tag=%d, param=%x)\n", vha->vp_idx, abts->fcp_hdr_le.s_id.domain,
2154 abts->fcp_hdr_le.s_id.area, abts->fcp_hdr_le.s_id.al_pa, tag,
2d70c103
NB		 2155 le32_to_cpu(abts->fcp_hdr_le.parameter));
2156
df95f39a 2157 s_id = le_id_to_be(abts->fcp_hdr_le.s_id);
2d70c103 2158
7560151b 2159 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
2d70c103
NB		 2160 sess = ha->tgt.tgt_ops->find_sess_by_s_id(vha, s_id);
2161 if (!sess) {
2162 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf012,
03fea736 2163 "qla_target(%d): task abort for non-existent session\n",
2d70c103 2164 vha->vp_idx);
7560151b
QT		 2165 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2166
fb35265b
QT		 2167 qlt_24xx_send_abts_resp(ha->base_qpair, abts, FCP_TMF_REJECTED,
2168 false);
2d70c103
NB		 2169 return;
2170 }
7560151b
QT		 2171 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2172
2d70c103 2173
726b8548 2174 if (sess->deleted) {
82de802a
QT		 2175 qlt_24xx_send_abts_resp(ha->base_qpair, abts, FCP_TMF_REJECTED,
2176 false);
e52a8b45
AP		 2177 return;
2178 }
2179
2d70c103
NB		 2180 rc = __qlt_24xx_handle_abts(vha, abts, sess);
2181 if (rc != 0) {
2182 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf054,
2183 "qla_target(%d): __qlt_24xx_handle_abts() failed: %d\n",
2184 vha->vp_idx, rc);
82de802a
QT		 2185 qlt_24xx_send_abts_resp(ha->base_qpair, abts, FCP_TMF_REJECTED,
2186 false);
2d70c103
NB		 2187 return;
2188 }
2189}
2190
2191/*
2192 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
2193 */
82de802a 2194static void qlt_24xx_send_task_mgmt_ctio(struct qla_qpair *qpair,
2d70c103
NB		 2195 struct qla_tgt_mgmt_cmd *mcmd, uint32_t resp_code)
2196{
72fcd4eb 2197 struct scsi_qla_host *ha = mcmd->vha;
2d70c103
NB		 2198 struct atio_from_isp *atio = &mcmd->orig_iocb.atio;
2199 struct ctio7_to_24xx *ctio;
33a5fcee 2200 uint16_t temp;
2d70c103
NB		 2201
2202 ql_dbg(ql_dbg_tgt, ha, 0xe008,
2203 "Sending task mgmt CTIO7 (ha=%p, atio=%p, resp_code=%x\n",
2204 ha, atio, resp_code);
2205
2d70c103 2206
82de802a 2207 ctio = (struct ctio7_to_24xx *)__qla2x00_alloc_iocbs(qpair, NULL);
2d70c103
NB		 2208 if (ctio == NULL) {
2209 ql_dbg(ql_dbg_tgt, ha, 0xe04c,
2210 "qla_target(%d): %s failed: unable to allocate "
2211 "request packet\n", ha->vp_idx, __func__);
2212 return;
2213 }
2214
2215 ctio->entry_type = CTIO_TYPE7;
2216 ctio->entry_count = 1;
2217 ctio->handle = QLA_TGT_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK;
2218 ctio->nport_handle = mcmd->sess->loop_id;
ad950360 2219 ctio->timeout = cpu_to_le16(QLA_TGT_TIMEOUT);
2d70c103 2220 ctio->vp_index = ha->vp_idx;
df95f39a 2221 ctio->initiator_id = be_id_to_le(atio->u.isp24.fcp_hdr.s_id);
2d70c103 2222 ctio->exchange_addr = atio->u.isp24.exchange_addr;
f7e761f5
QT		 2223 temp = (atio->u.isp24.attr << 9)|
2224 CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_SEND_STATUS;
2225 ctio->u.status1.flags = cpu_to_le16(temp);
33a5fcee
QT		 2226 temp = be16_to_cpu(atio->u.isp24.fcp_hdr.ox_id);
2227 ctio->u.status1.ox_id = cpu_to_le16(temp);
2d70c103 2228 ctio->u.status1.scsi_status =
ad950360
BVA		 2229 cpu_to_le16(SS_RESPONSE_INFO_LEN_VALID);
2230 ctio->u.status1.response_len = cpu_to_le16(8);
e4b11b89 2231 ctio->u.status1.sense_data[0] = resp_code;
2d70c103 2232
63163e06
HM		 2233 /* Memory Barrier */
2234 wmb();
8abfa9e2
QT		 2235 if (qpair->reqq_start_iocbs)
2236 qpair->reqq_start_iocbs(qpair);
2237 else
2238 qla2x00_start_iocbs(ha, qpair->req);
2d70c103
NB		 2239}
2240
2241void qlt_free_mcmd(struct qla_tgt_mgmt_cmd *mcmd)
2242{
2243 mempool_free(mcmd, qla_tgt_mgmt_cmd_mempool);
2244}
2245EXPORT_SYMBOL(qlt_free_mcmd);
2246
be25152c
QT		 2247/*
2248 * ha->hardware_lock supposed to be held on entry. Might drop it, then
2249 * reacquire
2250 */
8abfa9e2 2251void qlt_send_resp_ctio(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
be25152c
QT		 2252 uint8_t scsi_status, uint8_t sense_key, uint8_t asc, uint8_t ascq)
2253{
2254 struct atio_from_isp *atio = &cmd->atio;
2255 struct ctio7_to_24xx *ctio;
2256 uint16_t temp;
8abfa9e2 2257 struct scsi_qla_host *vha = cmd->vha;
be25152c
QT		 2258
2259 ql_dbg(ql_dbg_tgt_dif, vha, 0x3066,
2260 "Sending response CTIO7 (vha=%p, atio=%p, scsi_status=%02x, "
2261 "sense_key=%02x, asc=%02x, ascq=%02x",
2262 vha, atio, scsi_status, sense_key, asc, ascq);
2263
2264 ctio = (struct ctio7_to_24xx *)qla2x00_alloc_iocbs(vha, NULL);
2265 if (!ctio) {
2266 ql_dbg(ql_dbg_async, vha, 0x3067,
2267 "qla2x00t(%ld): %s failed: unable to allocate request packet",
2268 vha->host_no, __func__);
2269 goto out;
2270 }
2271
2272 ctio->entry_type = CTIO_TYPE7;
2273 ctio->entry_count = 1;
2274 ctio->handle = QLA_TGT_SKIP_HANDLE;
2275 ctio->nport_handle = cmd->sess->loop_id;
2276 ctio->timeout = cpu_to_le16(QLA_TGT_TIMEOUT);
2277 ctio->vp_index = vha->vp_idx;
df95f39a 2278 ctio->initiator_id = be_id_to_le(atio->u.isp24.fcp_hdr.s_id);
be25152c 2279 ctio->exchange_addr = atio->u.isp24.exchange_addr;
f7e761f5
QT		 2280 temp = (atio->u.isp24.attr << 9) |
2281 CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_SEND_STATUS;
2282 ctio->u.status1.flags = cpu_to_le16(temp);
be25152c
QT		 2283 temp = be16_to_cpu(atio->u.isp24.fcp_hdr.ox_id);
2284 ctio->u.status1.ox_id = cpu_to_le16(temp);
2285 ctio->u.status1.scsi_status =
2286 cpu_to_le16(SS_RESPONSE_INFO_LEN_VALID | scsi_status);
2287 ctio->u.status1.response_len = cpu_to_le16(18);
2288 ctio->u.status1.residual = cpu_to_le32(get_datalen_for_atio(atio));
2289
2290 if (ctio->u.status1.residual != 0)
2291 ctio->u.status1.scsi_status |=
2292 cpu_to_le16(SS_RESIDUAL_UNDER);
2293
a861b492
BVA		 2294 /* Fixed format sense data. */
2295 ctio->u.status1.sense_data[0] = 0x70;
2296 ctio->u.status1.sense_data[2] = sense_key;
be25152c 2297 /* Additional sense length */
a861b492 2298 ctio->u.status1.sense_data[7] = 0xa;
be25152c 2299 /* ASC and ASCQ */
a861b492
BVA		 2300 ctio->u.status1.sense_data[12] = asc;
2301 ctio->u.status1.sense_data[13] = ascq;
be25152c
QT		 2302
2303 /* Memory Barrier */
2304 wmb();
2305
8abfa9e2
QT		 2306 if (qpair->reqq_start_iocbs)
2307 qpair->reqq_start_iocbs(qpair);
2308 else
2309 qla2x00_start_iocbs(vha, qpair->req);
2310
be25152c
QT		 2311out:
2312 return;
2313}
2314
2d70c103
NB		 2315/* callback from target fabric module code */
2316void qlt_xmit_tm_rsp(struct qla_tgt_mgmt_cmd *mcmd)
2317{
2318 struct scsi_qla_host *vha = mcmd->sess->vha;
2319 struct qla_hw_data *ha = vha->hw;
2320 unsigned long flags;
82de802a 2321 struct qla_qpair *qpair = mcmd->qpair;
6b0431d6 2322 bool free_mcmd = true;
2d70c103
NB		 2323
2324 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf013,
2325 "TM response mcmd (%p) status %#x state %#x",
2326 mcmd, mcmd->fc_tm_rsp, mcmd->flags);
2327
82de802a 2328 spin_lock_irqsave(qpair->qp_lock_ptr, flags);
b6a029e1 2329
7c3f8fd1 2330 if (!vha->flags.online || mcmd->reset_count != qpair->chip_reset) {
b6a029e1 2331 /*
3bb67df5 2332 * Either the port is not online or this request was from
b6a029e1
AE		 2333 * previous life, just abort the processing.
2334 */
2335 ql_dbg(ql_dbg_async, vha, 0xe100,
3bb67df5
DKU		 2336 "RESET-TMR online/active/old-count/new-count = %d/%d/%d/%d.\n",
2337 vha->flags.online, qla2x00_reset_active(vha),
7c3f8fd1 2338 mcmd->reset_count, qpair->chip_reset);
b6a029e1 2339 ha->tgt.tgt_ops->free_mcmd(mcmd);
82de802a 2340 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
b6a029e1
AE		 2341 return;
2342 }
2343
726b8548 2344 if (mcmd->flags == QLA24XX_MGMT_SEND_NACK) {
8837aa8b
BVA		 2345 switch (mcmd->orig_iocb.imm_ntfy.u.isp24.status_subcode) {
2346 case ELS_LOGO:
2347 case ELS_PRLO:
2348 case ELS_TPRLO:
83548fe2 2349 ql_dbg(ql_dbg_disc, vha, 0x2106,
19ce192c 2350 "TM response logo %8phC status %#x state %#x",
726b8548
QT		 2351 mcmd->sess->port_name, mcmd->fc_tm_rsp,
2352 mcmd->flags);
d8630bb9 2353 qlt_schedule_sess_for_deletion(mcmd->sess);
8837aa8b
BVA		 2354 break;
2355 default:
82de802a
QT		 2356 qlt_send_notify_ack(vha->hw->base_qpair,
2357 &mcmd->orig_iocb.imm_ntfy, 0, 0, 0, 0, 0, 0);
8837aa8b 2358 break;
726b8548
QT		 2359 }
2360 } else {
6b0431d6
QT		 2361 if (mcmd->orig_iocb.atio.u.raw.entry_type == ABTS_RECV_24XX) {
2362 qlt_build_abts_resp_iocb(mcmd);
2363 free_mcmd = false;
2364 } else
82de802a 2365 qlt_24xx_send_task_mgmt_ctio(qpair, mcmd,
2d70c103
NB		 2366 mcmd->fc_tm_rsp);
2367 }
2368 /*
2369 * Make the callback for ->free_mcmd() to queue_work() and invoke
2370 * target_put_sess_cmd() to drop cmd_kref to 1. The final
2371 * target_put_sess_cmd() call will be made from TFO->check_stop_free()
2372 * -> tcm_qla2xxx_check_stop_free() to release the TMR associated se_cmd
2373 * descriptor after TFO->queue_tm_rsp() -> tcm_qla2xxx_queue_tm_rsp() ->
2374 * qlt_xmit_tm_rsp() returns here..
2375 */
6b0431d6
QT		 2376 if (free_mcmd)
2377 ha->tgt.tgt_ops->free_mcmd(mcmd);
2378
82de802a 2379 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
2d70c103
NB		 2380}
2381EXPORT_SYMBOL(qlt_xmit_tm_rsp);
2382
2383/* No locks */
2384static int qlt_pci_map_calc_cnt(struct qla_tgt_prm *prm)
2385{
2386 struct qla_tgt_cmd *cmd = prm->cmd;
2387
2388 BUG_ON(cmd->sg_cnt == 0);
2389
2390 prm->sg = (struct scatterlist *)cmd->sg;
e7d0bb77 2391 prm->seg_cnt = dma_map_sg(&cmd->qpair->pdev->dev, cmd->sg,
2d70c103
NB		 2392 cmd->sg_cnt, cmd->dma_data_direction);
2393 if (unlikely(prm->seg_cnt == 0))
2394 goto out_err;
2395
2396 prm->cmd->sg_mapped = 1;
2397
f83adb61
QT		 2398 if (cmd->se_cmd.prot_op == TARGET_PROT_NORMAL) {
2399 /*
2400 * If greater than four sg entries then we need to allocate
2401 * the continuation entries
2402 */
b5399f7d 2403 if (prm->seg_cnt > QLA_TGT_DATASEGS_PER_CMD_24XX)
f83adb61 2404 prm->req_cnt += DIV_ROUND_UP(prm->seg_cnt -
b5399f7d
QT		 2405 QLA_TGT_DATASEGS_PER_CMD_24XX,
2406 QLA_TGT_DATASEGS_PER_CONT_24XX);
f83adb61
QT		 2407 } else {
2408 /* DIF */
2409 if ((cmd->se_cmd.prot_op == TARGET_PROT_DIN_INSERT) ||
2410 (cmd->se_cmd.prot_op == TARGET_PROT_DOUT_STRIP)) {
2411 prm->seg_cnt = DIV_ROUND_UP(cmd->bufflen, cmd->blk_sz);
2412 prm->tot_dsds = prm->seg_cnt;
2413 } else
2414 prm->tot_dsds = prm->seg_cnt;
2415
2416 if (cmd->prot_sg_cnt) {
2417 prm->prot_sg = cmd->prot_sg;
e7d0bb77 2418 prm->prot_seg_cnt = dma_map_sg(&cmd->qpair->pdev->dev,
f83adb61
QT		 2419 cmd->prot_sg, cmd->prot_sg_cnt,
2420 cmd->dma_data_direction);
2421 if (unlikely(prm->prot_seg_cnt == 0))
2422 goto out_err;
2423
2424 if ((cmd->se_cmd.prot_op == TARGET_PROT_DIN_INSERT) ||
2425 (cmd->se_cmd.prot_op == TARGET_PROT_DOUT_STRIP)) {
2426 /* Dif Bundling not support here */
2427 prm->prot_seg_cnt = DIV_ROUND_UP(cmd->bufflen,
2428 cmd->blk_sz);
2429 prm->tot_dsds += prm->prot_seg_cnt;
2430 } else
2431 prm->tot_dsds += prm->prot_seg_cnt;
2432 }
2433 }
2d70c103 2434
2d70c103
NB		 2435 return 0;
2436
2437out_err:
22d84726 2438 ql_dbg_qp(ql_dbg_tgt, prm->cmd->qpair, 0xe04d,
2d70c103
NB		 2439 "qla_target(%d): PCI mapping failed: sg_cnt=%d",
2440 0, prm->cmd->sg_cnt);
2441 return -1;
2442}
2443
f9b6721a 2444static void qlt_unmap_sg(struct scsi_qla_host *vha, struct qla_tgt_cmd *cmd)
2d70c103 2445{
8abfa9e2
QT		 2446 struct qla_hw_data *ha;
2447 struct qla_qpair *qpair;
bd432bb5 2448
f9b6721a
JE		 2449 if (!cmd->sg_mapped)
2450 return;
2451
8abfa9e2
QT		 2452 qpair = cmd->qpair;
2453
e7d0bb77 2454 dma_unmap_sg(&qpair->pdev->dev, cmd->sg, cmd->sg_cnt,
8abfa9e2 2455 cmd->dma_data_direction);
2d70c103 2456 cmd->sg_mapped = 0;
f83adb61
QT		 2457
2458 if (cmd->prot_sg_cnt)
e7d0bb77 2459 dma_unmap_sg(&qpair->pdev->dev, cmd->prot_sg, cmd->prot_sg_cnt,
f83adb61
QT		 2460 cmd->dma_data_direction);
2461
d5ff0eed
JC		 2462 if (!cmd->ctx)
2463 return;
8abfa9e2 2464 ha = vha->hw;
f83adb61 2465 if (cmd->ctx_dsd_alloced)
d5ff0eed 2466 qla2x00_clean_dsd_pool(ha, cmd->ctx);
f83adb61 2467
d5ff0eed 2468 dma_pool_free(ha->dl_dma_pool, cmd->ctx, cmd->ctx->crc_ctx_dma);
2d70c103
NB		 2469}
2470
82de802a 2471static int qlt_check_reserve_free_req(struct qla_qpair *qpair,
2d70c103
NB		 2472 uint32_t req_cnt)
2473{
d63b328f 2474 uint32_t cnt;
82de802a 2475 struct req_que *req = qpair->req;
2d70c103 2476
82de802a 2477 if (req->cnt < (req_cnt + 2)) {
af7bb382
QT		 2478 cnt = (uint16_t)(qpair->use_shadow_reg ? *req->out_ptr :
2479 RD_REG_DWORD_RELAXED(req->req_q_out));
2d70c103 2480
82de802a
QT		 2481 if (req->ring_index < cnt)
2482 req->cnt = cnt - req->ring_index;
2d70c103 2483 else
82de802a 2484 req->cnt = req->length - (req->ring_index - cnt);
2d70c103 2485
82de802a 2486 if (unlikely(req->cnt < (req_cnt + 2)))
bc7095a9 2487 return -EAGAIN;
2d70c103 2488 }
bc7095a9 2489
82de802a 2490 req->cnt -= req_cnt;
2d70c103
NB		 2491
2492 return 0;
2493}
2494
2495/*
2496 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
2497 */
82de802a 2498static inline void *qlt_get_req_pkt(struct req_que *req)
2d70c103
NB		 2499{
2500 /* Adjust ring index. */
82de802a
QT		 2501 req->ring_index++;
2502 if (req->ring_index == req->length) {
2503 req->ring_index = 0;
2504 req->ring_ptr = req->ring;
2d70c103 2505 } else {
82de802a 2506 req->ring_ptr++;
2d70c103 2507 }
82de802a 2508 return (cont_entry_t *)req->ring_ptr;
2d70c103
NB		 2509}
2510
2511/* ha->hardware_lock supposed to be held on entry */
82de802a 2512static inline uint32_t qlt_make_handle(struct qla_qpair *qpair)
2d70c103 2513{
2d70c103 2514 uint32_t h;
c5419e26
QT		 2515 int index;
2516 uint8_t found = 0;
82de802a 2517 struct req_que *req = qpair->req;
c5419e26
QT		 2518
2519 h = req->current_outstanding_cmd;
2d70c103 2520
c5419e26
QT		 2521 for (index = 1; index < req->num_outstanding_cmds; index++) {
2522 h++;
2523 if (h == req->num_outstanding_cmds)
2524 h = 1;
2525
2526 if (h == QLA_TGT_SKIP_HANDLE)
2527 continue;
2528
2529 if (!req->outstanding_cmds[h]) {
2530 found = 1;
2d70c103
NB		 2531 break;
2532 }
c5419e26 2533 }
2d70c103 2534
c5419e26
QT		 2535 if (found) {
2536 req->current_outstanding_cmd = h;
2537 } else {
8abfa9e2
QT		 2538 ql_dbg(ql_dbg_io, qpair->vha, 0x305b,
2539 "qla_target(%d): Ran out of empty cmd slots\n",
2540 qpair->vha->vp_idx);
c5419e26
QT		 2541 h = QLA_TGT_NULL_HANDLE;
2542 }
2d70c103
NB		 2543
2544 return h;
2545}
2546
2547/* ha->hardware_lock supposed to be held on entry */
82de802a
QT		 2548static int qlt_24xx_build_ctio_pkt(struct qla_qpair *qpair,
2549 struct qla_tgt_prm *prm)
2d70c103
NB		 2550{
2551 uint32_t h;
2552 struct ctio7_to_24xx *pkt;
2d70c103 2553 struct atio_from_isp *atio = &prm->cmd->atio;
33a5fcee 2554 uint16_t temp;
2d70c103 2555
82de802a 2556 pkt = (struct ctio7_to_24xx *)qpair->req->ring_ptr;
2d70c103
NB		 2557 prm->pkt = pkt;
2558 memset(pkt, 0, sizeof(*pkt));
2559
2560 pkt->entry_type = CTIO_TYPE7;
2561 pkt->entry_count = (uint8_t)prm->req_cnt;
22d84726 2562 pkt->vp_index = prm->cmd->vp_idx;
2d70c103 2563
82de802a 2564 h = qlt_make_handle(qpair);
2d70c103
NB		 2565 if (unlikely(h == QLA_TGT_NULL_HANDLE)) {
2566 /*
2567 * CTIO type 7 from the firmware doesn't provide a way to
2568 * know the initiator's LOOP ID, hence we can't find
2569 * the session and, so, the command.
2570 */
2571 return -EAGAIN;
e326d22a
QT		 2572 } else
2573 qpair->req->outstanding_cmds[h] = (srb_t *)prm->cmd;
2d70c103 2574
82de802a
QT		 2575 pkt->handle = MAKE_HANDLE(qpair->req->id, h);
2576 pkt->handle |= CTIO_COMPLETION_HANDLE_MARK;
2577 pkt->nport_handle = cpu_to_le16(prm->cmd->loop_id);
ad950360 2578 pkt->timeout = cpu_to_le16(QLA_TGT_TIMEOUT);
df95f39a 2579 pkt->initiator_id = be_id_to_le(atio->u.isp24.fcp_hdr.s_id);
2d70c103 2580 pkt->exchange_addr = atio->u.isp24.exchange_addr;
f7e761f5
QT		 2581 temp = atio->u.isp24.attr << 9;
2582 pkt->u.status0.flags |= cpu_to_le16(temp);
33a5fcee
QT		 2583 temp = be16_to_cpu(atio->u.isp24.fcp_hdr.ox_id);
2584 pkt->u.status0.ox_id = cpu_to_le16(temp);
2d70c103
NB		 2585 pkt->u.status0.relative_offset = cpu_to_le32(prm->cmd->offset);
2586
2d70c103
NB		 2587 return 0;
2588}
2589
2590/*
2591 * ha->hardware_lock supposed to be held on entry. We have already made sure
2592 * that there is sufficient amount of request entries to not drop it.
2593 */
32d29b4c 2594static void qlt_load_cont_data_segments(struct qla_tgt_prm *prm)
2d70c103
NB		 2595{
2596 int cnt;
15b7a68c 2597 struct dsd64 *cur_dsd;
2d70c103
NB		 2598
2599 /* Build continuation packets */
2600 while (prm->seg_cnt > 0) {
2601 cont_a64_entry_t *cont_pkt64 =
82de802a
QT		 2602 (cont_a64_entry_t *)qlt_get_req_pkt(
2603 prm->cmd->qpair->req);
2d70c103
NB		 2604
2605 /*
2606 * Make sure that from cont_pkt64 none of
2607 * 64-bit specific fields used for 32-bit
2608 * addressing. Cast to (cont_entry_t *) for
2609 * that.
2610 */
2611
2612 memset(cont_pkt64, 0, sizeof(*cont_pkt64));
2613
2614 cont_pkt64->entry_count = 1;
2615 cont_pkt64->sys_define = 0;
2616
32d29b4c 2617 cont_pkt64->entry_type = CONTINUE_A64_TYPE;
15b7a68c 2618 cur_dsd = cont_pkt64->dsd;
2d70c103
NB		 2619
2620 /* Load continuation entry data segments */
2621 for (cnt = 0;
b5399f7d 2622 cnt < QLA_TGT_DATASEGS_PER_CONT_24XX && prm->seg_cnt;
2d70c103 2623 cnt++, prm->seg_cnt--) {
15b7a68c 2624 append_dsd64(&cur_dsd, prm->sg);
2d70c103
NB		 2625 prm->sg = sg_next(prm->sg);
2626 }
2627 }
2628}
2629
2630/*
2631 * ha->hardware_lock supposed to be held on entry. We have already made sure
2632 * that there is sufficient amount of request entries to not drop it.
2633 */
32d29b4c 2634static void qlt_load_data_segments(struct qla_tgt_prm *prm)
2d70c103
NB		 2635{
2636 int cnt;
15b7a68c 2637 struct dsd64 *cur_dsd;
2d70c103
NB		 2638 struct ctio7_to_24xx *pkt24 = (struct ctio7_to_24xx *)prm->pkt;
2639
2d70c103
NB		 2640 pkt24->u.status0.transfer_length = cpu_to_le32(prm->cmd->bufflen);
2641
2642 /* Setup packet address segment pointer */
15b7a68c 2643 cur_dsd = &pkt24->u.status0.dsd;
2d70c103
NB		 2644
2645 /* Set total data segment count */
2646 if (prm->seg_cnt)
2647 pkt24->dseg_count = cpu_to_le16(prm->seg_cnt);
2648
2649 if (prm->seg_cnt == 0) {
2650 /* No data transfer */
15b7a68c
BVA		 2651 cur_dsd->address = 0;
2652 cur_dsd->length = 0;
2d70c103
NB		 2653 return;
2654 }
2655
2656 /* If scatter gather */
2d70c103
NB		 2657
2658 /* Load command entry data segments */
2659 for (cnt = 0;
b5399f7d 2660 (cnt < QLA_TGT_DATASEGS_PER_CMD_24XX) && prm->seg_cnt;
2d70c103 2661 cnt++, prm->seg_cnt--) {
15b7a68c 2662 append_dsd64(&cur_dsd, prm->sg);
2d70c103
NB		 2663 prm->sg = sg_next(prm->sg);
2664 }
2665
32d29b4c 2666 qlt_load_cont_data_segments(prm);
2d70c103
NB		 2667}
2668
2669static inline int qlt_has_data(struct qla_tgt_cmd *cmd)
2670{
2671 return cmd->bufflen > 0;
2672}
2673
be25152c
QT		 2674static void qlt_print_dif_err(struct qla_tgt_prm *prm)
2675{
2676 struct qla_tgt_cmd *cmd;
2677 struct scsi_qla_host *vha;
2678
2679 /* asc 0x10=dif error */
2680 if (prm->sense_buffer && (prm->sense_buffer[12] == 0x10)) {
2681 cmd = prm->cmd;
2682 vha = cmd->vha;
2683 /* ASCQ */
2684 switch (prm->sense_buffer[13]) {
2685 case 1:
83548fe2 2686 ql_dbg(ql_dbg_tgt_dif, vha, 0xe00b,
be25152c
QT		 2687 "BE detected Guard TAG ERR: lba[0x%llx|%lld] len[0x%x] "
2688 "se_cmd=%p tag[%x]",
2689 cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
2690 cmd->atio.u.isp24.exchange_addr);
2691 break;
2692 case 2:
83548fe2 2693 ql_dbg(ql_dbg_tgt_dif, vha, 0xe00c,
be25152c
QT		 2694 "BE detected APP TAG ERR: lba[0x%llx|%lld] len[0x%x] "
2695 "se_cmd=%p tag[%x]",
2696 cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
2697 cmd->atio.u.isp24.exchange_addr);
2698 break;
2699 case 3:
83548fe2 2700 ql_dbg(ql_dbg_tgt_dif, vha, 0xe00f,
be25152c
QT		 2701 "BE detected REF TAG ERR: lba[0x%llx|%lld] len[0x%x] "
2702 "se_cmd=%p tag[%x]",
2703 cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
2704 cmd->atio.u.isp24.exchange_addr);
2705 break;
2706 default:
83548fe2 2707 ql_dbg(ql_dbg_tgt_dif, vha, 0xe010,
be25152c
QT		 2708 "BE detected Dif ERR: lba[%llx|%lld] len[%x] "
2709 "se_cmd=%p tag[%x]",
2710 cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
2711 cmd->atio.u.isp24.exchange_addr);
2712 break;
2713 }
83548fe2 2714 ql_dump_buffer(ql_dbg_tgt_dif, vha, 0xe011, cmd->cdb, 16);
be25152c
QT		 2715 }
2716}
2717
2d70c103
NB		 2718/*
2719 * Called without ha->hardware_lock held
2720 */
2721static int qlt_pre_xmit_response(struct qla_tgt_cmd *cmd,
2722 struct qla_tgt_prm *prm, int xmit_type, uint8_t scsi_status,
2723 uint32_t *full_req_cnt)
2724{
2d70c103 2725 struct se_cmd *se_cmd = &cmd->se_cmd;
22d84726 2726 struct qla_qpair *qpair = cmd->qpair;
2d70c103 2727
2d70c103 2728 prm->cmd = cmd;
7c3f8fd1
QT		 2729 prm->tgt = cmd->tgt;
2730 prm->pkt = NULL;
2d70c103
NB		 2731 prm->rq_result = scsi_status;
2732 prm->sense_buffer = &cmd->sense_buffer[0];
2733 prm->sense_buffer_len = TRANSPORT_SENSE_BUFFER;
2734 prm->sg = NULL;
2735 prm->seg_cnt = -1;
2736 prm->req_cnt = 1;
7c3f8fd1 2737 prm->residual = 0;
2d70c103 2738 prm->add_status_pkt = 0;
7c3f8fd1
QT		 2739 prm->prot_sg = NULL;
2740 prm->prot_seg_cnt = 0;
2741 prm->tot_dsds = 0;
2d70c103 2742
2d70c103
NB		 2743 if ((xmit_type & QLA_TGT_XMIT_DATA) && qlt_has_data(cmd)) {
2744 if (qlt_pci_map_calc_cnt(prm) != 0)
2745 return -EAGAIN;
2746 }
2747
2748 *full_req_cnt = prm->req_cnt;
2749
2750 if (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) {
2751 prm->residual = se_cmd->residual_count;
22d84726 2752 ql_dbg_qp(ql_dbg_io + ql_dbg_verbose, qpair, 0x305c,
649ee054
BVA		 2753 "Residual underflow: %d (tag %lld, op %x, bufflen %d, rq_result %x)\n",
2754 prm->residual, se_cmd->tag,
2755 se_cmd->t_task_cdb ? se_cmd->t_task_cdb[0] : 0,
2756 cmd->bufflen, prm->rq_result);
2d70c103
NB		 2757 prm->rq_result |= SS_RESIDUAL_UNDER;
2758 } else if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
2759 prm->residual = se_cmd->residual_count;
22d84726 2760 ql_dbg_qp(ql_dbg_io, qpair, 0x305d,
649ee054
BVA		 2761 "Residual overflow: %d (tag %lld, op %x, bufflen %d, rq_result %x)\n",
2762 prm->residual, se_cmd->tag, se_cmd->t_task_cdb ?
2763 se_cmd->t_task_cdb[0] : 0, cmd->bufflen, prm->rq_result);
2d70c103
NB		 2764 prm->rq_result |= SS_RESIDUAL_OVER;
2765 }
2766
2767 if (xmit_type & QLA_TGT_XMIT_STATUS) {
2768 /*
2769 * If QLA_TGT_XMIT_DATA is not set, add_status_pkt will be
2770 * ignored in *xmit_response() below
2771 */
2772 if (qlt_has_data(cmd)) {
2773 if (QLA_TGT_SENSE_VALID(prm->sense_buffer) ||
7c3f8fd1 2774 (IS_FWI2_CAPABLE(cmd->vha->hw) &&
2d70c103
NB		 2775 (prm->rq_result != 0))) {
2776 prm->add_status_pkt = 1;
2777 (*full_req_cnt)++;
2778 }
2779 }
2780 }
2781
2d70c103
NB		 2782 return 0;
2783}
2784
7c3f8fd1
QT		 2785static inline int qlt_need_explicit_conf(struct qla_tgt_cmd *cmd,
2786 int sending_sense)
2d70c103 2787{
7c3f8fd1 2788 if (cmd->qpair->enable_class_2)
2d70c103
NB		 2789 return 0;
2790
2791 if (sending_sense)
2792 return cmd->conf_compl_supported;
2793 else
7c3f8fd1
QT		 2794 return cmd->qpair->enable_explicit_conf &&
2795 cmd->conf_compl_supported;
2d70c103
NB		 2796}
2797
2d70c103
NB		 2798static void qlt_24xx_init_ctio_to_isp(struct ctio7_to_24xx *ctio,
2799 struct qla_tgt_prm *prm)
2800{
2801 prm->sense_buffer_len = min_t(uint32_t, prm->sense_buffer_len,
2802 (uint32_t)sizeof(ctio->u.status1.sense_data));
ad950360 2803 ctio->u.status0.flags |= cpu_to_le16(CTIO7_FLAGS_SEND_STATUS);
7c3f8fd1 2804 if (qlt_need_explicit_conf(prm->cmd, 0)) {
ad950360 2805 ctio->u.status0.flags |= cpu_to_le16(
2d70c103
NB		 2806 CTIO7_FLAGS_EXPLICIT_CONFORM |
2807 CTIO7_FLAGS_CONFORM_REQ);
2808 }
2809 ctio->u.status0.residual = cpu_to_le32(prm->residual);
2810 ctio->u.status0.scsi_status = cpu_to_le16(prm->rq_result);
2811 if (QLA_TGT_SENSE_VALID(prm->sense_buffer)) {
2812 int i;
2813
7c3f8fd1 2814 if (qlt_need_explicit_conf(prm->cmd, 1)) {
df2e32c5 2815 if ((prm->rq_result & SS_SCSI_STATUS_BYTE) != 0) {
22d84726 2816 ql_dbg_qp(ql_dbg_tgt, prm->cmd->qpair, 0xe017,
2d70c103
NB		 2817 "Skipping EXPLICIT_CONFORM and "
2818 "CTIO7_FLAGS_CONFORM_REQ for FCP READ w/ "
2819 "non GOOD status\n");
2820 goto skip_explict_conf;
2821 }
ad950360 2822 ctio->u.status1.flags |= cpu_to_le16(
2d70c103
NB		 2823 CTIO7_FLAGS_EXPLICIT_CONFORM |
2824 CTIO7_FLAGS_CONFORM_REQ);
2825 }
2826skip_explict_conf:
2827 ctio->u.status1.flags &=
ad950360 2828 ~cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_0);
2d70c103 2829 ctio->u.status1.flags |=
ad950360 2830 cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1);
2d70c103 2831 ctio->u.status1.scsi_status |=
ad950360 2832 cpu_to_le16(SS_SENSE_LEN_VALID);
2d70c103
NB		 2833 ctio->u.status1.sense_length =
2834 cpu_to_le16(prm->sense_buffer_len);
2835 for (i = 0; i < prm->sense_buffer_len/4; i++)
2836 ((uint32_t *)ctio->u.status1.sense_data)[i] =
2837 cpu_to_be32(((uint32_t *)prm->sense_buffer)[i]);
be25152c
QT		 2838
2839 qlt_print_dif_err(prm);
2840
2d70c103
NB		 2841 } else {
2842 ctio->u.status1.flags &=
ad950360 2843 ~cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_0);
2d70c103 2844 ctio->u.status1.flags |=
ad950360 2845 cpu_to_le16(CTIO7_FLAGS_STATUS_MODE_1);
2d70c103
NB		 2846 ctio->u.status1.sense_length = 0;
2847 memset(ctio->u.status1.sense_data, 0,
2848 sizeof(ctio->u.status1.sense_data));
2849 }
2850
2851 /* Sense with len > 24, is it possible ??? */
2852}
2853
f83adb61
QT		 2854static inline int
2855qlt_hba_err_chk_enabled(struct se_cmd *se_cmd)
2856{
f83adb61
QT		 2857 switch (se_cmd->prot_op) {
2858 case TARGET_PROT_DOUT_INSERT:
2859 case TARGET_PROT_DIN_STRIP:
2860 if (ql2xenablehba_err_chk >= 1)
2861 return 1;
2862 break;
2863 case TARGET_PROT_DOUT_PASS:
2864 case TARGET_PROT_DIN_PASS:
2865 if (ql2xenablehba_err_chk >= 2)
2866 return 1;
2867 break;
2868 case TARGET_PROT_DIN_INSERT:
2869 case TARGET_PROT_DOUT_STRIP:
2870 return 1;
2871 default:
2872 break;
2873 }
2874 return 0;
2875}
2876
be25152c
QT		 2877static inline int
2878qla_tgt_ref_mask_check(struct se_cmd *se_cmd)
2879{
2880 switch (se_cmd->prot_op) {
2881 case TARGET_PROT_DIN_INSERT:
2882 case TARGET_PROT_DOUT_INSERT:
2883 case TARGET_PROT_DIN_STRIP:
2884 case TARGET_PROT_DOUT_STRIP:
2885 case TARGET_PROT_DIN_PASS:
2886 case TARGET_PROT_DOUT_PASS:
2887 return 1;
2888 default:
2889 return 0;
2890 }
2891 return 0;
2892}
2893
f83adb61 2894/*
be25152c 2895 * qla_tgt_set_dif_tags - Extract Ref and App tags from SCSI command
f83adb61 2896 */
be25152c
QT		 2897static void
2898qla_tgt_set_dif_tags(struct qla_tgt_cmd *cmd, struct crc_context *ctx,
2899 uint16_t *pfw_prot_opts)
f83adb61 2900{
be25152c 2901 struct se_cmd *se_cmd = &cmd->se_cmd;
f83adb61 2902 uint32_t lba = 0xffffffff & se_cmd->t_task_lba;
be25152c
QT		 2903 scsi_qla_host_t *vha = cmd->tgt->vha;
2904 struct qla_hw_data *ha = vha->hw;
2905 uint32_t t32 = 0;
f83adb61 2906
be25152c
QT		 2907 /*
2908 * wait till Mode Sense/Select cmd, modepage Ah, subpage 2
f83adb61
QT		 2909 * have been immplemented by TCM, before AppTag is avail.
2910 * Look for modesense_handlers[]
2911 */
c7ee3bd4 2912 ctx->app_tag = 0;
f83adb61
QT		 2913 ctx->app_tag_mask[0] = 0x0;
2914 ctx->app_tag_mask[1] = 0x0;
2915
be25152c
QT		 2916 if (IS_PI_UNINIT_CAPABLE(ha)) {
2917 if ((se_cmd->prot_type == TARGET_DIF_TYPE1_PROT) ||
2918 (se_cmd->prot_type == TARGET_DIF_TYPE2_PROT))
2919 *pfw_prot_opts |= PO_DIS_VALD_APP_ESC;
2920 else if (se_cmd->prot_type == TARGET_DIF_TYPE3_PROT)
2921 *pfw_prot_opts |= PO_DIS_VALD_APP_REF_ESC;
2922 }
2923
2924 t32 = ha->tgt.tgt_ops->get_dif_tags(cmd, pfw_prot_opts);
2925
f83adb61
QT		 2926 switch (se_cmd->prot_type) {
2927 case TARGET_DIF_TYPE0_PROT:
2928 /*
be25152c
QT		 2929 * No check for ql2xenablehba_err_chk, as it
2930 * would be an I/O error if hba tag generation
2931 * is not done.
f83adb61
QT		 2932 */
2933 ctx->ref_tag = cpu_to_le32(lba);
f83adb61
QT		 2934 /* enable ALL bytes of the ref tag */
2935 ctx->ref_tag_mask[0] = 0xff;
2936 ctx->ref_tag_mask[1] = 0xff;
2937 ctx->ref_tag_mask[2] = 0xff;
2938 ctx->ref_tag_mask[3] = 0xff;
2939 break;
f83adb61 2940 case TARGET_DIF_TYPE1_PROT:
be25152c
QT		 2941 /*
2942 * For TYPE 1 protection: 16 bit GUARD tag, 32 bit
2943 * REF tag, and 16 bit app tag.
2944 */
2945 ctx->ref_tag = cpu_to_le32(lba);
2946 if (!qla_tgt_ref_mask_check(se_cmd) ||
2947 !(ha->tgt.tgt_ops->chk_dif_tags(t32))) {
2948 *pfw_prot_opts |= PO_DIS_REF_TAG_VALD;
2949 break;
2950 }
2951 /* enable ALL bytes of the ref tag */
2952 ctx->ref_tag_mask[0] = 0xff;
2953 ctx->ref_tag_mask[1] = 0xff;
2954 ctx->ref_tag_mask[2] = 0xff;
2955 ctx->ref_tag_mask[3] = 0xff;
2956 break;
f83adb61 2957 case TARGET_DIF_TYPE2_PROT:
be25152c
QT		 2958 /*
2959 * For TYPE 2 protection: 16 bit GUARD + 32 bit REF
2960 * tag has to match LBA in CDB + N
2961 */
2962 ctx->ref_tag = cpu_to_le32(lba);
2963 if (!qla_tgt_ref_mask_check(se_cmd) ||
2964 !(ha->tgt.tgt_ops->chk_dif_tags(t32))) {
2965 *pfw_prot_opts |= PO_DIS_REF_TAG_VALD;
2966 break;
2967 }
2968 /* enable ALL bytes of the ref tag */
2969 ctx->ref_tag_mask[0] = 0xff;
2970 ctx->ref_tag_mask[1] = 0xff;
2971 ctx->ref_tag_mask[2] = 0xff;
2972 ctx->ref_tag_mask[3] = 0xff;
2973 break;
f83adb61 2974 case TARGET_DIF_TYPE3_PROT:
be25152c
QT		 2975 /* For TYPE 3 protection: 16 bit GUARD only */
2976 *pfw_prot_opts |= PO_DIS_REF_TAG_VALD;
2977 ctx->ref_tag_mask[0] = ctx->ref_tag_mask[1] =
2978 ctx->ref_tag_mask[2] = ctx->ref_tag_mask[3] = 0x00;
2979 break;
f83adb61
QT		 2980 }
2981}
2982
f83adb61 2983static inline int
82de802a 2984qlt_build_ctio_crc2_pkt(struct qla_qpair *qpair, struct qla_tgt_prm *prm)
f83adb61 2985{
15b7a68c 2986 struct dsd64 *cur_dsd;
f83adb61
QT		 2987 uint32_t transfer_length = 0;
2988 uint32_t data_bytes;
2989 uint32_t dif_bytes;
2990 uint8_t bundling = 1;
f83adb61
QT		 2991 struct crc_context *crc_ctx_pkt = NULL;
2992 struct qla_hw_data *ha;
2993 struct ctio_crc2_to_fw *pkt;
2994 dma_addr_t crc_ctx_dma;
2995 uint16_t fw_prot_opts = 0;
2996 struct qla_tgt_cmd *cmd = prm->cmd;
2997 struct se_cmd *se_cmd = &cmd->se_cmd;
2998 uint32_t h;
2999 struct atio_from_isp *atio = &prm->cmd->atio;
be25152c 3000 struct qla_tc_param tc;
c7ee3bd4 3001 uint16_t t16;
82de802a 3002 scsi_qla_host_t *vha = cmd->vha;
f83adb61 3003
f83adb61
QT		 3004 ha = vha->hw;
3005
82de802a 3006 pkt = (struct ctio_crc2_to_fw *)qpair->req->ring_ptr;
f83adb61
QT		 3007 prm->pkt = pkt;
3008 memset(pkt, 0, sizeof(*pkt));
3009
22d84726 3010 ql_dbg_qp(ql_dbg_tgt, cmd->qpair, 0xe071,
f83adb61 3011 "qla_target(%d):%s: se_cmd[%p] CRC2 prot_op[0x%x] cmd prot sg:cnt[%p:%x] lba[%llu]\n",
22d84726 3012 cmd->vp_idx, __func__, se_cmd, se_cmd->prot_op,
f83adb61
QT		 3013 prm->prot_sg, prm->prot_seg_cnt, se_cmd->t_task_lba);
3014
3015 if ((se_cmd->prot_op == TARGET_PROT_DIN_INSERT) ||
3016 (se_cmd->prot_op == TARGET_PROT_DOUT_STRIP))
3017 bundling = 0;
3018
3019 /* Compute dif len and adjust data len to incude protection */
3020 data_bytes = cmd->bufflen;
3021 dif_bytes = (data_bytes / cmd->blk_sz) * 8;
3022
3023 switch (se_cmd->prot_op) {
3024 case TARGET_PROT_DIN_INSERT:
3025 case TARGET_PROT_DOUT_STRIP:
3026 transfer_length = data_bytes;
be25152c
QT		 3027 if (cmd->prot_sg_cnt)
3028 data_bytes += dif_bytes;
f83adb61 3029 break;
f83adb61
QT		 3030 case TARGET_PROT_DIN_STRIP:
3031 case TARGET_PROT_DOUT_INSERT:
3032 case TARGET_PROT_DIN_PASS:
3033 case TARGET_PROT_DOUT_PASS:
3034 transfer_length = data_bytes + dif_bytes;
3035 break;
f83adb61
QT		 3036 default:
3037 BUG();
3038 break;
3039 }
3040
3041 if (!qlt_hba_err_chk_enabled(se_cmd))
3042 fw_prot_opts |= 0x10; /* Disable Guard tag checking */
3043 /* HBA error checking enabled */
3044 else if (IS_PI_UNINIT_CAPABLE(ha)) {
3045 if ((se_cmd->prot_type == TARGET_DIF_TYPE1_PROT) ||
3046 (se_cmd->prot_type == TARGET_DIF_TYPE2_PROT))
3047 fw_prot_opts |= PO_DIS_VALD_APP_ESC;
3048 else if (se_cmd->prot_type == TARGET_DIF_TYPE3_PROT)
3049 fw_prot_opts |= PO_DIS_VALD_APP_REF_ESC;
3050 }
3051
3052 switch (se_cmd->prot_op) {
3053 case TARGET_PROT_DIN_INSERT:
3054 case TARGET_PROT_DOUT_INSERT:
3055 fw_prot_opts |= PO_MODE_DIF_INSERT;
3056 break;
3057 case TARGET_PROT_DIN_STRIP:
3058 case TARGET_PROT_DOUT_STRIP:
3059 fw_prot_opts |= PO_MODE_DIF_REMOVE;
3060 break;
3061 case TARGET_PROT_DIN_PASS:
3062 case TARGET_PROT_DOUT_PASS:
3063 fw_prot_opts |= PO_MODE_DIF_PASS;
3064 /* FUTURE: does tcm require T10CRC<->IPCKSUM conversion? */
3065 break;
3066 default:/* Normal Request */
3067 fw_prot_opts |= PO_MODE_DIF_PASS;
3068 break;
3069 }
3070
f83adb61
QT		 3071 /* ---- PKT ---- */
3072 /* Update entry type to indicate Command Type CRC_2 IOCB */
3073 pkt->entry_type = CTIO_CRC2;
3074 pkt->entry_count = 1;
22d84726 3075 pkt->vp_index = cmd->vp_idx;
f83adb61 3076
82de802a 3077 h = qlt_make_handle(qpair);
f83adb61
QT		 3078 if (unlikely(h == QLA_TGT_NULL_HANDLE)) {
3079 /*
3080 * CTIO type 7 from the firmware doesn't provide a way to
3081 * know the initiator's LOOP ID, hence we can't find
3082 * the session and, so, the command.
3083 */
3084 return -EAGAIN;
3085 } else
82de802a 3086 qpair->req->outstanding_cmds[h] = (srb_t *)prm->cmd;
f83adb61 3087
82de802a
QT		 3088 pkt->handle = MAKE_HANDLE(qpair->req->id, h);
3089 pkt->handle |= CTIO_COMPLETION_HANDLE_MARK;
be25152c 3090 pkt->nport_handle = cpu_to_le16(prm->cmd->loop_id);
ad950360 3091 pkt->timeout = cpu_to_le16(QLA_TGT_TIMEOUT);
df95f39a 3092 pkt->initiator_id = be_id_to_le(atio->u.isp24.fcp_hdr.s_id);
f83adb61 3093 pkt->exchange_addr = atio->u.isp24.exchange_addr;
c7ee3bd4
QT		 3094
3095 /* silence compile warning */
3096 t16 = be16_to_cpu(atio->u.isp24.fcp_hdr.ox_id);
3097 pkt->ox_id = cpu_to_le16(t16);
3098
3099 t16 = (atio->u.isp24.attr << 9);
3100 pkt->flags |= cpu_to_le16(t16);
f83adb61
QT		 3101 pkt->relative_offset = cpu_to_le32(prm->cmd->offset);
3102
3103 /* Set transfer direction */
3104 if (cmd->dma_data_direction == DMA_TO_DEVICE)
ad950360 3105 pkt->flags = cpu_to_le16(CTIO7_FLAGS_DATA_IN);
f83adb61 3106 else if (cmd->dma_data_direction == DMA_FROM_DEVICE)
ad950360 3107 pkt->flags = cpu_to_le16(CTIO7_FLAGS_DATA_OUT);
f83adb61 3108
f83adb61
QT		 3109 pkt->dseg_count = prm->tot_dsds;
3110 /* Fibre channel byte count */
3111 pkt->transfer_length = cpu_to_le32(transfer_length);
3112
f83adb61
QT		 3113 /* ----- CRC context -------- */
3114
3115 /* Allocate CRC context from global pool */
3116 crc_ctx_pkt = cmd->ctx =
501017f6 3117 dma_pool_zalloc(ha->dl_dma_pool, GFP_ATOMIC, &crc_ctx_dma);
f83adb61
QT		 3118
3119 if (!crc_ctx_pkt)
3120 goto crc_queuing_error;
3121
f83adb61
QT		 3122 crc_ctx_pkt->crc_ctx_dma = crc_ctx_dma;
3123 INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list);
3124
3125 /* Set handle */
3126 crc_ctx_pkt->handle = pkt->handle;
3127
be25152c 3128 qla_tgt_set_dif_tags(cmd, crc_ctx_pkt, &fw_prot_opts);
f83adb61 3129
d4556a49 3130 put_unaligned_le64(crc_ctx_dma, &pkt->crc_context_address);
f83adb61
QT		 3131 pkt->crc_context_len = CRC_CONTEXT_LEN_FW;
3132
f83adb61 3133 if (!bundling) {
9e75b5e2 3134 cur_dsd = &crc_ctx_pkt->u.nobundling.data_dsd[0];
f83adb61
QT		 3135 } else {
3136 /*
3137 * Configure Bundling if we need to fetch interlaving
3138 * protection PCI accesses
3139 */
3140 fw_prot_opts |= PO_ENABLE_DIF_BUNDLING;
3141 crc_ctx_pkt->u.bundling.dif_byte_count = cpu_to_le32(dif_bytes);
3142 crc_ctx_pkt->u.bundling.dseg_count =
3143 cpu_to_le16(prm->tot_dsds - prm->prot_seg_cnt);
9e75b5e2 3144 cur_dsd = &crc_ctx_pkt->u.bundling.data_dsd[0];
f83adb61
QT		 3145 }
3146
3147 /* Finish the common fields of CRC pkt */
3148 crc_ctx_pkt->blk_size = cpu_to_le16(cmd->blk_sz);
3149 crc_ctx_pkt->prot_opts = cpu_to_le16(fw_prot_opts);
3150 crc_ctx_pkt->byte_count = cpu_to_le32(data_bytes);
ad950360 3151 crc_ctx_pkt->guard_seed = cpu_to_le16(0);
f83adb61 3152
be25152c
QT		 3153 memset((uint8_t *)&tc, 0 , sizeof(tc));
3154 tc.vha = vha;
3155 tc.blk_sz = cmd->blk_sz;
3156 tc.bufflen = cmd->bufflen;
3157 tc.sg = cmd->sg;
3158 tc.prot_sg = cmd->prot_sg;
3159 tc.ctx = crc_ctx_pkt;
3160 tc.ctx_dsd_alloced = &cmd->ctx_dsd_alloced;
f83adb61
QT		 3161
3162 /* Walks data segments */
ad950360 3163 pkt->flags |= cpu_to_le16(CTIO7_FLAGS_DSD_PTR);
f83adb61
QT		 3164
3165 if (!bundling && prm->prot_seg_cnt) {
3166 if (qla24xx_walk_and_build_sglist_no_difb(ha, NULL, cur_dsd,
be25152c 3167 prm->tot_dsds, &tc))
f83adb61
QT		 3168 goto crc_queuing_error;
3169 } else if (qla24xx_walk_and_build_sglist(ha, NULL, cur_dsd,
be25152c 3170 (prm->tot_dsds - prm->prot_seg_cnt), &tc))
f83adb61
QT		 3171 goto crc_queuing_error;
3172
3173 if (bundling && prm->prot_seg_cnt) {
3174 /* Walks dif segments */
c7ee3bd4 3175 pkt->add_flags |= CTIO_CRC2_AF_DIF_DSD_ENA;
f83adb61 3176
15b7a68c 3177 cur_dsd = &crc_ctx_pkt->u.bundling.dif_dsd;
f83adb61 3178 if (qla24xx_walk_and_build_prot_sglist(ha, NULL, cur_dsd,
50b81275 3179 prm->prot_seg_cnt, cmd))
f83adb61
QT		 3180 goto crc_queuing_error;
3181 }
3182 return QLA_SUCCESS;
3183
3184crc_queuing_error:
3185 /* Cleanup will be performed by the caller */
82de802a 3186 qpair->req->outstanding_cmds[h] = NULL;
f83adb61
QT		 3187
3188 return QLA_FUNCTION_FAILED;
3189}
3190
2d70c103
NB		 3191/*
3192 * Callback to setup response of xmit_type of QLA_TGT_XMIT_DATA and *
3193 * QLA_TGT_XMIT_STATUS for >= 24xx silicon
3194 */
3195int qlt_xmit_response(struct qla_tgt_cmd *cmd, int xmit_type,
3196 uint8_t scsi_status)
3197{
3198 struct scsi_qla_host *vha = cmd->vha;
82de802a 3199 struct qla_qpair *qpair = cmd->qpair;
2d70c103
NB		 3200 struct ctio7_to_24xx *pkt;
3201 struct qla_tgt_prm prm;
3202 uint32_t full_req_cnt = 0;
3203 unsigned long flags = 0;
3204 int res;
3205
51fd6e63
QT		 3206 if (!qpair->fw_started || (cmd->reset_count != qpair->chip_reset) ||
3207 (cmd->sess && cmd->sess->deleted)) {
a6ca8878 3208 cmd->state = QLA_TGT_STATE_PROCESSED;
a6ca8878
AP		 3209 return 0;
3210 }
a6ca8878 3211
22d84726 3212 ql_dbg_qp(ql_dbg_tgt, qpair, 0xe018,
82de802a 3213 "is_send_status=%d, cmd->bufflen=%d, cmd->sg_cnt=%d, cmd->dma_data_direction=%d se_cmd[%p] qp %d\n",
f83adb61
QT		 3214 (xmit_type & QLA_TGT_XMIT_STATUS) ?
3215 1 : 0, cmd->bufflen, cmd->sg_cnt, cmd->dma_data_direction,
82de802a 3216 &cmd->se_cmd, qpair->id);
2d70c103
NB		 3217
3218 res = qlt_pre_xmit_response(cmd, &prm, xmit_type, scsi_status,
3219 &full_req_cnt);
3220 if (unlikely(res != 0)) {
2d70c103
NB		 3221 return res;
3222 }
3223
82de802a 3224 spin_lock_irqsave(qpair->qp_lock_ptr, flags);
2d70c103 3225
ce1025cd 3226 if (xmit_type == QLA_TGT_XMIT_STATUS)
60a9eadb 3227 qpair->tgt_counters.core_qla_snd_status++;
ce1025cd 3228 else
60a9eadb 3229 qpair->tgt_counters.core_qla_que_buf++;
ce1025cd 3230
7c3f8fd1 3231 if (!qpair->fw_started || cmd->reset_count != qpair->chip_reset) {
b6a029e1 3232 /*
3bb67df5 3233 * Either the port is not online or this request was from
b6a029e1
AE		 3234 * previous life, just abort the processing.
3235 */
3236 cmd->state = QLA_TGT_STATE_PROCESSED;
22d84726 3237 ql_dbg_qp(ql_dbg_async, qpair, 0xe101,
3bb67df5
DKU		 3238 "RESET-RSP online/active/old-count/new-count = %d/%d/%d/%d.\n",
3239 vha->flags.online, qla2x00_reset_active(vha),
7c3f8fd1 3240 cmd->reset_count, qpair->chip_reset);
82de802a 3241 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
b6a029e1
AE		 3242 return 0;
3243 }
3244
2d70c103 3245 /* Does F/W have an IOCBs for this request */
82de802a 3246 res = qlt_check_reserve_free_req(qpair, full_req_cnt);
2d70c103
NB		 3247 if (unlikely(res))
3248 goto out_unmap_unlock;
3249
f83adb61 3250 if (cmd->se_cmd.prot_op && (xmit_type & QLA_TGT_XMIT_DATA))
82de802a 3251 res = qlt_build_ctio_crc2_pkt(qpair, &prm);
f83adb61 3252 else
82de802a 3253 res = qlt_24xx_build_ctio_pkt(qpair, &prm);
810e30bc 3254 if (unlikely(res != 0)) {
82de802a 3255 qpair->req->cnt += full_req_cnt;
2d70c103 3256 goto out_unmap_unlock;
810e30bc 3257 }
2d70c103
NB		 3258
3259 pkt = (struct ctio7_to_24xx *)prm.pkt;
3260
3261 if (qlt_has_data(cmd) && (xmit_type & QLA_TGT_XMIT_DATA)) {
3262 pkt->u.status0.flags |=
ad950360 3263 cpu_to_le16(CTIO7_FLAGS_DATA_IN |
2d70c103
NB		 3264 CTIO7_FLAGS_STATUS_MODE_0);
3265
f83adb61 3266 if (cmd->se_cmd.prot_op == TARGET_PROT_NORMAL)
32d29b4c 3267 qlt_load_data_segments(&prm);
2d70c103
NB		 3268
3269 if (prm.add_status_pkt == 0) {
3270 if (xmit_type & QLA_TGT_XMIT_STATUS) {
3271 pkt->u.status0.scsi_status =
3272 cpu_to_le16(prm.rq_result);
3273 pkt->u.status0.residual =
3274 cpu_to_le32(prm.residual);
ad950360 3275 pkt->u.status0.flags |= cpu_to_le16(
2d70c103 3276 CTIO7_FLAGS_SEND_STATUS);
7c3f8fd1 3277 if (qlt_need_explicit_conf(cmd, 0)) {
2d70c103 3278 pkt->u.status0.flags |=
ad950360 3279 cpu_to_le16(
2d70c103
NB		 3280 CTIO7_FLAGS_EXPLICIT_CONFORM |
3281 CTIO7_FLAGS_CONFORM_REQ);
3282 }
3283 }
3284
3285 } else {
3286 /*
3287 * We have already made sure that there is sufficient
3288 * amount of request entries to not drop HW lock in
3289 * req_pkt().
3290 */
3291 struct ctio7_to_24xx *ctio =
82de802a
QT		 3292 (struct ctio7_to_24xx *)qlt_get_req_pkt(
3293 qpair->req);
2d70c103 3294
22d84726 3295 ql_dbg_qp(ql_dbg_tgt, qpair, 0x305e,
667024a3
AE		 3296 "Building additional status packet 0x%p.\n",
3297 ctio);
2d70c103 3298
f83adb61
QT		 3299 /*
3300 * T10Dif: ctio_crc2_to_fw overlay ontop of
3301 * ctio7_to_24xx
3302 */
2d70c103 3303 memcpy(ctio, pkt, sizeof(*ctio));
f83adb61 3304 /* reset back to CTIO7 */
2d70c103 3305 ctio->entry_count = 1;
f83adb61 3306 ctio->entry_type = CTIO_TYPE7;
2d70c103 3307 ctio->dseg_count = 0;
ad950360 3308 ctio->u.status1.flags &= ~cpu_to_le16(
2d70c103
NB		 3309 CTIO7_FLAGS_DATA_IN);
3310
3311 /* Real finish is ctio_m1's finish */
3312 pkt->handle |= CTIO_INTERMEDIATE_HANDLE_MARK;
ad950360 3313 pkt->u.status0.flags |= cpu_to_le16(
2d70c103 3314 CTIO7_FLAGS_DONT_RET_CTIO);
f83adb61
QT		 3315
3316 /* qlt_24xx_init_ctio_to_isp will correct
3317 * all neccessary fields that's part of CTIO7.
3318 * There should be no residual of CTIO-CRC2 data.
3319 */
2d70c103
NB		 3320 qlt_24xx_init_ctio_to_isp((struct ctio7_to_24xx *)ctio,
3321 &prm);
2d70c103
NB		 3322 }
3323 } else
3324 qlt_24xx_init_ctio_to_isp(pkt, &prm);
3325
3326
3327 cmd->state = QLA_TGT_STATE_PROCESSED; /* Mid-level is done processing */
d564a372 3328 cmd->cmd_sent_to_fw = 1;
079a3a3b 3329 cmd->ctio_flags = le16_to_cpu(pkt->u.status0.flags);
2d70c103 3330
63163e06
HM		 3331 /* Memory Barrier */
3332 wmb();
8abfa9e2
QT		 3333 if (qpair->reqq_start_iocbs)
3334 qpair->reqq_start_iocbs(qpair);
3335 else
3336 qla2x00_start_iocbs(vha, qpair->req);
82de802a 3337 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
2d70c103
NB		 3338
3339 return 0;
3340
3341out_unmap_unlock:
f9b6721a 3342 qlt_unmap_sg(vha, cmd);
82de802a 3343 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
2d70c103
NB		 3344
3345 return res;
3346}
3347EXPORT_SYMBOL(qlt_xmit_response);
3348
3349int qlt_rdy_to_xfer(struct qla_tgt_cmd *cmd)
3350{
3351 struct ctio7_to_24xx *pkt;
3352 struct scsi_qla_host *vha = cmd->vha;
2d70c103
NB		 3353 struct qla_tgt *tgt = cmd->tgt;
3354 struct qla_tgt_prm prm;
82de802a 3355 unsigned long flags = 0;
2d70c103 3356 int res = 0;
82de802a 3357 struct qla_qpair *qpair = cmd->qpair;
2d70c103
NB		 3358
3359 memset(&prm, 0, sizeof(prm));
3360 prm.cmd = cmd;
3361 prm.tgt = tgt;
3362 prm.sg = NULL;
3363 prm.req_cnt = 1;
3364
2d70c103
NB		 3365 /* Calculate number of entries and segments required */
3366 if (qlt_pci_map_calc_cnt(&prm) != 0)
3367 return -EAGAIN;
3368
7c3f8fd1 3369 if (!qpair->fw_started || (cmd->reset_count != qpair->chip_reset) ||
726b8548 3370 (cmd->sess && cmd->sess->deleted)) {
b6a029e1 3371 /*
3bb67df5 3372 * Either the port is not online or this request was from
b6a029e1
AE		 3373 * previous life, just abort the processing.
3374 */
aefed3e5
BVA		 3375 cmd->aborted = 1;
3376 cmd->write_data_transferred = 0;
3377 cmd->state = QLA_TGT_STATE_DATA_IN;
3378 vha->hw->tgt.tgt_ops->handle_data(cmd);
22d84726 3379 ql_dbg_qp(ql_dbg_async, qpair, 0xe102,
3bb67df5
DKU		 3380 "RESET-XFR online/active/old-count/new-count = %d/%d/%d/%d.\n",
3381 vha->flags.online, qla2x00_reset_active(vha),
7c3f8fd1 3382 cmd->reset_count, qpair->chip_reset);
b6a029e1
AE		 3383 return 0;
3384 }
3385
82de802a 3386 spin_lock_irqsave(qpair->qp_lock_ptr, flags);
2d70c103 3387 /* Does F/W have an IOCBs for this request */
82de802a 3388 res = qlt_check_reserve_free_req(qpair, prm.req_cnt);
2d70c103
NB		 3389 if (res != 0)
3390 goto out_unlock_free_unmap;
f83adb61 3391 if (cmd->se_cmd.prot_op)
82de802a 3392 res = qlt_build_ctio_crc2_pkt(qpair, &prm);
f83adb61 3393 else
82de802a 3394 res = qlt_24xx_build_ctio_pkt(qpair, &prm);
2d70c103 3395
810e30bc 3396 if (unlikely(res != 0)) {
82de802a 3397 qpair->req->cnt += prm.req_cnt;
2d70c103 3398 goto out_unlock_free_unmap;
810e30bc
QT		 3399 }
3400
2d70c103 3401 pkt = (struct ctio7_to_24xx *)prm.pkt;
ad950360 3402 pkt->u.status0.flags |= cpu_to_le16(CTIO7_FLAGS_DATA_OUT |
2d70c103 3403 CTIO7_FLAGS_STATUS_MODE_0);
f83adb61
QT		 3404
3405 if (cmd->se_cmd.prot_op == TARGET_PROT_NORMAL)
32d29b4c 3406 qlt_load_data_segments(&prm);
2d70c103
NB		 3407
3408 cmd->state = QLA_TGT_STATE_NEED_DATA;
d564a372 3409 cmd->cmd_sent_to_fw = 1;
079a3a3b 3410 cmd->ctio_flags = le16_to_cpu(pkt->u.status0.flags);
2d70c103 3411
63163e06
HM		 3412 /* Memory Barrier */
3413 wmb();
8abfa9e2
QT		 3414 if (qpair->reqq_start_iocbs)
3415 qpair->reqq_start_iocbs(qpair);
3416 else
3417 qla2x00_start_iocbs(vha, qpair->req);
82de802a 3418 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
2d70c103
NB		 3419
3420 return res;
3421
3422out_unlock_free_unmap:
f9b6721a 3423 qlt_unmap_sg(vha, cmd);
82de802a 3424 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
2d70c103
NB		 3425
3426 return res;
3427}
3428EXPORT_SYMBOL(qlt_rdy_to_xfer);
3429
f83adb61
QT		 3430
3431/*
be25152c 3432 * it is assumed either hardware_lock or qpair lock is held.
f83adb61 3433 */
be25152c 3434static void
8abfa9e2 3435qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
be25152c 3436 struct ctio_crc_from_fw *sts)
f83adb61
QT		 3437{
3438 uint8_t *ap = &sts->actual_dif[0];
3439 uint8_t *ep = &sts->expected_dif[0];
f83adb61 3440 uint64_t lba = cmd->se_cmd.t_task_lba;
be25152c
QT		 3441 uint8_t scsi_status, sense_key, asc, ascq;
3442 unsigned long flags;
8abfa9e2 3443 struct scsi_qla_host *vha = cmd->vha;
f83adb61 3444
be25152c 3445 cmd->trc_flags |= TRC_DIF_ERR;
f83adb61 3446
be25152c
QT		 3447 cmd->a_guard = be16_to_cpu(*(uint16_t *)(ap + 0));
3448 cmd->a_app_tag = be16_to_cpu(*(uint16_t *)(ap + 2));
3449 cmd->a_ref_tag = be32_to_cpu(*(uint32_t *)(ap + 4));
f83adb61 3450
be25152c
QT		 3451 cmd->e_guard = be16_to_cpu(*(uint16_t *)(ep + 0));
3452 cmd->e_app_tag = be16_to_cpu(*(uint16_t *)(ep + 2));
3453 cmd->e_ref_tag = be32_to_cpu(*(uint32_t *)(ep + 4));
f83adb61 3454
be25152c
QT		 3455 ql_dbg(ql_dbg_tgt_dif, vha, 0xf075,
3456 "%s: aborted %d state %d\n", __func__, cmd->aborted, cmd->state);
f83adb61 3457
be25152c 3458 scsi_status = sense_key = asc = ascq = 0;
f83adb61 3459
be25152c
QT		 3460 /* check appl tag */
3461 if (cmd->e_app_tag != cmd->a_app_tag) {
83548fe2
QT		 3462 ql_dbg(ql_dbg_tgt_dif, vha, 0xe00d,
3463 "App Tag ERR: cdb[%x] lba[%llx %llx] blks[%x] [Actual|Expected] Ref[%x|%x], App[%x|%x], Guard [%x|%x] cmd=%p ox_id[%04x]",
3464 cmd->cdb[0], lba, (lba+cmd->num_blks), cmd->num_blks,
3465 cmd->a_ref_tag, cmd->e_ref_tag, cmd->a_app_tag,
3466 cmd->e_app_tag, cmd->a_guard, cmd->e_guard, cmd,
3467 cmd->atio.u.isp24.fcp_hdr.ox_id);
be25152c
QT		 3468
3469 cmd->dif_err_code = DIF_ERR_APP;
3470 scsi_status = SAM_STAT_CHECK_CONDITION;
3471 sense_key = ABORTED_COMMAND;
3472 asc = 0x10;
3473 ascq = 0x2;
f83adb61
QT		 3474 }
3475
3476 /* check ref tag */
be25152c 3477 if (cmd->e_ref_tag != cmd->a_ref_tag) {
83548fe2
QT		 3478 ql_dbg(ql_dbg_tgt_dif, vha, 0xe00e,
3479 "Ref Tag ERR: cdb[%x] lba[%llx %llx] blks[%x] [Actual|Expected] Ref[%x|%x], App[%x|%x], Guard[%x|%x] cmd=%p ox_id[%04x] ",
3480 cmd->cdb[0], lba, (lba+cmd->num_blks), cmd->num_blks,
3481 cmd->a_ref_tag, cmd->e_ref_tag, cmd->a_app_tag,
3482 cmd->e_app_tag, cmd->a_guard, cmd->e_guard, cmd,
3483 cmd->atio.u.isp24.fcp_hdr.ox_id);
be25152c
QT		 3484
3485 cmd->dif_err_code = DIF_ERR_REF;
3486 scsi_status = SAM_STAT_CHECK_CONDITION;
3487 sense_key = ABORTED_COMMAND;
3488 asc = 0x10;
3489 ascq = 0x3;
f83adb61
QT		 3490 goto out;
3491 }
3492
be25152c
QT		 3493 /* check guard */
3494 if (cmd->e_guard != cmd->a_guard) {
83548fe2
QT		 3495 ql_dbg(ql_dbg_tgt_dif, vha, 0xe012,
3496 "Guard ERR: cdb[%x] lba[%llx %llx] blks[%x] [Actual|Expected] Ref[%x|%x], App[%x|%x], Guard [%x|%x] cmd=%p ox_id[%04x]",
3497 cmd->cdb[0], lba, (lba+cmd->num_blks), cmd->num_blks,
3498 cmd->a_ref_tag, cmd->e_ref_tag, cmd->a_app_tag,
3499 cmd->e_app_tag, cmd->a_guard, cmd->e_guard, cmd,
3500 cmd->atio.u.isp24.fcp_hdr.ox_id);
3501
be25152c
QT		 3502 cmd->dif_err_code = DIF_ERR_GRD;
3503 scsi_status = SAM_STAT_CHECK_CONDITION;
3504 sense_key = ABORTED_COMMAND;
3505 asc = 0x10;
3506 ascq = 0x1;
f83adb61
QT		 3507 }
3508out:
be25152c
QT		 3509 switch (cmd->state) {
3510 case QLA_TGT_STATE_NEED_DATA:
3511 /* handle_data will load DIF error code */
3512 cmd->state = QLA_TGT_STATE_DATA_IN;
3513 vha->hw->tgt.tgt_ops->handle_data(cmd);
3514 break;
3515 default:
3516 spin_lock_irqsave(&cmd->cmd_lock, flags);
3517 if (cmd->aborted) {
3518 spin_unlock_irqrestore(&cmd->cmd_lock, flags);
3519 vha->hw->tgt.tgt_ops->free_cmd(cmd);
3520 break;
3521 }
3522 spin_unlock_irqrestore(&cmd->cmd_lock, flags);
f83adb61 3523
8abfa9e2
QT		 3524 qlt_send_resp_ctio(qpair, cmd, scsi_status, sense_key, asc,
3525 ascq);
be25152c
QT		 3526 /* assume scsi status gets out on the wire.
3527 * Will not wait for completion.
3528 */
3529 vha->hw->tgt.tgt_ops->free_cmd(cmd);
3530 break;
3531 }
3532}
f83adb61 3533
a6ca8878
AP		 3534/* If hardware_lock held on entry, might drop it, then reaquire */
3535/* This function sends the appropriate CTIO to ISP 2xxx or 24xx */
3536static int __qlt_send_term_imm_notif(struct scsi_qla_host *vha,
3537 struct imm_ntfy_from_isp *ntfy)
3538{
3539 struct nack_to_isp *nack;
3540 struct qla_hw_data *ha = vha->hw;
3541 request_t *pkt;
3542 int ret = 0;
3543
3544 ql_dbg(ql_dbg_tgt_tmr, vha, 0xe01c,
3545 "Sending TERM ELS CTIO (ha=%p)\n", ha);
3546
ec7193e2 3547 pkt = (request_t *)qla2x00_alloc_iocbs(vha, NULL);
a6ca8878
AP		 3548 if (pkt == NULL) {
3549 ql_dbg(ql_dbg_tgt, vha, 0xe080,
3550 "qla_target(%d): %s failed: unable to allocate "
3551 "request packet\n", vha->vp_idx, __func__);
3552 return -ENOMEM;
3553 }
3554
3555 pkt->entry_type = NOTIFY_ACK_TYPE;
3556 pkt->entry_count = 1;
4f060736 3557 pkt->handle = QLA_TGT_SKIP_HANDLE;
a6ca8878
AP		 3558
3559 nack = (struct nack_to_isp *)pkt;
3560 nack->ox_id = ntfy->ox_id;
3561
3562 nack->u.isp24.nport_handle = ntfy->u.isp24.nport_handle;
3563 if (le16_to_cpu(ntfy->u.isp24.status) == IMM_NTFY_ELS) {
3564 nack->u.isp24.flags = ntfy->u.isp24.flags &
3565 __constant_cpu_to_le32(NOTIFY24XX_FLAGS_PUREX_IOCB);
3566 }
3567
3568 /* terminate */
3569 nack->u.isp24.flags |=
3570 __constant_cpu_to_le16(NOTIFY_ACK_FLAGS_TERMINATE);
3571
3572 nack->u.isp24.srr_rx_id = ntfy->u.isp24.srr_rx_id;
3573 nack->u.isp24.status = ntfy->u.isp24.status;
3574 nack->u.isp24.status_subcode = ntfy->u.isp24.status_subcode;
3575 nack->u.isp24.fw_handle = ntfy->u.isp24.fw_handle;
3576 nack->u.isp24.exchange_address = ntfy->u.isp24.exchange_address;
3577 nack->u.isp24.srr_rel_offs = ntfy->u.isp24.srr_rel_offs;
3578 nack->u.isp24.srr_ui = ntfy->u.isp24.srr_ui;
3579 nack->u.isp24.vp_index = ntfy->u.isp24.vp_index;
3580
3581 qla2x00_start_iocbs(vha, vha->req);
3582 return ret;
3583}
3584
3585static void qlt_send_term_imm_notif(struct scsi_qla_host *vha,
3586 struct imm_ntfy_from_isp *imm, int ha_locked)
3587{
a6ca8878
AP		 3588 int rc;
3589
e65449aa 3590 WARN_ON_ONCE(!ha_locked);
a6ca8878 3591 rc = __qlt_send_term_imm_notif(vha, imm);
e65449aa 3592 pr_debug("rc = %d\n", rc);
a6ca8878
AP		 3593}
3594
83548fe2
QT		 3595/*
3596 * If hardware_lock held on entry, might drop it, then reaquire
3597 * This function sends the appropriate CTIO to ISP 2xxx or 24xx
3598 */
82de802a 3599static int __qlt_send_term_exchange(struct qla_qpair *qpair,
2d70c103
NB		 3600 struct qla_tgt_cmd *cmd,
3601 struct atio_from_isp *atio)
3602{
82de802a 3603 struct scsi_qla_host *vha = qpair->vha;
2d70c103
NB		 3604 struct ctio7_to_24xx *ctio24;
3605 struct qla_hw_data *ha = vha->hw;
3606 request_t *pkt;
3607 int ret = 0;
33a5fcee 3608 uint16_t temp;
2d70c103 3609
83548fe2 3610 ql_dbg(ql_dbg_tgt, vha, 0xe009, "Sending TERM EXCH CTIO (ha=%p)\n", ha);
2d70c103 3611
72fcd4eb
QT		 3612 if (cmd)
3613 vha = cmd->vha;
3614
82de802a 3615 pkt = (request_t *)qla2x00_alloc_iocbs_ready(qpair, NULL);
2d70c103
NB		 3616 if (pkt == NULL) {
3617 ql_dbg(ql_dbg_tgt, vha, 0xe050,
3618 "qla_target(%d): %s failed: unable to allocate "
3619 "request packet\n", vha->vp_idx, __func__);
3620 return -ENOMEM;
3621 }
3622
3623 if (cmd != NULL) {
3624 if (cmd->state < QLA_TGT_STATE_PROCESSED) {
3625 ql_dbg(ql_dbg_tgt, vha, 0xe051,
3626 "qla_target(%d): Terminating cmd %p with "
3627 "incorrect state %d\n", vha->vp_idx, cmd,
3628 cmd->state);
3629 } else
3630 ret = 1;
3631 }
3632
60a9eadb 3633 qpair->tgt_counters.num_term_xchg_sent++;
2d70c103
NB		 3634 pkt->entry_count = 1;
3635 pkt->handle = QLA_TGT_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK;
3636
3637 ctio24 = (struct ctio7_to_24xx *)pkt;
3638 ctio24->entry_type = CTIO_TYPE7;
71cdc079 3639 ctio24->nport_handle = CTIO7_NHANDLE_UNRECOGNIZED;
ad950360 3640 ctio24->timeout = cpu_to_le16(QLA_TGT_TIMEOUT);
2d70c103 3641 ctio24->vp_index = vha->vp_idx;
df95f39a 3642 ctio24->initiator_id = be_id_to_le(atio->u.isp24.fcp_hdr.s_id);
2d70c103 3643 ctio24->exchange_addr = atio->u.isp24.exchange_addr;
f7e761f5
QT		 3644 temp = (atio->u.isp24.attr << 9) | CTIO7_FLAGS_STATUS_MODE_1 |
3645 CTIO7_FLAGS_TERMINATE;
3646 ctio24->u.status1.flags = cpu_to_le16(temp);
33a5fcee
QT		 3647 temp = be16_to_cpu(atio->u.isp24.fcp_hdr.ox_id);
3648 ctio24->u.status1.ox_id = cpu_to_le16(temp);
2d70c103 3649
63163e06
HM		 3650 /* Memory Barrier */
3651 wmb();
8abfa9e2
QT		 3652 if (qpair->reqq_start_iocbs)
3653 qpair->reqq_start_iocbs(qpair);
3654 else
3655 qla2x00_start_iocbs(vha, qpair->req);
2d70c103
NB		 3656 return ret;
3657}
3658
82de802a 3659static void qlt_send_term_exchange(struct qla_qpair *qpair,
a07100e0
QT		 3660 struct qla_tgt_cmd *cmd, struct atio_from_isp *atio, int ha_locked,
3661 int ul_abort)
2d70c103 3662{
82de802a 3663 struct scsi_qla_host *vha;
6bc85dd5 3664 unsigned long flags = 0;
2d70c103
NB		 3665 int rc;
3666
82de802a
QT		 3667 /* why use different vha? NPIV */
3668 if (cmd)
3669 vha = cmd->vha;
3670 else
3671 vha = qpair->vha;
2d70c103
NB		 3672
3673 if (ha_locked) {
82de802a 3674 rc = __qlt_send_term_exchange(qpair, cmd, atio);
33e79977
QT		 3675 if (rc == -ENOMEM)
3676 qlt_alloc_qfull_cmd(vha, atio, 0, 0);
2d70c103
NB		 3677 goto done;
3678 }
82de802a
QT		 3679 spin_lock_irqsave(qpair->qp_lock_ptr, flags);
3680 rc = __qlt_send_term_exchange(qpair, cmd, atio);
33e79977
QT		 3681 if (rc == -ENOMEM)
3682 qlt_alloc_qfull_cmd(vha, atio, 0, 0);
d564a372 3683
2d70c103 3684done:
a07100e0 3685 if (cmd && !ul_abort && !cmd->aborted) {
6bc85dd5
HM		 3686 if (cmd->sg_mapped)
3687 qlt_unmap_sg(vha, cmd);
2d70c103
NB		 3688 vha->hw->tgt.tgt_ops->free_cmd(cmd);
3689 }
6bc85dd5
HM		 3690
3691 if (!ha_locked)
82de802a 3692 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
6bc85dd5 3693
7b898542 3694 return;
2d70c103
NB		 3695}
3696
33e79977
QT		 3697static void qlt_init_term_exchange(struct scsi_qla_host *vha)
3698{
3699 struct list_head free_list;
3700 struct qla_tgt_cmd *cmd, *tcmd;
3701
3702 vha->hw->tgt.leak_exchg_thresh_hold =
03e8c680 3703 (vha->hw->cur_fw_xcb_count/100) * LEAK_EXCHG_THRESH_HOLD_PERCENT;
33e79977
QT		 3704
3705 cmd = tcmd = NULL;
3706 if (!list_empty(&vha->hw->tgt.q_full_list)) {
3707 INIT_LIST_HEAD(&free_list);
3708 list_splice_init(&vha->hw->tgt.q_full_list, &free_list);
3709
3710 list_for_each_entry_safe(cmd, tcmd, &free_list, cmd_list) {
3711 list_del(&cmd->cmd_list);
3712 /* This cmd was never sent to TCM. There is no need
3713 * to schedule free or call free_cmd
3714 */
3715 qlt_free_cmd(cmd);
3716 vha->hw->tgt.num_qfull_cmds_alloc--;
3717 }
3718 }
3719 vha->hw->tgt.num_qfull_cmds_dropped = 0;
3720}
3721
3722static void qlt_chk_exch_leak_thresh_hold(struct scsi_qla_host *vha)
3723{
3724 uint32_t total_leaked;
3725
3726 total_leaked = vha->hw->tgt.num_qfull_cmds_dropped;
3727
3728 if (vha->hw->tgt.leak_exchg_thresh_hold &&
3729 (total_leaked > vha->hw->tgt.leak_exchg_thresh_hold)) {
3730
3731 ql_dbg(ql_dbg_tgt, vha, 0xe079,
3732 "Chip reset due to exchange starvation: %d/%d.\n",
03e8c680 3733 total_leaked, vha->hw->cur_fw_xcb_count);
33e79977
QT		 3734
3735 if (IS_P3P_TYPE(vha->hw))
3736 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
3737 else
3738 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3739 qla2xxx_wake_dpc(vha);
3740 }
3741
3742}
3743
a07100e0 3744int qlt_abort_cmd(struct qla_tgt_cmd *cmd)
7359df25
AP		 3745{
3746 struct qla_tgt *tgt = cmd->tgt;
3747 struct scsi_qla_host *vha = tgt->vha;
3748 struct se_cmd *se_cmd = &cmd->se_cmd;
a07100e0 3749 unsigned long flags;
7359df25
AP		 3750
3751 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf014,
3752 "qla_target(%d): terminating exchange for aborted cmd=%p "
3753 "(se_cmd=%p, tag=%llu)", vha->vp_idx, cmd, &cmd->se_cmd,
3754 se_cmd->tag);
3755
a07100e0
QT		 3756 spin_lock_irqsave(&cmd->cmd_lock, flags);
3757 if (cmd->aborted) {
3758 spin_unlock_irqrestore(&cmd->cmd_lock, flags);
3759 /*
3760 * It's normal to see 2 calls in this path:
3761 * 1) XFER Rdy completion + CMD_T_ABORT
3762 * 2) TCM TMR - drain_state_list
3763 */
83548fe2
QT		 3764 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf016,
3765 "multiple abort. %p transport_state %x, t_state %x, "
3766 "se_cmd_flags %x\n", cmd, cmd->se_cmd.transport_state,
3767 cmd->se_cmd.t_state, cmd->se_cmd.se_cmd_flags);
a07100e0
QT		 3768 return EIO;
3769 }
193b50b9 3770 cmd->aborted = 1;
1eb42f96 3771 cmd->trc_flags |= TRC_ABORT;
a07100e0 3772 spin_unlock_irqrestore(&cmd->cmd_lock, flags);
7359df25 3773
82de802a 3774 qlt_send_term_exchange(cmd->qpair, cmd, &cmd->atio, 0, 1);
a07100e0 3775 return 0;
7359df25
AP		 3776}
3777EXPORT_SYMBOL(qlt_abort_cmd);
3778
2d70c103
NB		 3779void qlt_free_cmd(struct qla_tgt_cmd *cmd)
3780{
5d964837 3781 struct fc_port *sess = cmd->sess;
51a07f84 3782
f83adb61
QT		 3783 ql_dbg(ql_dbg_tgt, cmd->vha, 0xe074,
3784 "%s: se_cmd[%p] ox_id %04x\n",
3785 __func__, &cmd->se_cmd,
3786 be16_to_cpu(cmd->atio.u.isp24.fcp_hdr.ox_id));
2d70c103 3787
e07f8f65
SK		 3788 BUG_ON(cmd->cmd_in_wq);
3789
a07100e0
QT		 3790 if (cmd->sg_mapped)
3791 qlt_unmap_sg(cmd->vha, cmd);
3792
33e79977
QT		 3793 if (!cmd->q_full)
3794 qlt_decr_num_pend_cmds(cmd->vha);
3795
f83adb61 3796 BUG_ON(cmd->sg_mapped);
e07f8f65 3797 cmd->jiffies_at_free = get_jiffies_64();
2d70c103
NB		 3798 if (unlikely(cmd->free_sg))
3799 kfree(cmd->sg);
51a07f84
NB		 3800
3801 if (!sess || !sess->se_sess) {
3802 WARN_ON(1);
3803 return;
3804 }
e07f8f65 3805 cmd->jiffies_at_free = get_jiffies_64();
83c2b54b 3806 target_free_tag(sess->se_sess, &cmd->se_cmd);
2d70c103
NB		 3807}
3808EXPORT_SYMBOL(qlt_free_cmd);
3809
2d70c103
NB		 3810/*
3811 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
3812 */
82de802a 3813static int qlt_term_ctio_exchange(struct qla_qpair *qpair, void *ctio,
2d70c103
NB		 3814 struct qla_tgt_cmd *cmd, uint32_t status)
3815{
3816 int term = 0;
82de802a 3817 struct scsi_qla_host *vha = qpair->vha;
2d70c103 3818
be25152c 3819 if (cmd->se_cmd.prot_op)
83548fe2 3820 ql_dbg(ql_dbg_tgt_dif, vha, 0xe013,
be25152c
QT		 3821 "Term DIF cmd: lba[0x%llx|%lld] len[0x%x] "
3822 "se_cmd=%p tag[%x] op %#x/%s",
3823 cmd->lba, cmd->lba,
3824 cmd->num_blks, &cmd->se_cmd,
3825 cmd->atio.u.isp24.exchange_addr,
3826 cmd->se_cmd.prot_op,
3827 prot_op_str(cmd->se_cmd.prot_op));
3828
2d70c103
NB		 3829 if (ctio != NULL) {
3830 struct ctio7_from_24xx *c = (struct ctio7_from_24xx *)ctio;
bd432bb5 3831
2d70c103 3832 term = !(c->flags &
ad950360 3833 cpu_to_le16(OF_TERM_EXCH));
2d70c103
NB		 3834 } else
3835 term = 1;
3836
3837 if (term)
3efc31f7 3838 qlt_send_term_exchange(qpair, cmd, &cmd->atio, 1, 0);
2d70c103
NB		 3839
3840 return term;
3841}
3842
2d70c103
NB		 3843
3844/* ha->hardware_lock supposed to be held on entry */
6b0431d6 3845static void *qlt_ctio_to_cmd(struct scsi_qla_host *vha,
82de802a 3846 struct rsp_que *rsp, uint32_t handle, void *ctio)
2d70c103 3847{
6b0431d6 3848 void *cmd = NULL;
82de802a
QT		 3849 struct req_que *req;
3850 int qid = GET_QID(handle);
3851 uint32_t h = handle & ~QLA_TGT_HANDLE_MASK;
2d70c103 3852
82de802a
QT		 3853 if (unlikely(h == QLA_TGT_SKIP_HANDLE))
3854 return NULL;
2d70c103 3855
82de802a
QT		 3856 if (qid == rsp->req->id) {
3857 req = rsp->req;
3858 } else if (vha->hw->req_q_map[qid]) {
3859 ql_dbg(ql_dbg_tgt_mgt, vha, 0x1000a,
3860 "qla_target(%d): CTIO completion with different QID %d handle %x\n",
3861 vha->vp_idx, rsp->id, handle);
3862 req = vha->hw->req_q_map[qid];
3863 } else {
3864 return NULL;
3865 }
667024a3 3866
82de802a 3867 h &= QLA_CMD_HANDLE_MASK;
c5419e26 3868
82de802a 3869 if (h != QLA_TGT_NULL_HANDLE) {
fb2028a0 3870 if (unlikely(h >= req->num_outstanding_cmds)) {
2d70c103
NB		 3871 ql_dbg(ql_dbg_tgt, vha, 0xe052,
3872 "qla_target(%d): Wrong handle %x received\n",
3873 vha->vp_idx, handle);
3874 return NULL;
3875 }
82de802a 3876
6b0431d6 3877 cmd = (void *) req->outstanding_cmds[h];
82de802a 3878 if (unlikely(cmd == NULL)) {
c5419e26 3879 ql_dbg(ql_dbg_async, vha, 0xe053,
82de802a
QT		 3880 "qla_target(%d): Suspicious: unable to find the command with handle %x req->id %d rsp->id %d\n",
3881 vha->vp_idx, handle, req->id, rsp->id);
2d70c103
NB		 3882 return NULL;
3883 }
82de802a 3884 req->outstanding_cmds[h] = NULL;
2d70c103
NB		 3885 } else if (ctio != NULL) {
3886 /* We can't get loop ID from CTIO7 */
3887 ql_dbg(ql_dbg_tgt, vha, 0xe054,
3888 "qla_target(%d): Wrong CTIO received: QLA24xx doesn't "
3889 "support NULL handles\n", vha->vp_idx);
3890 return NULL;
3891 }
3892
3893 return cmd;
3894}
3895
3896/*
3897 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
3898 */
82de802a
QT		 3899static void qlt_do_ctio_completion(struct scsi_qla_host *vha,
3900 struct rsp_que *rsp, uint32_t handle, uint32_t status, void *ctio)
2d70c103
NB		 3901{
3902 struct qla_hw_data *ha = vha->hw;
3903 struct se_cmd *se_cmd;
2d70c103 3904 struct qla_tgt_cmd *cmd;
82de802a 3905 struct qla_qpair *qpair = rsp->qpair;
2d70c103 3906
2d70c103
NB		 3907 if (handle & CTIO_INTERMEDIATE_HANDLE_MARK) {
3908 /* That could happen only in case of an error/reset/abort */
3909 if (status != CTIO_SUCCESS) {
3910 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf01d,
3911 "Intermediate CTIO received"
3912 " (status %x)\n", status);
3913 }
3914 return;
3915 }
3916
81bcf1c5 3917 cmd = qlt_ctio_to_cmd(vha, rsp, handle, ctio);
092e1dc3 3918 if (cmd == NULL)
2d70c103 3919 return;
092e1dc3 3920
2d70c103 3921 se_cmd = &cmd->se_cmd;
d564a372 3922 cmd->cmd_sent_to_fw = 0;
2d70c103 3923
f9b6721a 3924 qlt_unmap_sg(vha, cmd);
2d70c103
NB		 3925
3926 if (unlikely(status != CTIO_SUCCESS)) {
3927 switch (status & 0xFFFF) {
079a3a3b
QT		 3928 case CTIO_INVALID_RX_ID:
3929 if (printk_ratelimit())
3930 dev_info(&vha->hw->pdev->dev,
3931 "qla_target(%d): CTIO with INVALID_RX_ID ATIO attr %x CTIO Flags %x|%x\n",
3932 vha->vp_idx, cmd->atio.u.isp24.attr,
3933 ((cmd->ctio_flags >> 9) & 0xf),
3934 cmd->ctio_flags);
3935
3936 break;
2d70c103
NB		 3937 case CTIO_LIP_RESET:
3938 case CTIO_TARGET_RESET:
3939 case CTIO_ABORTED:
7b898542 3940 /* driver request abort via Terminate exchange */
2d70c103 3941 case CTIO_TIMEOUT:
2d70c103
NB		 3942 /* They are OK */
3943 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf058,
3944 "qla_target(%d): CTIO with "
3945 "status %#x received, state %x, se_cmd %p, "
3946 "(LIP_RESET=e, ABORTED=2, TARGET_RESET=17, "
3947 "TIMEOUT=b, INVALID_RX_ID=8)\n", vha->vp_idx,
3948 status, cmd->state, se_cmd);
3949 break;
3950
3951 case CTIO_PORT_LOGGED_OUT:
3952 case CTIO_PORT_UNAVAILABLE:
71cdc079 3953 {
dacb5822
HM		 3954 int logged_out =
3955 (status & 0xFFFF) == CTIO_PORT_LOGGED_OUT;
3956
2d70c103 3957 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf059,
71cdc079 3958 "qla_target(%d): CTIO with %s status %x "
2d70c103 3959 "received (state %x, se_cmd %p)\n", vha->vp_idx,
dacb5822 3960 logged_out ? "PORT LOGGED OUT" : "PORT UNAVAILABLE",
2d70c103 3961 status, cmd->state, se_cmd);
2d70c103 3962
71cdc079
AP		 3963 if (logged_out && cmd->sess) {
3964 /*
3965 * Session is already logged out, but we need
3966 * to notify initiator, who's not aware of this
3967 */
71cdc079 3968 cmd->sess->send_els_logo = 1;
83548fe2 3969 ql_dbg(ql_dbg_disc, vha, 0x20f8,
726b8548
QT		 3970 "%s %d %8phC post del sess\n",
3971 __func__, __LINE__, cmd->sess->port_name);
3972
d8630bb9 3973 qlt_schedule_sess_for_deletion(cmd->sess);
71cdc079
AP		 3974 }
3975 break;
3976 }
f83adb61
QT		 3977 case CTIO_DIF_ERROR: {
3978 struct ctio_crc_from_fw *crc =
3979 (struct ctio_crc_from_fw *)ctio;
3980 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf073,
be25152c
QT		 3981 "qla_target(%d): CTIO with DIF_ERROR status %x "
3982 "received (state %x, ulp_cmd %p) actual_dif[0x%llx] "
3983 "expect_dif[0x%llx]\n",
f83adb61
QT		 3984 vha->vp_idx, status, cmd->state, se_cmd,
3985 *((u64 *)&crc->actual_dif[0]),
3986 *((u64 *)&crc->expected_dif[0]));
3987
8abfa9e2 3988 qlt_handle_dif_error(qpair, cmd, ctio);
be25152c 3989 return;
f83adb61 3990 }
2d70c103
NB		 3991 default:
3992 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf05b,
f83adb61 3993 "qla_target(%d): CTIO with error status 0x%x received (state %x, se_cmd %p\n",
2d70c103
NB		 3994 vha->vp_idx, status, cmd->state, se_cmd);
3995 break;
3996 }
3997
7b898542 3998
193b50b9 3999 /* "cmd->aborted" means
7b898542
QT		 4000 * cmd is already aborted/terminated, we don't
4001 * need to terminate again. The exchange is already
4002 * cleaned up/freed at FW level. Just cleanup at driver
4003 * level.
4004 */
4005 if ((cmd->state != QLA_TGT_STATE_NEED_DATA) &&
193b50b9 4006 (!cmd->aborted)) {
1eb42f96 4007 cmd->trc_flags |= TRC_CTIO_ERR;
82de802a 4008 if (qlt_term_ctio_exchange(qpair, ctio, cmd, status))
2d70c103 4009 return;
7b898542 4010 }
2d70c103
NB		 4011 }
4012
4013 if (cmd->state == QLA_TGT_STATE_PROCESSED) {
1eb42f96 4014 cmd->trc_flags |= TRC_CTIO_DONE;
2d70c103 4015 } else if (cmd->state == QLA_TGT_STATE_NEED_DATA) {
2d70c103
NB		 4016 cmd->state = QLA_TGT_STATE_DATA_IN;
4017
52c82823 4018 if (status == CTIO_SUCCESS)
2d70c103
NB		 4019 cmd->write_data_transferred = 1;
4020
2d70c103
NB		 4021 ha->tgt.tgt_ops->handle_data(cmd);
4022 return;
193b50b9 4023 } else if (cmd->aborted) {
1eb42f96 4024 cmd->trc_flags |= TRC_CTIO_ABORTED;
2d70c103 4025 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf01e,
649ee054 4026 "Aborted command %p (tag %lld) finished\n", cmd, se_cmd->tag);
2d70c103 4027 } else {
1eb42f96 4028 cmd->trc_flags |= TRC_CTIO_STRANGE;
2d70c103
NB		 4029 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf05c,
4030 "qla_target(%d): A command in state (%d) should "
4031 "not return a CTIO complete\n", vha->vp_idx, cmd->state);
4032 }
4033
7b898542 4034 if (unlikely(status != CTIO_SUCCESS) &&
193b50b9 4035 !cmd->aborted) {
2d70c103
NB		 4036 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf01f, "Finishing failed CTIO\n");
4037 dump_stack();
4038 }
4039
4040 ha->tgt.tgt_ops->free_cmd(cmd);
4041}
4042
2d70c103
NB		 4043static inline int qlt_get_fcp_task_attr(struct scsi_qla_host *vha,
4044 uint8_t task_codes)
4045{
4046 int fcp_task_attr;
4047
4048 switch (task_codes) {
4049 case ATIO_SIMPLE_QUEUE:
68d81f40 4050 fcp_task_attr = TCM_SIMPLE_TAG;
2d70c103
NB		 4051 break;
4052 case ATIO_HEAD_OF_QUEUE:
68d81f40 4053 fcp_task_attr = TCM_HEAD_TAG;
2d70c103
NB		 4054 break;
4055 case ATIO_ORDERED_QUEUE:
68d81f40 4056 fcp_task_attr = TCM_ORDERED_TAG;
2d70c103
NB		 4057 break;
4058 case ATIO_ACA_QUEUE:
68d81f40 4059 fcp_task_attr = TCM_ACA_TAG;
2d70c103
NB		 4060 break;
4061 case ATIO_UNTAGGED:
68d81f40 4062 fcp_task_attr = TCM_SIMPLE_TAG;
2d70c103
NB		 4063 break;
4064 default:
4065 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf05d,
4066 "qla_target: unknown task code %x, use ORDERED instead\n",
4067 task_codes);
68d81f40 4068 fcp_task_attr = TCM_ORDERED_TAG;
2d70c103
NB		 4069 break;
4070 }
4071
4072 return fcp_task_attr;
4073}
4074
2d70c103
NB		 4075/*
4076 * Process context for I/O path into tcm_qla2xxx code
4077 */
51a07f84 4078static void __qlt_do_work(struct qla_tgt_cmd *cmd)
2d70c103 4079{
2d70c103
NB		 4080 scsi_qla_host_t *vha = cmd->vha;
4081 struct qla_hw_data *ha = vha->hw;
5d964837 4082 struct fc_port *sess = cmd->sess;
2d70c103
NB		 4083 struct atio_from_isp *atio = &cmd->atio;
4084 unsigned char *cdb;
4085 unsigned long flags;
4086 uint32_t data_length;
4087 int ret, fcp_task_attr, data_dir, bidi = 0;
82de802a 4088 struct qla_qpair *qpair = cmd->qpair;
2d70c103 4089
e07f8f65 4090 cmd->cmd_in_wq = 0;
1eb42f96 4091 cmd->trc_flags |= TRC_DO_WORK;
2d70c103 4092
193b50b9 4093 if (cmd->aborted) {
8b2f5ff3
SN		 4094 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf082,
4095 "cmd with tag %u is aborted\n",
4096 cmd->atio.u.isp24.exchange_addr);
4097 goto out_term;
4098 }
4099
a07100e0 4100 spin_lock_init(&cmd->cmd_lock);
2d70c103 4101 cdb = &atio->u.isp24.fcp_cmnd.cdb[0];
649ee054 4102 cmd->se_cmd.tag = atio->u.isp24.exchange_addr;
2d70c103
NB		 4103
4104 if (atio->u.isp24.fcp_cmnd.rddata &&
4105 atio->u.isp24.fcp_cmnd.wrdata) {
4106 bidi = 1;
4107 data_dir = DMA_TO_DEVICE;
4108 } else if (atio->u.isp24.fcp_cmnd.rddata)
4109 data_dir = DMA_FROM_DEVICE;
4110 else if (atio->u.isp24.fcp_cmnd.wrdata)
4111 data_dir = DMA_TO_DEVICE;
4112 else
4113 data_dir = DMA_NONE;
4114
4115 fcp_task_attr = qlt_get_fcp_task_attr(vha,
4116 atio->u.isp24.fcp_cmnd.task_attr);
e25f7654 4117 data_length = get_datalen_for_atio(atio);
2d70c103 4118
51a07f84
NB		 4119 ret = ha->tgt.tgt_ops->handle_cmd(vha, cmd, cdb, data_length,
4120 fcp_task_attr, data_dir, bidi);
2d70c103
NB		 4121 if (ret != 0)
4122 goto out_term;
4123 /*
67eb4a60 4124 * Drop extra session reference from qlt_handle_cmd_for_atio().
2d70c103 4125 */
5d964837 4126 ha->tgt.tgt_ops->put_sess(sess);
2d70c103
NB		 4127 return;
4128
4129out_term:
667024a3 4130 ql_dbg(ql_dbg_io, vha, 0x3060, "Terminating work cmd %p", cmd);
2d70c103 4131 /*
fae9eaf8
RD		 4132 * cmd has not sent to target yet, so pass NULL as the second
4133 * argument to qlt_send_term_exchange() and free the memory here.
2d70c103 4134 */
1eb42f96 4135 cmd->trc_flags |= TRC_DO_WORK_ERR;
82de802a
QT		 4136 spin_lock_irqsave(qpair->qp_lock_ptr, flags);
4137 qlt_send_term_exchange(qpair, NULL, &cmd->atio, 1, 0);
33e79977
QT		 4138
4139 qlt_decr_num_pend_cmds(vha);
83c2b54b 4140 target_free_tag(sess->se_sess, &cmd->se_cmd);
82de802a 4141 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
7560151b 4142
5d964837 4143 ha->tgt.tgt_ops->put_sess(sess);
51a07f84
NB		 4144}
4145
4146static void qlt_do_work(struct work_struct *work)
4147{
4148 struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
8b2f5ff3
SN		 4149 scsi_qla_host_t *vha = cmd->vha;
4150 unsigned long flags;
4151
4152 spin_lock_irqsave(&vha->cmd_list_lock, flags);
4153 list_del(&cmd->cmd_list);
4154 spin_unlock_irqrestore(&vha->cmd_list_lock, flags);
51a07f84
NB		 4155
4156 __qlt_do_work(cmd);
4157}
4158
09620eeb
QT		 4159void qlt_clr_qp_table(struct scsi_qla_host *vha)
4160{
4161 unsigned long flags;
4162 struct qla_hw_data *ha = vha->hw;
4163 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
4164 void *node;
4165 u64 key = 0;
4166
4167 ql_log(ql_log_info, vha, 0x706c,
4168 "User update Number of Active Qpairs %d\n",
4169 ha->tgt.num_act_qpairs);
4170
4171 spin_lock_irqsave(&ha->tgt.atio_lock, flags);
4172
4173 btree_for_each_safe64(&tgt->lun_qpair_map, key, node)
4174 btree_remove64(&tgt->lun_qpair_map, key);
4175
4176 ha->base_qpair->lun_cnt = 0;
4177 for (key = 0; key < ha->max_qpairs; key++)
4178 if (ha->queue_pair_map[key])
4179 ha->queue_pair_map[key]->lun_cnt = 0;
4180
4181 spin_unlock_irqrestore(&ha->tgt.atio_lock, flags);
4182}
4183
e326d22a
QT		 4184static void qlt_assign_qpair(struct scsi_qla_host *vha,
4185 struct qla_tgt_cmd *cmd)
4186{
4187 struct qla_qpair *qpair, *qp;
4188 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
4189 struct qla_qpair_hint *h;
4190
4191 if (vha->flags.qpairs_available) {
4192 h = btree_lookup64(&tgt->lun_qpair_map, cmd->unpacked_lun);
4193 if (unlikely(!h)) {
4194 /* spread lun to qpair ratio evently */
4195 int lcnt = 0, rc;
4196 struct scsi_qla_host *base_vha =
4197 pci_get_drvdata(vha->hw->pdev);
4198
4199 qpair = vha->hw->base_qpair;
4200 if (qpair->lun_cnt == 0) {
4201 qpair->lun_cnt++;
4202 h = qla_qpair_to_hint(tgt, qpair);
4203 BUG_ON(!h);
4204 rc = btree_insert64(&tgt->lun_qpair_map,
4205 cmd->unpacked_lun, h, GFP_ATOMIC);
4206 if (rc) {
4207 qpair->lun_cnt--;
4208 ql_log(ql_log_info, vha, 0xd037,
4209 "Unable to insert lun %llx into lun_qpair_map\n",
4210 cmd->unpacked_lun);
4211 }
4212 goto out;
4213 } else {
4214 lcnt = qpair->lun_cnt;
4215 }
4216
4217 h = NULL;
4218 list_for_each_entry(qp, &base_vha->qp_list,
4219 qp_list_elem) {
4220 if (qp->lun_cnt == 0) {
4221 qp->lun_cnt++;
4222 h = qla_qpair_to_hint(tgt, qp);
4223 BUG_ON(!h);
4224 rc = btree_insert64(&tgt->lun_qpair_map,
4225 cmd->unpacked_lun, h, GFP_ATOMIC);
4226 if (rc) {
4227 qp->lun_cnt--;
4228 ql_log(ql_log_info, vha, 0xd038,
4229 "Unable to insert lun %llx into lun_qpair_map\n",
4230 cmd->unpacked_lun);
4231 }
4232 qpair = qp;
4233 goto out;
4234 } else {
4235 if (qp->lun_cnt < lcnt) {
4236 lcnt = qp->lun_cnt;
4237 qpair = qp;
4238 continue;
4239 }
4240 }
4241 }
4242 BUG_ON(!qpair);
4243 qpair->lun_cnt++;
4244 h = qla_qpair_to_hint(tgt, qpair);
4245 BUG_ON(!h);
4246 rc = btree_insert64(&tgt->lun_qpair_map,
4247 cmd->unpacked_lun, h, GFP_ATOMIC);
4248 if (rc) {
4249 qpair->lun_cnt--;
4250 ql_log(ql_log_info, vha, 0xd039,
4251 "Unable to insert lun %llx into lun_qpair_map\n",
4252 cmd->unpacked_lun);
4253 }
4254 }
4255 } else {
4256 h = &tgt->qphints[0];
4257 }
4258out:
4259 cmd->qpair = h->qpair;
4260 cmd->se_cmd.cpuid = h->cpuid;
4261}
4262
51a07f84 4263static struct qla_tgt_cmd *qlt_get_tag(scsi_qla_host_t *vha,
5d964837 4264 struct fc_port *sess,
51a07f84
NB		 4265 struct atio_from_isp *atio)
4266{
4267 struct se_session *se_sess = sess->se_sess;
4268 struct qla_tgt_cmd *cmd;
10e9cbb6 4269 int tag, cpu;
51a07f84 4270
10e9cbb6 4271 tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu);
51a07f84
NB		 4272 if (tag < 0)
4273 return NULL;
4274
4275 cmd = &((struct qla_tgt_cmd *)se_sess->sess_cmd_map)[tag];
4276 memset(cmd, 0, sizeof(struct qla_tgt_cmd));
c5419e26 4277 cmd->cmd_type = TYPE_TGT_CMD;
51a07f84
NB		 4278 memcpy(&cmd->atio, atio, sizeof(*atio));
4279 cmd->state = QLA_TGT_STATE_NEW;
4280 cmd->tgt = vha->vha_tgt.qla_tgt;
33e79977 4281 qlt_incr_num_pend_cmds(vha);
51a07f84
NB		 4282 cmd->vha = vha;
4283 cmd->se_cmd.map_tag = tag;
10e9cbb6 4284 cmd->se_cmd.map_cpu = cpu;
51a07f84
NB		 4285 cmd->sess = sess;
4286 cmd->loop_id = sess->loop_id;
4287 cmd->conf_compl_supported = sess->conf_compl_supported;
4288
1eb42f96 4289 cmd->trc_flags = 0;
9fce1254
KS		 4290 cmd->jiffies_at_alloc = get_jiffies_64();
4291
e326d22a
QT		 4292 cmd->unpacked_lun = scsilun_to_int(
4293 (struct scsi_lun *)&atio->u.isp24.fcp_cmnd.lun);
4294 qlt_assign_qpair(vha, cmd);
7c3f8fd1 4295 cmd->reset_count = vha->hw->base_qpair->chip_reset;
22d84726 4296 cmd->vp_idx = vha->vp_idx;
9fce1254 4297
51a07f84
NB		 4298 return cmd;
4299}
4300
2d70c103
NB		 4301/* ha->hardware_lock supposed to be held on entry */
4302static int qlt_handle_cmd_for_atio(struct scsi_qla_host *vha,
4303 struct atio_from_isp *atio)
4304{
51a07f84 4305 struct qla_hw_data *ha = vha->hw;
0e8cd71c 4306 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
5d964837 4307 struct fc_port *sess;
2d70c103 4308 struct qla_tgt_cmd *cmd;
5d964837 4309 unsigned long flags;
a4239945 4310 port_id_t id;
2d70c103
NB		 4311
4312 if (unlikely(tgt->tgt_stop)) {
667024a3 4313 ql_dbg(ql_dbg_io, vha, 0x3061,
2d70c103 4314 "New command while device %p is shutting down\n", tgt);
7cf95f7e 4315 return -ENODEV;
2d70c103
NB		 4316 }
4317
df95f39a 4318 id = be_to_port_id(atio->u.isp24.fcp_hdr.s_id);
a4239945
QT		 4319 if (IS_SW_RESV_ADDR(id))
4320 return -EBUSY;
4321
51a07f84 4322 sess = ha->tgt.tgt_ops->find_sess_by_s_id(vha, atio->u.isp24.fcp_hdr.s_id);
fb35265b
QT		 4323 if (unlikely(!sess))
4324 return -EFAULT;
e52a8b45
AP		 4325
4326 /* Another WWN used to have our s_id. Our PLOGI scheduled its
4327 * session deletion, but it's still in sess_del_work wq */
726b8548 4328 if (sess->deleted) {
83548fe2 4329 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf002,
e52a8b45
AP		 4330 "New command while old session %p is being deleted\n",
4331 sess);
4332 return -EFAULT;
4333 }
4334
51a07f84
NB		 4335 /*
4336 * Do kref_get() before returning + dropping qla_hw_data->hardware_lock.
4337 */
726b8548 4338 if (!kref_get_unless_zero(&sess->sess_kref)) {
83548fe2 4339 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf004,
726b8548
QT		 4340 "%s: kref_get fail, %8phC oxid %x \n",
4341 __func__, sess->port_name,
4342 be16_to_cpu(atio->u.isp24.fcp_hdr.ox_id));
4343 return -EFAULT;
4344 }
51a07f84
NB		 4345
4346 cmd = qlt_get_tag(vha, sess, atio);
2d70c103 4347 if (!cmd) {
667024a3 4348 ql_dbg(ql_dbg_io, vha, 0x3062,
2d70c103 4349 "qla_target(%d): Allocation of cmd failed\n", vha->vp_idx);
5d964837 4350 ha->tgt.tgt_ops->put_sess(sess);
7cf95f7e 4351 return -EBUSY;
2d70c103
NB		 4352 }
4353
e07f8f65 4354 cmd->cmd_in_wq = 1;
1eb42f96 4355 cmd->trc_flags |= TRC_NEW_CMD;
8b2f5ff3 4356
726b8548 4357 spin_lock_irqsave(&vha->cmd_list_lock, flags);
8b2f5ff3 4358 list_add_tail(&cmd->cmd_list, &vha->qla_cmd_list);
726b8548 4359 spin_unlock_irqrestore(&vha->cmd_list_lock, flags);
8b2f5ff3 4360
2d70c103 4361 INIT_WORK(&cmd->work, qlt_do_work);
e326d22a
QT		 4362 if (vha->flags.qpairs_available) {
4363 queue_work_on(cmd->se_cmd.cpuid, qla_tgt_wq, &cmd->work);
4364 } else if (ha->msix_count) {
fb3269ba
QT		 4365 if (cmd->atio.u.isp24.fcp_cmnd.rddata)
4366 queue_work_on(smp_processor_id(), qla_tgt_wq,
4367 &cmd->work);
4368 else
4369 queue_work_on(cmd->se_cmd.cpuid, qla_tgt_wq,
4370 &cmd->work);
4371 } else {
4372 queue_work(qla_tgt_wq, &cmd->work);
4373 }
2d70c103 4374
82de802a 4375 return 0;
2d70c103
NB		 4376}
4377
4378/* ha->hardware_lock supposed to be held on entry */
5d964837 4379static int qlt_issue_task_mgmt(struct fc_port *sess, u64 lun,
2d70c103
NB		 4380 int fn, void *iocb, int flags)
4381{
4382 struct scsi_qla_host *vha = sess->vha;
4383 struct qla_hw_data *ha = vha->hw;
4384 struct qla_tgt_mgmt_cmd *mcmd;
8b2f5ff3 4385 struct atio_from_isp *a = (struct atio_from_isp *)iocb;
84905dfe 4386 struct qla_qpair_hint *h = &vha->vha_tgt.qla_tgt->qphints[0];
2d70c103
NB		 4387
4388 mcmd = mempool_alloc(qla_tgt_mgmt_cmd_mempool, GFP_ATOMIC);
4389 if (!mcmd) {
4390 ql_dbg(ql_dbg_tgt_tmr, vha, 0x10009,
4391 "qla_target(%d): Allocation of management "
4392 "command failed, some commands and their data could "
4393 "leak\n", vha->vp_idx);
4394 return -ENOMEM;
4395 }
4396 memset(mcmd, 0, sizeof(*mcmd));
4397 mcmd->sess = sess;
4398
4399 if (iocb) {
4400 memcpy(&mcmd->orig_iocb.imm_ntfy, iocb,
4401 sizeof(mcmd->orig_iocb.imm_ntfy));
4402 }
4403 mcmd->tmr_func = fn;
4404 mcmd->flags = flags;
7c3f8fd1 4405 mcmd->reset_count = ha->base_qpair->chip_reset;
84905dfe 4406 mcmd->qpair = h->qpair;
72fcd4eb 4407 mcmd->vha = vha;
84905dfe
QT		 4408 mcmd->se_cmd.cpuid = h->cpuid;
4409 mcmd->unpacked_lun = lun;
2d70c103
NB		 4410
4411 switch (fn) {
2d70c103 4412 case QLA_TGT_LUN_RESET:
84905dfe
QT		 4413 case QLA_TGT_CLEAR_TS:
4414 case QLA_TGT_ABORT_TS:
4415 abort_cmds_for_lun(vha, lun, a->u.isp24.fcp_hdr.s_id);
50435d42 4416 /* fall through */
84905dfe
QT		 4417 case QLA_TGT_CLEAR_ACA:
4418 h = qlt_find_qphint(vha, mcmd->unpacked_lun);
4419 mcmd->qpair = h->qpair;
4420 mcmd->se_cmd.cpuid = h->cpuid;
4421 break;
2d70c103 4422
84905dfe
QT		 4423 case QLA_TGT_TARGET_RESET:
4424 case QLA_TGT_NEXUS_LOSS_SESS:
4425 case QLA_TGT_NEXUS_LOSS:
4426 case QLA_TGT_ABORT_ALL:
4427 default:
4428 /* no-op */
4429 break;
2d70c103
NB		 4430 }
4431
84905dfe
QT		 4432 INIT_WORK(&mcmd->work, qlt_do_tmr_work);
4433 queue_work_on(mcmd->se_cmd.cpuid, qla_tgt_wq,
4434 &mcmd->work);
4435
2d70c103
NB		 4436 return 0;
4437}
4438
4439/* ha->hardware_lock supposed to be held on entry */
4440static int qlt_handle_task_mgmt(struct scsi_qla_host *vha, void *iocb)
4441{
4442 struct atio_from_isp *a = (struct atio_from_isp *)iocb;
4443 struct qla_hw_data *ha = vha->hw;
5d964837 4444 struct fc_port *sess;
f775bd14 4445 u64 unpacked_lun;
52c82823 4446 int fn;
7560151b 4447 unsigned long flags;
2d70c103 4448
2d70c103 4449 fn = a->u.isp24.fcp_cmnd.task_mgmt_flags;
7560151b
QT		 4450
4451 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
2d70c103
NB		 4452 sess = ha->tgt.tgt_ops->find_sess_by_s_id(vha,
4453 a->u.isp24.fcp_hdr.s_id);
7560151b
QT		 4454 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
4455
f775bd14
QT		 4456 unpacked_lun =
4457 scsilun_to_int((struct scsi_lun *)&a->u.isp24.fcp_cmnd.lun);
2d70c103 4458
fb35265b 4459 if (sess == NULL || sess->deleted)
e52a8b45
AP		 4460 return -EFAULT;
4461
2d70c103
NB		 4462 return qlt_issue_task_mgmt(sess, unpacked_lun, fn, iocb, 0);
4463}
4464
4465/* ha->hardware_lock supposed to be held on entry */
4466static int __qlt_abort_task(struct scsi_qla_host *vha,
5d964837 4467 struct imm_ntfy_from_isp *iocb, struct fc_port *sess)
2d70c103
NB		 4468{
4469 struct atio_from_isp *a = (struct atio_from_isp *)iocb;
4470 struct qla_hw_data *ha = vha->hw;
4471 struct qla_tgt_mgmt_cmd *mcmd;
f775bd14 4472 u64 unpacked_lun;
2d70c103
NB		 4473 int rc;
4474
4475 mcmd = mempool_alloc(qla_tgt_mgmt_cmd_mempool, GFP_ATOMIC);
4476 if (mcmd == NULL) {
4477 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf05f,
4478 "qla_target(%d): %s: Allocation of ABORT cmd failed\n",
4479 vha->vp_idx, __func__);
4480 return -ENOMEM;
4481 }
4482 memset(mcmd, 0, sizeof(*mcmd));
4483
4484 mcmd->sess = sess;
4485 memcpy(&mcmd->orig_iocb.imm_ntfy, iocb,
4486 sizeof(mcmd->orig_iocb.imm_ntfy));
4487
f775bd14
QT		 4488 unpacked_lun =
4489 scsilun_to_int((struct scsi_lun *)&a->u.isp24.fcp_cmnd.lun);
7c3f8fd1 4490 mcmd->reset_count = ha->base_qpair->chip_reset;
be92fc3f 4491 mcmd->tmr_func = QLA_TGT_2G_ABORT_TASK;
82de802a 4492 mcmd->qpair = ha->base_qpair;
2d70c103 4493
be92fc3f 4494 rc = ha->tgt.tgt_ops->handle_tmr(mcmd, unpacked_lun, mcmd->tmr_func,
2d70c103
NB		 4495 le16_to_cpu(iocb->u.isp2x.seq_id));
4496 if (rc != 0) {
4497 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf060,
4498 "qla_target(%d): tgt_ops->handle_tmr() failed: %d\n",
4499 vha->vp_idx, rc);
4500 mempool_free(mcmd, qla_tgt_mgmt_cmd_mempool);
4501 return -EFAULT;
4502 }
4503
4504 return 0;
4505}
4506
4507/* ha->hardware_lock supposed to be held on entry */
4508static int qlt_abort_task(struct scsi_qla_host *vha,
4509 struct imm_ntfy_from_isp *iocb)
4510{
4511 struct qla_hw_data *ha = vha->hw;
5d964837 4512 struct fc_port *sess;
2d70c103 4513 int loop_id;
7560151b 4514 unsigned long flags;
2d70c103
NB		 4515
4516 loop_id = GET_TARGET_ID(ha, (struct atio_from_isp *)iocb);
4517
7560151b 4518 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
2d70c103 4519 sess = ha->tgt.tgt_ops->find_sess_by_loop_id(vha, loop_id);
7560151b
QT		 4520 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
4521
2d70c103
NB		 4522 if (sess == NULL) {
4523 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf025,
4524 "qla_target(%d): task abort for unexisting "
4525 "session\n", vha->vp_idx);
0e8cd71c 4526 return qlt_sched_sess_work(vha->vha_tgt.qla_tgt,
2d70c103
NB		 4527 QLA_TGT_SESS_WORK_ABORT, iocb, sizeof(*iocb));
4528 }
4529
4530 return __qlt_abort_task(vha, iocb, sess);
4531}
4532
a6ca8878
AP		 4533void qlt_logo_completion_handler(fc_port_t *fcport, int rc)
4534{
726b8548
QT		 4535 if (rc != MBS_COMMAND_COMPLETE) {
4536 ql_dbg(ql_dbg_tgt_mgt, fcport->vha, 0xf093,
4537 "%s: se_sess %p / sess %p from"
4538 " port %8phC loop_id %#04x s_id %02x:%02x:%02x"
4539 " LOGO failed: %#x\n",
4540 __func__,
4541 fcport->se_sess,
4542 fcport,
4543 fcport->port_name, fcport->loop_id,
4544 fcport->d_id.b.domain, fcport->d_id.b.area,
4545 fcport->d_id.b.al_pa, rc);
4546 }
4547
4548 fcport->logout_completed = 1;
a6ca8878
AP		 4549}
4550
a6ca8878
AP		 4551/*
4552* ha->hardware_lock supposed to be held on entry (to protect tgt->sess_list)
4553*
4554* Schedules sessions with matching port_id/loop_id but different wwn for
4555* deletion. Returns existing session with matching wwn if present.
4556* Null otherwise.
4557*/
726b8548
QT		 4558struct fc_port *
4559qlt_find_sess_invalidate_other(scsi_qla_host_t *vha, uint64_t wwn,
5d964837 4560 port_id_t port_id, uint16_t loop_id, struct fc_port **conflict_sess)
a6ca8878 4561{
5d964837 4562 struct fc_port *sess = NULL, *other_sess;
a6ca8878
AP		 4563 uint64_t other_wwn;
4564
b7bd104e
AP		 4565 *conflict_sess = NULL;
4566
5d964837 4567 list_for_each_entry(other_sess, &vha->vp_fcports, list) {
a6ca8878
AP		 4568
4569 other_wwn = wwn_to_u64(other_sess->port_name);
4570
4571 if (wwn == other_wwn) {
4572 WARN_ON(sess);
4573 sess = other_sess;
4574 continue;
4575 }
4576
4577 /* find other sess with nport_id collision */
37cacc0a 4578 if (port_id.b24 == other_sess->d_id.b24) {
a6ca8878 4579 if (loop_id != other_sess->loop_id) {
726b8548 4580 ql_dbg(ql_dbg_tgt_tmr, vha, 0x1000c,
a6ca8878
AP		 4581 "Invalidating sess %p loop_id %d wwn %llx.\n",
4582 other_sess, other_sess->loop_id, other_wwn);
4583
4584 /*
4585 * logout_on_delete is set by default, but another
4586 * session that has the same s_id/loop_id combo
4587 * might have cleared it when requested this session
4588 * deletion, so don't touch it
4589 */
94cff6e1 4590 qlt_schedule_sess_for_deletion(other_sess);
a6ca8878
AP		 4591 } else {
4592 /*
4593 * Another wwn used to have our s_id/loop_id
b7bd104e 4594 * kill the session, but don't free the loop_id
a6ca8878 4595 */
83548fe2 4596 ql_dbg(ql_dbg_tgt_tmr, vha, 0xf01b,
726b8548
QT		 4597 "Invalidating sess %p loop_id %d wwn %llx.\n",
4598 other_sess, other_sess->loop_id, other_wwn);
4599
b7bd104e 4600 other_sess->keep_nport_handle = 1;
ba743f91
QT		 4601 if (other_sess->disc_state != DSC_DELETED)
4602 *conflict_sess = other_sess;
94cff6e1 4603 qlt_schedule_sess_for_deletion(other_sess);
a6ca8878
AP		 4604 }
4605 continue;
4606 }
4607
4608 /* find other sess with nport handle collision */
726b8548
QT		 4609 if ((loop_id == other_sess->loop_id) &&
4610 (loop_id != FC_NO_LOOP_ID)) {
4611 ql_dbg(ql_dbg_tgt_tmr, vha, 0x1000d,
a6ca8878
AP		 4612 "Invalidating sess %p loop_id %d wwn %llx.\n",
4613 other_sess, other_sess->loop_id, other_wwn);
4614
4615 /* Same loop_id but different s_id
4616 * Ok to kill and logout */
94cff6e1 4617 qlt_schedule_sess_for_deletion(other_sess);
a6ca8878
AP		 4618 }
4619 }
4620
4621 return sess;
4622}
4623
daddf5cf
AP		 4624/* Abort any commands for this s_id waiting on qla_tgt_wq workqueue */
4625static int abort_cmds_for_s_id(struct scsi_qla_host *vha, port_id_t *s_id)
4626{
4627 struct qla_tgt_sess_op *op;
4628 struct qla_tgt_cmd *cmd;
4629 uint32_t key;
4630 int count = 0;
8b631d87 4631 unsigned long flags;
daddf5cf
AP		 4632
4633 key = (((u32)s_id->b.domain << 16) |
4634 ((u32)s_id->b.area << 8) |
4635 ((u32)s_id->b.al_pa));
4636
8b631d87 4637 spin_lock_irqsave(&vha->cmd_list_lock, flags);
daddf5cf
AP		 4638 list_for_each_entry(op, &vha->qla_sess_op_cmd_list, cmd_list) {
4639 uint32_t op_key = sid_to_key(op->atio.u.isp24.fcp_hdr.s_id);
41dc529a 4640
daddf5cf
AP		 4641 if (op_key == key) {
4642 op->aborted = true;
4643 count++;
4644 }
4645 }
41dc529a
QT		 4646
4647 list_for_each_entry(op, &vha->unknown_atio_list, cmd_list) {
4648 uint32_t op_key = sid_to_key(op->atio.u.isp24.fcp_hdr.s_id);
bd432bb5 4649
41dc529a
QT		 4650 if (op_key == key) {
4651 op->aborted = true;
4652 count++;
4653 }
4654 }
4655
daddf5cf
AP		 4656 list_for_each_entry(cmd, &vha->qla_cmd_list, cmd_list) {
4657 uint32_t cmd_key = sid_to_key(cmd->atio.u.isp24.fcp_hdr.s_id);
bd432bb5 4658
daddf5cf 4659 if (cmd_key == key) {
193b50b9 4660 cmd->aborted = 1;
daddf5cf
AP		 4661 count++;
4662 }
4663 }
8b631d87 4664 spin_unlock_irqrestore(&vha->cmd_list_lock, flags);
daddf5cf
AP		 4665
4666 return count;
4667}
4668
9cd883f0
QT		 4669static int qlt_handle_login(struct scsi_qla_host *vha,
4670 struct imm_ntfy_from_isp *iocb)
4671{
4672 struct fc_port *sess = NULL, *conflict_sess = NULL;
4673 uint64_t wwn;
4674 port_id_t port_id;
4675 uint16_t loop_id, wd3_lo;
4676 int res = 0;
4677 struct qlt_plogi_ack_t *pla;
4678 unsigned long flags;
4679
57bf595a
BVA		 4680 lockdep_assert_held(&vha->hw->hardware_lock);
4681
9cd883f0
QT		 4682 wwn = wwn_to_u64(iocb->u.isp24.port_name);
4683
4684 port_id.b.domain = iocb->u.isp24.port_id[2];
4685 port_id.b.area = iocb->u.isp24.port_id[1];
4686 port_id.b.al_pa = iocb->u.isp24.port_id[0];
4687 port_id.b.rsvd_1 = 0;
4688
4689 loop_id = le16_to_cpu(iocb->u.isp24.nport_handle);
4690
4691 /* Mark all stale commands sitting in qla_tgt_wq for deletion */
4692 abort_cmds_for_s_id(vha, &port_id);
4693
4694 if (wwn) {
4695 spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
4696 sess = qlt_find_sess_invalidate_other(vha, wwn,
4697 port_id, loop_id, &conflict_sess);
4698 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
aa9e6d7b
QT		 4699 } else {
4700 ql_dbg(ql_dbg_disc, vha, 0xffff,
4701 "%s %d Term INOT due to WWN=0 lid=%d, NportID %06X ",
4702 __func__, __LINE__, loop_id, port_id.b24);
4703 qlt_send_term_imm_notif(vha, iocb, 1);
4704 goto out;
9cd883f0
QT		 4705 }
4706
4707 if (IS_SW_RESV_ADDR(port_id)) {
4708 res = 1;
4709 goto out;
4710 }
4711
4712 pla = qlt_plogi_ack_find_add(vha, &port_id, iocb);
4713 if (!pla) {
48acad09
QT		 4714 ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
4715 "%s %d %8phC Term INOT due to mem alloc fail",
4716 __func__, __LINE__,
4717 iocb->u.isp24.port_name);
9cd883f0
QT		 4718 qlt_send_term_imm_notif(vha, iocb, 1);
4719 goto out;
4720 }
4721
4722 if (conflict_sess) {
4723 conflict_sess->login_gen++;
4724 qlt_plogi_ack_link(vha, pla, conflict_sess,
4725 QLT_PLOGI_LINK_CONFLICT);
4726 }
4727
4728 if (!sess) {
4729 pla->ref_count++;
4730 ql_dbg(ql_dbg_disc, vha, 0xffff,
4731 "%s %d %8phC post new sess\n",
4732 __func__, __LINE__, iocb->u.isp24.port_name);
a4239945
QT		 4733 if (iocb->u.isp24.status_subcode == ELS_PLOGI)
4734 qla24xx_post_newsess_work(vha, &port_id,
4735 iocb->u.isp24.port_name,
4736 iocb->u.isp24.u.plogi.node_name,
4737 pla, FC4_TYPE_UNKNOWN);
4738 else
4739 qla24xx_post_newsess_work(vha, &port_id,
4740 iocb->u.isp24.port_name, NULL,
4741 pla, FC4_TYPE_UNKNOWN);
4742
9cd883f0
QT		 4743 goto out;
4744 }
4745
cd4ed6b4
QT		 4746 if (sess->disc_state == DSC_UPD_FCPORT) {
4747 u16 sec;
4748
4749 /*
4750 * Remote port registration is still going on from
4751 * previous login. Allow it to finish before we
4752 * accept the new login.
4753 */
4754 sess->next_disc_state = DSC_DELETE_PEND;
4755 sec = jiffies_to_msecs(jiffies -
4756 sess->jiffies_at_registration) / 1000;
4757 if (sess->sec_since_registration < sec && sec &&
4758 !(sec % 5)) {
4759 sess->sec_since_registration = sec;
4760 ql_dbg(ql_dbg_disc, vha, 0xffff,
4761 "%s %8phC - Slow Rport registration (%d Sec)\n",
4762 __func__, sess->port_name, sec);
4763 }
4764
1df627b4
BVA		 4765 if (!conflict_sess) {
4766 list_del(&pla->list);
cd4ed6b4 4767 kmem_cache_free(qla_tgt_plogi_cachep, pla);
1df627b4 4768 }
cd4ed6b4
QT		 4769
4770 qlt_send_term_imm_notif(vha, iocb, 1);
4771 goto out;
4772 }
4773
9cd883f0
QT		 4774 qlt_plogi_ack_link(vha, pla, sess, QLT_PLOGI_LINK_SAME_WWN);
4775 sess->d_id = port_id;
4776 sess->login_gen++;
4777
4778 if (iocb->u.isp24.status_subcode == ELS_PRLI) {
4779 sess->fw_login_state = DSC_LS_PRLI_PEND;
4780 sess->local = 0;
4781 sess->loop_id = loop_id;
4782 sess->d_id = port_id;
4783 sess->fw_login_state = DSC_LS_PRLI_PEND;
4784 wd3_lo = le16_to_cpu(iocb->u.isp24.u.prli.wd3_lo);
4785
4786 if (wd3_lo & BIT_7)
4787 sess->conf_compl_supported = 1;
4788
4789 if ((wd3_lo & BIT_4) == 0)
4790 sess->port_type = FCT_INITIATOR;
4791 else
4792 sess->port_type = FCT_TARGET;
4793
4794 } else
4795 sess->fw_login_state = DSC_LS_PLOGI_PEND;
4796
4797
4798 ql_dbg(ql_dbg_disc, vha, 0x20f9,
4799 "%s %d %8phC DS %d\n",
4800 __func__, __LINE__, sess->port_name, sess->disc_state);
4801
4802 switch (sess->disc_state) {
4803 case DSC_DELETED:
4804 qlt_plogi_ack_unref(vha, pla);
4805 break;
4806
4807 default:
4808 /*
4809 * Under normal circumstances we want to release nport handle
4810 * during LOGO process to avoid nport handle leaks inside FW.
4811 * The exception is when LOGO is done while another PLOGI with
4812 * the same nport handle is waiting as might be the case here.
4813 * Note: there is always a possibily of a race where session
4814 * deletion has already started for other reasons (e.g. ACL
4815 * removal) and now PLOGI arrives:
4816 * 1. if PLOGI arrived in FW after nport handle has been freed,
4817 * FW must have assigned this PLOGI a new/same handle and we
4818 * can proceed ACK'ing it as usual when session deletion
4819 * completes.
4820 * 2. if PLOGI arrived in FW before LOGO with LCF_FREE_NPORT
4821 * bit reached it, the handle has now been released. We'll
4822 * get an error when we ACK this PLOGI. Nothing will be sent
4823 * back to initiator. Initiator should eventually retry
4824 * PLOGI and situation will correct itself.
4825 */
4826 sess->keep_nport_handle = ((sess->loop_id == loop_id) &&
4827 (sess->d_id.b24 == port_id.b24));
4828
4829 ql_dbg(ql_dbg_disc, vha, 0x20f9,
4830 "%s %d %8phC post del sess\n",
4831 __func__, __LINE__, sess->port_name);
4832
4833
d8630bb9 4834 qlt_schedule_sess_for_deletion(sess);
9cd883f0
QT		 4835 break;
4836 }
4837out:
4838 return res;
4839}
4840
2d70c103
NB		 4841/*
4842 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
4843 */
4844static int qlt_24xx_handle_els(struct scsi_qla_host *vha,
4845 struct imm_ntfy_from_isp *iocb)
4846{
a6ca8878 4847 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
df673274 4848 struct qla_hw_data *ha = vha->hw;
5d964837 4849 struct fc_port *sess = NULL, *conflict_sess = NULL;
a6ca8878
AP		 4850 uint64_t wwn;
4851 port_id_t port_id;
4852 uint16_t loop_id;
4853 uint16_t wd3_lo;
2d70c103 4854 int res = 0;
9cd883f0 4855 unsigned long flags;
2d70c103 4856
57bf595a
BVA		 4857 lockdep_assert_held(&ha->hardware_lock);
4858
a6ca8878
AP		 4859 wwn = wwn_to_u64(iocb->u.isp24.port_name);
4860
4861 port_id.b.domain = iocb->u.isp24.port_id[2];
4862 port_id.b.area = iocb->u.isp24.port_id[1];
4863 port_id.b.al_pa = iocb->u.isp24.port_id[0];
4864 port_id.b.rsvd_1 = 0;
4865
4866 loop_id = le16_to_cpu(iocb->u.isp24.nport_handle);
4867
726b8548
QT		 4868 ql_dbg(ql_dbg_disc, vha, 0xf026,
4869 "qla_target(%d): Port ID: %02x:%02x:%02x ELS opcode: 0x%02x lid %d %8phC\n",
4870 vha->vp_idx, iocb->u.isp24.port_id[2],
4871 iocb->u.isp24.port_id[1], iocb->u.isp24.port_id[0],
4872 iocb->u.isp24.status_subcode, loop_id,
4873 iocb->u.isp24.port_name);
2d70c103 4874
a6ca8878
AP		 4875 /* res = 1 means ack at the end of thread
4876 * res = 0 means ack async/later.
4877 */
2d70c103
NB		 4878 switch (iocb->u.isp24.status_subcode) {
4879 case ELS_PLOGI:
9cd883f0
QT		 4880 res = qlt_handle_login(vha, iocb);
4881 break;
a6ca8878 4882
9cd883f0
QT		 4883 case ELS_PRLI:
4884 if (N2N_TOPO(ha)) {
4885 sess = qla2x00_find_fcport_by_wwpn(vha,
4886 iocb->u.isp24.port_name, 1);
726b8548 4887
9cd883f0
QT		 4888 if (sess && sess->plogi_link[QLT_PLOGI_LINK_SAME_WWN]) {
4889 ql_dbg(ql_dbg_disc, vha, 0xffff,
4890 "%s %d %8phC Term PRLI due to PLOGI ACK not completed\n",
4891 __func__, __LINE__,
4892 iocb->u.isp24.port_name);
4893 qlt_send_term_imm_notif(vha, iocb, 1);
4894 break;
4895 }
726b8548 4896
9cd883f0 4897 res = qlt_handle_login(vha, iocb);
726b8548
QT		 4898 break;
4899 }
4900
a4239945
QT		 4901 if (IS_SW_RESV_ADDR(port_id)) {
4902 res = 1;
4903 break;
4904 }
4905
a6ca8878
AP		 4906 wd3_lo = le16_to_cpu(iocb->u.isp24.u.prli.wd3_lo);
4907
7560151b
QT		 4908 if (wwn) {
4909 spin_lock_irqsave(&tgt->ha->tgt.sess_lock, flags);
726b8548
QT		 4910 sess = qlt_find_sess_invalidate_other(vha, wwn, port_id,
4911 loop_id, &conflict_sess);
7560151b
QT		 4912 spin_unlock_irqrestore(&tgt->ha->tgt.sess_lock, flags);
4913 }
b7bd104e
AP		 4914
4915 if (conflict_sess) {
5ef696aa
QT		 4916 switch (conflict_sess->disc_state) {
4917 case DSC_DELETED:
4918 case DSC_DELETE_PEND:
4919 break;
4920 default:
4921 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf09b,
4922 "PRLI with conflicting sess %p port %8phC\n",
4923 conflict_sess, conflict_sess->port_name);
4924 conflict_sess->fw_login_state =
4925 DSC_LS_PORT_UNAVAIL;
4926 qlt_send_term_imm_notif(vha, iocb, 1);
4927 res = 0;
4928 break;
4929 }
b7bd104e 4930 }
a6ca8878
AP		 4931
4932 if (sess != NULL) {
a4239945 4933 bool delete = false;
cd4ed6b4 4934 int sec;
bd432bb5 4935
82abdcaf
QT		 4936 spin_lock_irqsave(&tgt->ha->tgt.sess_lock, flags);
4937 switch (sess->fw_login_state) {
a4239945 4938 case DSC_LS_PLOGI_PEND:
82abdcaf
QT		 4939 case DSC_LS_PLOGI_COMP:
4940 case DSC_LS_PRLI_COMP:
4941 break;
4942 default:
a4239945
QT		 4943 delete = true;
4944 break;
4945 }
4946
4947 switch (sess->disc_state) {
cd4ed6b4
QT		 4948 case DSC_UPD_FCPORT:
4949 spin_unlock_irqrestore(&tgt->ha->tgt.sess_lock,
4950 flags);
4951
4952 sec = jiffies_to_msecs(jiffies -
4953 sess->jiffies_at_registration)/1000;
4954 if (sess->sec_since_registration < sec && sec &&
4955 !(sec % 5)) {
4956 sess->sec_since_registration = sec;
4957 ql_dbg(ql_dbg_disc, sess->vha, 0xffff,
4958 "%s %8phC : Slow Rport registration(%d Sec)\n",
4959 __func__, sess->port_name, sec);
4960 }
4961 qlt_send_term_imm_notif(vha, iocb, 1);
4962 return 0;
4963
a4239945
QT		 4964 case DSC_LOGIN_PEND:
4965 case DSC_GPDB:
a4239945
QT		 4966 case DSC_LOGIN_COMPLETE:
4967 case DSC_ADISC:
4968 delete = false;
4969 break;
4970 default:
4971 break;
4972 }
4973
4974 if (delete) {
82abdcaf
QT		 4975 spin_unlock_irqrestore(&tgt->ha->tgt.sess_lock,
4976 flags);
a6ca8878
AP		 4977 /*
4978 * Impatient initiator sent PRLI before last
4979 * PLOGI could finish. Will force him to re-try,
4980 * while last one finishes.
4981 */
df673274 4982 ql_log(ql_log_warn, sess->vha, 0xf095,
a6ca8878
AP		 4983 "sess %p PRLI received, before plogi ack.\n",
4984 sess);
4985 qlt_send_term_imm_notif(vha, iocb, 1);
4986 res = 0;
4987 break;
4988 }
4989
4990 /*
4991 * This shouldn't happen under normal circumstances,
4992 * since we have deleted the old session during PLOGI
4993 */
df673274 4994 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf096,
a6ca8878
AP		 4995 "PRLI (loop_id %#04x) for existing sess %p (loop_id %#04x)\n",
4996 sess->loop_id, sess, iocb->u.isp24.nport_handle);
4997
4998 sess->local = 0;
4999 sess->loop_id = loop_id;
37cacc0a 5000 sess->d_id = port_id;
726b8548 5001 sess->fw_login_state = DSC_LS_PRLI_PEND;
a6ca8878
AP		 5002
5003 if (wd3_lo & BIT_7)
5004 sess->conf_compl_supported = 1;
5005
726b8548
QT		 5006 if ((wd3_lo & BIT_4) == 0)
5007 sess->port_type = FCT_INITIATOR;
5008 else
5009 sess->port_type = FCT_TARGET;
82abdcaf
QT		 5010
5011 spin_unlock_irqrestore(&tgt->ha->tgt.sess_lock, flags);
df673274
AP		 5012 }
5013 res = 1; /* send notify ack */
5014
5015 /* Make session global (not used in fabric mode) */
5016 if (ha->current_topology != ISP_CFG_F) {
ec7193e2 5017 if (sess) {
83548fe2 5018 ql_dbg(ql_dbg_disc, vha, 0x20fa,
ec7193e2
QT		 5019 "%s %d %8phC post nack\n",
5020 __func__, __LINE__, sess->port_name);
5021 qla24xx_post_nack_work(vha, sess, iocb,
5022 SRB_NACK_PRLI);
5023 res = 0;
5024 } else {
5025 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
5026 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
5027 qla2xxx_wake_dpc(vha);
5028 }
a6ca8878 5029 } else {
726b8548 5030 if (sess) {
83548fe2 5031 ql_dbg(ql_dbg_disc, vha, 0x20fb,
ec7193e2
QT		 5032 "%s %d %8phC post nack\n",
5033 __func__, __LINE__, sess->port_name);
726b8548
QT		 5034 qla24xx_post_nack_work(vha, sess, iocb,
5035 SRB_NACK_PRLI);
5036 res = 0;
5037 }
5038 }
a6ca8878
AP		 5039 break;
5040
41dc529a
QT		 5041 case ELS_TPRLO:
5042 if (le16_to_cpu(iocb->u.isp24.flags) &
5043 NOTIFY24XX_FLAGS_GLOBAL_TPRLO) {
5044 loop_id = 0xFFFF;
5045 qlt_reset(vha, iocb, QLA_TGT_NEXUS_LOSS);
5046 res = 1;
5047 break;
5048 }
81881861 5049 /* fall through */
2d70c103
NB		 5050 case ELS_LOGO:
5051 case ELS_PRLO:
726b8548
QT		 5052 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
5053 sess = qla2x00_find_fcport_by_loopid(vha, loop_id);
5054 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
5055
5056 if (sess) {
5057 sess->login_gen++;
5058 sess->fw_login_state = DSC_LS_LOGO_PEND;
726b8548
QT		 5059 sess->logo_ack_needed = 1;
5060 memcpy(sess->iocb, iocb, IOCB_SIZE);
5061 }
5062
2d70c103 5063 res = qlt_reset(vha, iocb, QLA_TGT_NEXUS_LOSS_SESS);
726b8548 5064
83548fe2 5065 ql_dbg(ql_dbg_disc, vha, 0x20fc,
726b8548
QT		 5066 "%s: logo %llx res %d sess %p ",
5067 __func__, wwn, res, sess);
5068 if (res == 0) {
41dc529a
QT		 5069 /*
5070 * cmd went upper layer, look for qlt_xmit_tm_rsp()
5071 * for LOGO_ACK & sess delete
5072 */
726b8548
QT		 5073 BUG_ON(!sess);
5074 res = 0;
5075 } else {
41dc529a 5076 /* cmd did not go to upper layer. */
726b8548 5077 if (sess) {
d8630bb9 5078 qlt_schedule_sess_for_deletion(sess);
726b8548
QT		 5079 res = 0;
5080 }
5081 /* else logo will be ack */
5082 }
2d70c103
NB		 5083 break;
5084 case ELS_PDISC:
5085 case ELS_ADISC:
5086 {
0e8cd71c 5087 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
bd432bb5 5088
2d70c103 5089 if (tgt->link_reinit_iocb_pending) {
82de802a
QT		 5090 qlt_send_notify_ack(ha->base_qpair,
5091 &tgt->link_reinit_iocb, 0, 0, 0, 0, 0, 0);
2d70c103
NB		 5092 tgt->link_reinit_iocb_pending = 0;
5093 }
726b8548
QT		 5094
5095 sess = qla2x00_find_fcport_by_wwpn(vha,
5096 iocb->u.isp24.port_name, 1);
5097 if (sess) {
83548fe2 5098 ql_dbg(ql_dbg_disc, vha, 0x20fd,
726b8548
QT		 5099 "sess %p lid %d|%d DS %d LS %d\n",
5100 sess, sess->loop_id, loop_id,
5101 sess->disc_state, sess->fw_login_state);
5102 }
5103
2d70c103
NB		 5104 res = 1; /* send notify ack */
5105 break;
5106 }
5107
a6ca8878 5108 case ELS_FLOGI: /* should never happen */
2d70c103
NB		 5109 default:
5110 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf061,
5111 "qla_target(%d): Unsupported ELS command %x "
5112 "received\n", vha->vp_idx, iocb->u.isp24.status_subcode);
5113 res = qlt_reset(vha, iocb, QLA_TGT_NEXUS_LOSS_SESS);
5114 break;
5115 }
5116
9cd883f0
QT		 5117 ql_dbg(ql_dbg_disc, vha, 0xf026,
5118 "qla_target(%d): Exit ELS opcode: 0x%02x res %d\n",
5119 vha->vp_idx, iocb->u.isp24.status_subcode, res);
5120
2d70c103
NB		 5121 return res;
5122}
5123
2d70c103
NB		 5124/*
5125 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
5126 */
5127static void qlt_handle_imm_notify(struct scsi_qla_host *vha,
5128 struct imm_ntfy_from_isp *iocb)
5129{
5130 struct qla_hw_data *ha = vha->hw;
5131 uint32_t add_flags = 0;
5132 int send_notify_ack = 1;
5133 uint16_t status;
5134
57bf595a
BVA		 5135 lockdep_assert_held(&ha->hardware_lock);
5136
2d70c103
NB		 5137 status = le16_to_cpu(iocb->u.isp2x.status);
5138 switch (status) {
5139 case IMM_NTFY_LIP_RESET:
5140 {
5141 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf032,
5142 "qla_target(%d): LIP reset (loop %#x), subcode %x\n",
5143 vha->vp_idx, le16_to_cpu(iocb->u.isp24.nport_handle),
5144 iocb->u.isp24.status_subcode);
5145
5146 if (qlt_reset(vha, iocb, QLA_TGT_ABORT_ALL) == 0)
5147 send_notify_ack = 0;
5148 break;
5149 }
5150
5151 case IMM_NTFY_LIP_LINK_REINIT:
5152 {
0e8cd71c 5153 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
bd432bb5 5154
2d70c103
NB		 5155 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf033,
5156 "qla_target(%d): LINK REINIT (loop %#x, "
5157 "subcode %x)\n", vha->vp_idx,
5158 le16_to_cpu(iocb->u.isp24.nport_handle),
5159 iocb->u.isp24.status_subcode);
5160 if (tgt->link_reinit_iocb_pending) {
82de802a
QT		 5161 qlt_send_notify_ack(ha->base_qpair,
5162 &tgt->link_reinit_iocb, 0, 0, 0, 0, 0, 0);
2d70c103
NB		 5163 }
5164 memcpy(&tgt->link_reinit_iocb, iocb, sizeof(*iocb));
5165 tgt->link_reinit_iocb_pending = 1;
5166 /*
5167 * QLogic requires to wait after LINK REINIT for possible
5168 * PDISC or ADISC ELS commands
5169 */
5170 send_notify_ack = 0;
5171 break;
5172 }
5173
5174 case IMM_NTFY_PORT_LOGOUT:
5175 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf034,
5176 "qla_target(%d): Port logout (loop "
5177 "%#x, subcode %x)\n", vha->vp_idx,
5178 le16_to_cpu(iocb->u.isp24.nport_handle),
5179 iocb->u.isp24.status_subcode);
5180
5181 if (qlt_reset(vha, iocb, QLA_TGT_NEXUS_LOSS_SESS) == 0)
5182 send_notify_ack = 0;
5183 /* The sessions will be cleared in the callback, if needed */
5184 break;
5185
5186 case IMM_NTFY_GLBL_TPRLO:
5187 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf035,
5188 "qla_target(%d): Global TPRLO (%x)\n", vha->vp_idx, status);
5189 if (qlt_reset(vha, iocb, QLA_TGT_NEXUS_LOSS) == 0)
5190 send_notify_ack = 0;
5191 /* The sessions will be cleared in the callback, if needed */
5192 break;
5193
5194 case IMM_NTFY_PORT_CONFIG:
5195 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf036,
5196 "qla_target(%d): Port config changed (%x)\n", vha->vp_idx,
5197 status);
5198 if (qlt_reset(vha, iocb, QLA_TGT_ABORT_ALL) == 0)
5199 send_notify_ack = 0;
5200 /* The sessions will be cleared in the callback, if needed */
5201 break;
5202
5203 case IMM_NTFY_GLBL_LOGO:
5204 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf06a,
5205 "qla_target(%d): Link failure detected\n",
5206 vha->vp_idx);
5207 /* I_T nexus loss */
5208 if (qlt_reset(vha, iocb, QLA_TGT_NEXUS_LOSS) == 0)
5209 send_notify_ack = 0;
5210 break;
5211
5212 case IMM_NTFY_IOCB_OVERFLOW:
5213 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf06b,
5214 "qla_target(%d): Cannot provide requested "
5215 "capability (IOCB overflowed the immediate notify "
5216 "resource count)\n", vha->vp_idx);
5217 break;
5218
5219 case IMM_NTFY_ABORT_TASK:
5220 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf037,
5221 "qla_target(%d): Abort Task (S %08x I %#x -> "
5222 "L %#x)\n", vha->vp_idx,
5223 le16_to_cpu(iocb->u.isp2x.seq_id),
5224 GET_TARGET_ID(ha, (struct atio_from_isp *)iocb),
5225 le16_to_cpu(iocb->u.isp2x.lun));
5226 if (qlt_abort_task(vha, iocb) == 0)
5227 send_notify_ack = 0;
5228 break;
5229
5230 case IMM_NTFY_RESOURCE:
5231 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf06c,
5232 "qla_target(%d): Out of resources, host %ld\n",
5233 vha->vp_idx, vha->host_no);
5234 break;
5235
5236 case IMM_NTFY_MSG_RX:
5237 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf038,
5238 "qla_target(%d): Immediate notify task %x\n",
5239 vha->vp_idx, iocb->u.isp2x.task_flags);
2d70c103
NB		 5240 break;
5241
5242 case IMM_NTFY_ELS:
5243 if (qlt_24xx_handle_els(vha, iocb) == 0)
5244 send_notify_ack = 0;
5245 break;
2d70c103
NB		 5246 default:
5247 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf06d,
5248 "qla_target(%d): Received unknown immediate "
5249 "notify status %x\n", vha->vp_idx, status);
5250 break;
5251 }
5252
5253 if (send_notify_ack)
82de802a
QT		 5254 qlt_send_notify_ack(ha->base_qpair, iocb, add_flags, 0, 0, 0,
5255 0, 0);
2d70c103
NB		 5256}
5257
5258/*
5259 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
5260 * This function sends busy to ISP 2xxx or 24xx.
5261 */
82de802a 5262static int __qlt_send_busy(struct qla_qpair *qpair,
2d70c103
NB		 5263 struct atio_from_isp *atio, uint16_t status)
5264{
82de802a 5265 struct scsi_qla_host *vha = qpair->vha;
2d70c103
NB		 5266 struct ctio7_to_24xx *ctio24;
5267 struct qla_hw_data *ha = vha->hw;
5268 request_t *pkt;
5d964837 5269 struct fc_port *sess = NULL;
7560151b 5270 unsigned long flags;
f7e761f5 5271 u16 temp;
8ea4faf8
QT		 5272 port_id_t id;
5273
df95f39a 5274 id = be_to_port_id(atio->u.isp24.fcp_hdr.s_id);
2d70c103 5275
7560151b 5276 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
8ea4faf8 5277 sess = qla2x00_find_fcport_by_nportid(vha, &id, 1);
7560151b 5278 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2d70c103 5279 if (!sess) {
82de802a 5280 qlt_send_term_exchange(qpair, NULL, atio, 1, 0);
33e79977 5281 return 0;
2d70c103
NB		 5282 }
5283 /* Sending marker isn't necessary, since we called from ISR */
5284
82de802a 5285 pkt = (request_t *)__qla2x00_alloc_iocbs(qpair, NULL);
2d70c103 5286 if (!pkt) {
667024a3 5287 ql_dbg(ql_dbg_io, vha, 0x3063,
2d70c103
NB		 5288 "qla_target(%d): %s failed: unable to allocate "
5289 "request packet", vha->vp_idx, __func__);
33e79977 5290 return -ENOMEM;
2d70c103
NB		 5291 }
5292
60a9eadb 5293 qpair->tgt_counters.num_q_full_sent++;
2d70c103
NB		 5294 pkt->entry_count = 1;
5295 pkt->handle = QLA_TGT_SKIP_HANDLE | CTIO_COMPLETION_HANDLE_MARK;
5296
5297 ctio24 = (struct ctio7_to_24xx *)pkt;
5298 ctio24->entry_type = CTIO_TYPE7;
5299 ctio24->nport_handle = sess->loop_id;
ad950360 5300 ctio24->timeout = cpu_to_le16(QLA_TGT_TIMEOUT);
2d70c103 5301 ctio24->vp_index = vha->vp_idx;
df95f39a 5302 ctio24->initiator_id = be_id_to_le(atio->u.isp24.fcp_hdr.s_id);
2d70c103 5303 ctio24->exchange_addr = atio->u.isp24.exchange_addr;
f7e761f5 5304 temp = (atio->u.isp24.attr << 9) |
2d70c103 5305 CTIO7_FLAGS_STATUS_MODE_1 | CTIO7_FLAGS_SEND_STATUS |
f7e761f5
QT		 5306 CTIO7_FLAGS_DONT_RET_CTIO;
5307 ctio24->u.status1.flags = cpu_to_le16(temp);
2d70c103
NB		 5308 /*
5309 * CTIO from fw w/o se_cmd doesn't provide enough info to retry it,
5310 * if the explicit conformation is used.
5311 */
5312 ctio24->u.status1.ox_id = swab16(atio->u.isp24.fcp_hdr.ox_id);
5313 ctio24->u.status1.scsi_status = cpu_to_le16(status);
e25f7654
QT		 5314
5315 ctio24->u.status1.residual = get_datalen_for_atio(atio);
5316
5317 if (ctio24->u.status1.residual != 0)
5318 ctio24->u.status1.scsi_status |= SS_RESIDUAL_UNDER;
5319
63163e06
HM		 5320 /* Memory Barrier */
5321 wmb();
8abfa9e2
QT		 5322 if (qpair->reqq_start_iocbs)
5323 qpair->reqq_start_iocbs(qpair);
5324 else
5325 qla2x00_start_iocbs(vha, qpair->req);
33e79977
QT		 5326 return 0;
5327}
5328
5329/*
5330 * This routine is used to allocate a command for either a QFull condition
5331 * (ie reply SAM_STAT_BUSY) or to terminate an exchange that did not go
5332 * out previously.
5333 */
5334static void
5335qlt_alloc_qfull_cmd(struct scsi_qla_host *vha,
5336 struct atio_from_isp *atio, uint16_t status, int qfull)
5337{
5338 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
5339 struct qla_hw_data *ha = vha->hw;
5d964837 5340 struct fc_port *sess;
33e79977
QT		 5341 struct se_session *se_sess;
5342 struct qla_tgt_cmd *cmd;
10e9cbb6 5343 int tag, cpu;
82de802a 5344 unsigned long flags;
33e79977
QT		 5345
5346 if (unlikely(tgt->tgt_stop)) {
5347 ql_dbg(ql_dbg_io, vha, 0x300a,
5348 "New command while device %p is shutting down\n", tgt);
5349 return;
5350 }
5351
5352 if ((vha->hw->tgt.num_qfull_cmds_alloc + 1) > MAX_QFULL_CMDS_ALLOC) {
5353 vha->hw->tgt.num_qfull_cmds_dropped++;
5354 if (vha->hw->tgt.num_qfull_cmds_dropped >
fc90adaf
JC		 5355 vha->qla_stats.stat_max_qfull_cmds_dropped)
5356 vha->qla_stats.stat_max_qfull_cmds_dropped =
33e79977
QT		 5357 vha->hw->tgt.num_qfull_cmds_dropped;
5358
5359 ql_dbg(ql_dbg_io, vha, 0x3068,
5360 "qla_target(%d): %s: QFull CMD dropped[%d]\n",
5361 vha->vp_idx, __func__,
5362 vha->hw->tgt.num_qfull_cmds_dropped);
5363
5364 qlt_chk_exch_leak_thresh_hold(vha);
5365 return;
5366 }
5367
5368 sess = ha->tgt.tgt_ops->find_sess_by_s_id
5369 (vha, atio->u.isp24.fcp_hdr.s_id);
5370 if (!sess)
5371 return;
5372
5373 se_sess = sess->se_sess;
5374
10e9cbb6 5375 tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu);
c04466c1 5376 if (tag < 0) {
33e79977
QT		 5377 ql_dbg(ql_dbg_io, vha, 0x3009,
5378 "qla_target(%d): %s: Allocation of cmd failed\n",
5379 vha->vp_idx, __func__);
5380
5381 vha->hw->tgt.num_qfull_cmds_dropped++;
5382 if (vha->hw->tgt.num_qfull_cmds_dropped >
fc90adaf
JC		 5383 vha->qla_stats.stat_max_qfull_cmds_dropped)
5384 vha->qla_stats.stat_max_qfull_cmds_dropped =
33e79977
QT		 5385 vha->hw->tgt.num_qfull_cmds_dropped;
5386
5387 qlt_chk_exch_leak_thresh_hold(vha);
5388 return;
5389 }
5390
c04466c1 5391 cmd = &((struct qla_tgt_cmd *)se_sess->sess_cmd_map)[tag];
33e79977
QT		 5392 memset(cmd, 0, sizeof(struct qla_tgt_cmd));
5393
5394 qlt_incr_num_pend_cmds(vha);
5395 INIT_LIST_HEAD(&cmd->cmd_list);
5396 memcpy(&cmd->atio, atio, sizeof(*atio));
5397
5398 cmd->tgt = vha->vha_tgt.qla_tgt;
5399 cmd->vha = vha;
7c3f8fd1 5400 cmd->reset_count = ha->base_qpair->chip_reset;
33e79977 5401 cmd->q_full = 1;
82de802a 5402 cmd->qpair = ha->base_qpair;
10e9cbb6 5403 cmd->se_cmd.map_cpu = cpu;
33e79977
QT		 5404
5405 if (qfull) {
5406 cmd->q_full = 1;
5407 /* NOTE: borrowing the state field to carry the status */
5408 cmd->state = status;
5409 } else
5410 cmd->term_exchg = 1;
5411
82de802a 5412 spin_lock_irqsave(&vha->hw->tgt.q_full_lock, flags);
33e79977
QT		 5413 list_add_tail(&cmd->cmd_list, &vha->hw->tgt.q_full_list);
5414
5415 vha->hw->tgt.num_qfull_cmds_alloc++;
5416 if (vha->hw->tgt.num_qfull_cmds_alloc >
fc90adaf
JC		 5417 vha->qla_stats.stat_max_qfull_cmds_alloc)
5418 vha->qla_stats.stat_max_qfull_cmds_alloc =
33e79977 5419 vha->hw->tgt.num_qfull_cmds_alloc;
82de802a 5420 spin_unlock_irqrestore(&vha->hw->tgt.q_full_lock, flags);
33e79977
QT		 5421}
5422
5423int
82de802a 5424qlt_free_qfull_cmds(struct qla_qpair *qpair)
33e79977 5425{
82de802a 5426 struct scsi_qla_host *vha = qpair->vha;
33e79977
QT		 5427 struct qla_hw_data *ha = vha->hw;
5428 unsigned long flags;
5429 struct qla_tgt_cmd *cmd, *tcmd;
82de802a 5430 struct list_head free_list, q_full_list;
33e79977
QT		 5431 int rc = 0;
5432
5433 if (list_empty(&ha->tgt.q_full_list))
5434 return 0;
5435
5436 INIT_LIST_HEAD(&free_list);
82de802a 5437 INIT_LIST_HEAD(&q_full_list);
33e79977 5438
82de802a 5439 spin_lock_irqsave(&vha->hw->tgt.q_full_lock, flags);
33e79977 5440 if (list_empty(&ha->tgt.q_full_list)) {
82de802a 5441 spin_unlock_irqrestore(&vha->hw->tgt.q_full_lock, flags);
33e79977
QT		 5442 return 0;
5443 }
5444
82de802a
QT		 5445 list_splice_init(&vha->hw->tgt.q_full_list, &q_full_list);
5446 spin_unlock_irqrestore(&vha->hw->tgt.q_full_lock, flags);
5447
5448 spin_lock_irqsave(qpair->qp_lock_ptr, flags);
5449 list_for_each_entry_safe(cmd, tcmd, &q_full_list, cmd_list) {
33e79977
QT		 5450 if (cmd->q_full)
5451 /* cmd->state is a borrowed field to hold status */
82de802a 5452 rc = __qlt_send_busy(qpair, &cmd->atio, cmd->state);
33e79977 5453 else if (cmd->term_exchg)
82de802a 5454 rc = __qlt_send_term_exchange(qpair, NULL, &cmd->atio);
33e79977
QT		 5455
5456 if (rc == -ENOMEM)
5457 break;
5458
5459 if (cmd->q_full)
5460 ql_dbg(ql_dbg_io, vha, 0x3006,
5461 "%s: busy sent for ox_id[%04x]\n", __func__,
5462 be16_to_cpu(cmd->atio.u.isp24.fcp_hdr.ox_id));
5463 else if (cmd->term_exchg)
5464 ql_dbg(ql_dbg_io, vha, 0x3007,
5465 "%s: Term exchg sent for ox_id[%04x]\n", __func__,
5466 be16_to_cpu(cmd->atio.u.isp24.fcp_hdr.ox_id));
5467 else
5468 ql_dbg(ql_dbg_io, vha, 0x3008,
5469 "%s: Unexpected cmd in QFull list %p\n", __func__,
5470 cmd);
5471
5472 list_del(&cmd->cmd_list);
5473 list_add_tail(&cmd->cmd_list, &free_list);
5474
5475 /* piggy back on hardware_lock for protection */
5476 vha->hw->tgt.num_qfull_cmds_alloc--;
5477 }
82de802a 5478 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
33e79977
QT		 5479
5480 cmd = NULL;
5481
5482 list_for_each_entry_safe(cmd, tcmd, &free_list, cmd_list) {
5483 list_del(&cmd->cmd_list);
5484 /* This cmd was never sent to TCM. There is no need
5485 * to schedule free or call free_cmd
5486 */
5487 qlt_free_cmd(cmd);
5488 }
82de802a
QT		 5489
5490 if (!list_empty(&q_full_list)) {
5491 spin_lock_irqsave(&vha->hw->tgt.q_full_lock, flags);
5492 list_splice(&q_full_list, &vha->hw->tgt.q_full_list);
5493 spin_unlock_irqrestore(&vha->hw->tgt.q_full_lock, flags);
5494 }
5495
33e79977
QT		 5496 return rc;
5497}
5498
5499static void
82de802a
QT		 5500qlt_send_busy(struct qla_qpair *qpair, struct atio_from_isp *atio,
5501 uint16_t status)
33e79977
QT		 5502{
5503 int rc = 0;
82de802a 5504 struct scsi_qla_host *vha = qpair->vha;
33e79977 5505
82de802a 5506 rc = __qlt_send_busy(qpair, atio, status);
33e79977
QT		 5507 if (rc == -ENOMEM)
5508 qlt_alloc_qfull_cmd(vha, atio, status, 1);
5509}
5510
5511static int
82de802a
QT		 5512qlt_chk_qfull_thresh_hold(struct scsi_qla_host *vha, struct qla_qpair *qpair,
5513 struct atio_from_isp *atio, uint8_t ha_locked)
33e79977
QT		 5514{
5515 struct qla_hw_data *ha = vha->hw;
8b666809 5516 unsigned long flags;
33e79977
QT		 5517
5518 if (ha->tgt.num_pend_cmds < Q_FULL_THRESH_HOLD(ha))
5519 return 0;
5520
8b666809
QT		 5521 if (!ha_locked)
5522 spin_lock_irqsave(&ha->hardware_lock, flags);
7cf95f7e 5523 qlt_send_busy(qpair, atio, qla_sam_status);
8b666809
QT		 5524 if (!ha_locked)
5525 spin_unlock_irqrestore(&ha->hardware_lock, flags);
5526
33e79977 5527 return 1;
2d70c103
NB		 5528}
5529
5530/* ha->hardware_lock supposed to be held on entry */
5531/* called via callback from qla2xxx */
5532static void qlt_24xx_atio_pkt(struct scsi_qla_host *vha,
2f424b9b 5533 struct atio_from_isp *atio, uint8_t ha_locked)
2d70c103
NB		 5534{
5535 struct qla_hw_data *ha = vha->hw;
0e8cd71c 5536 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
2d70c103 5537 int rc;
7cf95f7e 5538 unsigned long flags = 0;
2d70c103
NB		 5539
5540 if (unlikely(tgt == NULL)) {
ec7193e2 5541 ql_dbg(ql_dbg_tgt, vha, 0x3064,
2d70c103
NB		 5542 "ATIO pkt, but no tgt (ha %p)", ha);
5543 return;
5544 }
2d70c103
NB		 5545 /*
5546 * In tgt_stop mode we also should allow all requests to pass.
5547 * Otherwise, some commands can stuck.
5548 */
5549
2f424b9b 5550 tgt->atio_irq_cmd_count++;
2d70c103
NB		 5551
5552 switch (atio->u.raw.entry_type) {
5553 case ATIO_TYPE7:
2d70c103
NB		 5554 if (unlikely(atio->u.isp24.exchange_addr ==
5555 ATIO_EXCHANGE_ADDRESS_UNKNOWN)) {
667024a3 5556 ql_dbg(ql_dbg_io, vha, 0x3065,
2d70c103
NB		 5557 "qla_target(%d): ATIO_TYPE7 "
5558 "received with UNKNOWN exchange address, "
5559 "sending QUEUE_FULL\n", vha->vp_idx);
2f424b9b
QT		 5560 if (!ha_locked)
5561 spin_lock_irqsave(&ha->hardware_lock, flags);
7cf95f7e 5562 qlt_send_busy(ha->base_qpair, atio, qla_sam_status);
2f424b9b 5563 if (!ha_locked)
82de802a
QT		 5564 spin_unlock_irqrestore(&ha->hardware_lock,
5565 flags);
2d70c103
NB		 5566 break;
5567 }
33e79977 5568
33e79977 5569 if (likely(atio->u.isp24.fcp_cmnd.task_mgmt_flags == 0)) {
82de802a
QT		 5570 rc = qlt_chk_qfull_thresh_hold(vha, ha->base_qpair,
5571 atio, ha_locked);
33e79977 5572 if (rc != 0) {
2f424b9b 5573 tgt->atio_irq_cmd_count--;
33e79977
QT		 5574 return;
5575 }
2d70c103 5576 rc = qlt_handle_cmd_for_atio(vha, atio);
33e79977 5577 } else {
2d70c103 5578 rc = qlt_handle_task_mgmt(vha, atio);
33e79977 5579 }
2d70c103 5580 if (unlikely(rc != 0)) {
7cf95f7e
QT		 5581 if (!ha_locked)
5582 spin_lock_irqsave(&ha->hardware_lock, flags);
5583 switch (rc) {
5584 case -ENODEV:
5585 ql_dbg(ql_dbg_tgt, vha, 0xe05f,
5586 "qla_target: Unable to send command to target\n");
5587 break;
5588 case -EBADF:
5589 ql_dbg(ql_dbg_tgt, vha, 0xe05f,
5590 "qla_target: Unable to send command to target, sending TERM EXCHANGE for rsp\n");
82de802a
QT		 5591 qlt_send_term_exchange(ha->base_qpair, NULL,
5592 atio, 1, 0);
7cf95f7e
QT		 5593 break;
5594 case -EBUSY:
5595 ql_dbg(ql_dbg_tgt, vha, 0xe060,
5596 "qla_target(%d): Unable to send command to target, sending BUSY status\n",
5597 vha->vp_idx);
5598 qlt_send_busy(ha->base_qpair, atio,
5599 tc_sam_status);
5600 break;
5601 default:
5602 ql_dbg(ql_dbg_tgt, vha, 0xe060,
5603 "qla_target(%d): Unable to send command to target, sending BUSY status\n",
5604 vha->vp_idx);
5605 qlt_send_busy(ha->base_qpair, atio,
5606 qla_sam_status);
5607 break;
2d70c103 5608 }
7cf95f7e
QT		 5609 if (!ha_locked)
5610 spin_unlock_irqrestore(&ha->hardware_lock,
5611 flags);
2d70c103
NB		 5612 }
5613 break;
5614
5615 case IMMED_NOTIFY_TYPE:
5616 {
5617 if (unlikely(atio->u.isp2x.entry_status != 0)) {
5618 ql_dbg(ql_dbg_tgt, vha, 0xe05b,
5619 "qla_target(%d): Received ATIO packet %x "
5620 "with error status %x\n", vha->vp_idx,
5621 atio->u.raw.entry_type,
5622 atio->u.isp2x.entry_status);
5623 break;
5624 }
5625 ql_dbg(ql_dbg_tgt, vha, 0xe02e, "%s", "IMMED_NOTIFY ATIO");
2f424b9b
QT		 5626
5627 if (!ha_locked)
5628 spin_lock_irqsave(&ha->hardware_lock, flags);
2d70c103 5629 qlt_handle_imm_notify(vha, (struct imm_ntfy_from_isp *)atio);
2f424b9b
QT		 5630 if (!ha_locked)
5631 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2d70c103
NB		 5632 break;
5633 }
5634
5635 default:
5636 ql_dbg(ql_dbg_tgt, vha, 0xe05c,
5637 "qla_target(%d): Received unknown ATIO atio "
5638 "type %x\n", vha->vp_idx, atio->u.raw.entry_type);
5639 break;
5640 }
5641
2f424b9b 5642 tgt->atio_irq_cmd_count--;
2d70c103
NB		 5643}
5644
0691094f
QT		 5645/*
5646 * qpair lock is assume to be held
5647 * rc = 0 : send terminate & abts respond
5648 * rc != 0: do not send term & abts respond
5649 */
5650static int qlt_chk_unresolv_exchg(struct scsi_qla_host *vha,
5651 struct qla_qpair *qpair, struct abts_resp_from_24xx_fw *entry)
5652{
5653 struct qla_hw_data *ha = vha->hw;
5654 int rc = 0;
5655
5656 /*
5657 * Detect unresolved exchange. If the same ABTS is unable
5658 * to terminate an existing command and the same ABTS loops
5659 * between FW & Driver, then force FW dump. Under 1 jiff,
5660 * we should see multiple loops.
5661 */
5662 if (qpair->retry_term_exchg_addr == entry->exchange_addr_to_abort &&
5663 qpair->retry_term_jiff == jiffies) {
5664 /* found existing exchange */
5665 qpair->retry_term_cnt++;
5666 if (qpair->retry_term_cnt >= 5) {
5667 rc = EIO;
5668 qpair->retry_term_cnt = 0;
5669 ql_log(ql_log_warn, vha, 0xffff,
5670 "Unable to send ABTS Respond. Dumping firmware.\n");
5671 ql_dump_buffer(ql_dbg_tgt_mgt + ql_dbg_buffer,
5672 vha, 0xffff, (uint8_t *)entry, sizeof(*entry));
5673
5674 if (qpair == ha->base_qpair)
5675 ha->isp_ops->fw_dump(vha, 1);
5676 else
5677 ha->isp_ops->fw_dump(vha, 0);
5678
5679 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
5680 qla2xxx_wake_dpc(vha);
5681 }
5682 } else if (qpair->retry_term_jiff != jiffies) {
5683 qpair->retry_term_exchg_addr = entry->exchange_addr_to_abort;
5684 qpair->retry_term_cnt = 0;
5685 qpair->retry_term_jiff = jiffies;
5686 }
5687
5688 return rc;
5689}
5690
6b0431d6
QT		 5691
5692static void qlt_handle_abts_completion(struct scsi_qla_host *vha,
5693 struct rsp_que *rsp, response_t *pkt)
5694{
5695 struct abts_resp_from_24xx_fw *entry =
5696 (struct abts_resp_from_24xx_fw *)pkt;
5697 u32 h = pkt->handle & ~QLA_TGT_HANDLE_MASK;
5698 struct qla_tgt_mgmt_cmd *mcmd;
5699 struct qla_hw_data *ha = vha->hw;
5700
81bcf1c5 5701 mcmd = qlt_ctio_to_cmd(vha, rsp, pkt->handle, pkt);
6b0431d6
QT		 5702 if (mcmd == NULL && h != QLA_TGT_SKIP_HANDLE) {
5703 ql_dbg(ql_dbg_async, vha, 0xe064,
5704 "qla_target(%d): ABTS Comp without mcmd\n",
5705 vha->vp_idx);
5706 return;
5707 }
5708
5709 if (mcmd)
5710 vha = mcmd->vha;
5711 vha->vha_tgt.qla_tgt->abts_resp_expected--;
5712
5713 ql_dbg(ql_dbg_tgt, vha, 0xe038,
5714 "ABTS_RESP_24XX: compl_status %x\n",
5715 entry->compl_status);
5716
5717 if (le16_to_cpu(entry->compl_status) != ABTS_RESP_COMPL_SUCCESS) {
5718 if ((entry->error_subcode1 == 0x1E) &&
5719 (entry->error_subcode2 == 0)) {
5720 if (qlt_chk_unresolv_exchg(vha, rsp->qpair, entry)) {
5721 ha->tgt.tgt_ops->free_mcmd(mcmd);
5722 return;
5723 }
5724 qlt_24xx_retry_term_exchange(vha, rsp->qpair,
5725 pkt, mcmd);
5726 } else {
5727 ql_dbg(ql_dbg_tgt, vha, 0xe063,
5728 "qla_target(%d): ABTS_RESP_24XX failed %x (subcode %x:%x)",
5729 vha->vp_idx, entry->compl_status,
5730 entry->error_subcode1,
5731 entry->error_subcode2);
5732 ha->tgt.tgt_ops->free_mcmd(mcmd);
5733 }
5734 } else {
5735 ha->tgt.tgt_ops->free_mcmd(mcmd);
5736 }
5737}
5738
2d70c103
NB		 5739/* ha->hardware_lock supposed to be held on entry */
5740/* called via callback from qla2xxx */
82de802a
QT		 5741static void qlt_response_pkt(struct scsi_qla_host *vha,
5742 struct rsp_que *rsp, response_t *pkt)
2d70c103 5743{
0e8cd71c 5744 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
2d70c103
NB		 5745
5746 if (unlikely(tgt == NULL)) {
5747 ql_dbg(ql_dbg_tgt, vha, 0xe05d,
60a9eadb
QT		 5748 "qla_target(%d): Response pkt %x received, but no tgt (ha %p)\n",
5749 vha->vp_idx, pkt->entry_type, vha->hw);
2d70c103
NB		 5750 return;
5751 }
5752
2d70c103
NB		 5753 /*
5754 * In tgt_stop mode we also should allow all requests to pass.
5755 * Otherwise, some commands can stuck.
5756 */
5757
2d70c103 5758 switch (pkt->entry_type) {
f83adb61 5759 case CTIO_CRC2:
2d70c103
NB		 5760 case CTIO_TYPE7:
5761 {
5762 struct ctio7_from_24xx *entry = (struct ctio7_from_24xx *)pkt;
bd432bb5 5763
82de802a 5764 qlt_do_ctio_completion(vha, rsp, entry->handle,
2d70c103
NB		 5765 le16_to_cpu(entry->status)|(pkt->entry_status << 16),
5766 entry);
5767 break;
5768 }
5769
5770 case ACCEPT_TGT_IO_TYPE:
5771 {
5772 struct atio_from_isp *atio = (struct atio_from_isp *)pkt;
5773 int rc;
bd432bb5 5774
2d70c103 5775 if (atio->u.isp2x.status !=
ad950360 5776 cpu_to_le16(ATIO_CDB_VALID)) {
2d70c103
NB		 5777 ql_dbg(ql_dbg_tgt, vha, 0xe05e,
5778 "qla_target(%d): ATIO with error "
5779 "status %x received\n", vha->vp_idx,
5780 le16_to_cpu(atio->u.isp2x.status));
5781 break;
5782 }
2d70c103 5783
82de802a 5784 rc = qlt_chk_qfull_thresh_hold(vha, rsp->qpair, atio, 1);
ba68a635 5785 if (rc != 0)
33e79977 5786 return;
33e79977 5787
2d70c103
NB		 5788 rc = qlt_handle_cmd_for_atio(vha, atio);
5789 if (unlikely(rc != 0)) {
7cf95f7e
QT		 5790 switch (rc) {
5791 case -ENODEV:
5792 ql_dbg(ql_dbg_tgt, vha, 0xe05f,
5793 "qla_target: Unable to send command to target\n");
5794 break;
5795 case -EBADF:
5796 ql_dbg(ql_dbg_tgt, vha, 0xe05f,
5797 "qla_target: Unable to send command to target, sending TERM EXCHANGE for rsp\n");
5798 qlt_send_term_exchange(rsp->qpair, NULL,
5799 atio, 1, 0);
5800 break;
5801 case -EBUSY:
5802 ql_dbg(ql_dbg_tgt, vha, 0xe060,
5803 "qla_target(%d): Unable to send command to target, sending BUSY status\n",
5804 vha->vp_idx);
5805 qlt_send_busy(rsp->qpair, atio,
5806 tc_sam_status);
5807 break;
5808 default:
5809 ql_dbg(ql_dbg_tgt, vha, 0xe060,
5810 "qla_target(%d): Unable to send command to target, sending BUSY status\n",
5811 vha->vp_idx);
5812 qlt_send_busy(rsp->qpair, atio,
5813 qla_sam_status);
5814 break;
2d70c103
NB		 5815 }
5816 }
5817 }
5818 break;
5819
5820 case CONTINUE_TGT_IO_TYPE:
5821 {
5822 struct ctio_to_2xxx *entry = (struct ctio_to_2xxx *)pkt;
bd432bb5 5823
82de802a 5824 qlt_do_ctio_completion(vha, rsp, entry->handle,
2d70c103
NB		 5825 le16_to_cpu(entry->status)|(pkt->entry_status << 16),
5826 entry);
5827 break;
5828 }
5829
5830 case CTIO_A64_TYPE:
5831 {
5832 struct ctio_to_2xxx *entry = (struct ctio_to_2xxx *)pkt;
bd432bb5 5833
82de802a 5834 qlt_do_ctio_completion(vha, rsp, entry->handle,
2d70c103
NB		 5835 le16_to_cpu(entry->status)|(pkt->entry_status << 16),
5836 entry);
5837 break;
5838 }
5839
5840 case IMMED_NOTIFY_TYPE:
5841 ql_dbg(ql_dbg_tgt, vha, 0xe035, "%s", "IMMED_NOTIFY\n");
5842 qlt_handle_imm_notify(vha, (struct imm_ntfy_from_isp *)pkt);
5843 break;
5844
5845 case NOTIFY_ACK_TYPE:
5846 if (tgt->notify_ack_expected > 0) {
5847 struct nack_to_isp *entry = (struct nack_to_isp *)pkt;
bd432bb5 5848
2d70c103
NB		 5849 ql_dbg(ql_dbg_tgt, vha, 0xe036,
5850 "NOTIFY_ACK seq %08x status %x\n",
5851 le16_to_cpu(entry->u.isp2x.seq_id),
5852 le16_to_cpu(entry->u.isp2x.status));
5853 tgt->notify_ack_expected--;
5854 if (entry->u.isp2x.status !=
ad950360 5855 cpu_to_le16(NOTIFY_ACK_SUCCESS)) {
2d70c103
NB		 5856 ql_dbg(ql_dbg_tgt, vha, 0xe061,
5857 "qla_target(%d): NOTIFY_ACK "
5858 "failed %x\n", vha->vp_idx,
5859 le16_to_cpu(entry->u.isp2x.status));
5860 }
5861 } else {
5862 ql_dbg(ql_dbg_tgt, vha, 0xe062,
5863 "qla_target(%d): Unexpected NOTIFY_ACK received\n",
5864 vha->vp_idx);
5865 }
5866 break;
5867
5868 case ABTS_RECV_24XX:
5869 ql_dbg(ql_dbg_tgt, vha, 0xe037,
5870 "ABTS_RECV_24XX: instance %d\n", vha->vp_idx);
5871 qlt_24xx_handle_abts(vha, (struct abts_recv_from_24xx *)pkt);
5872 break;
5873
5874 case ABTS_RESP_24XX:
5875 if (tgt->abts_resp_expected > 0) {
6b0431d6 5876 qlt_handle_abts_completion(vha, rsp, pkt);
2d70c103
NB		 5877 } else {
5878 ql_dbg(ql_dbg_tgt, vha, 0xe064,
5879 "qla_target(%d): Unexpected ABTS_RESP_24XX "
5880 "received\n", vha->vp_idx);
5881 }
5882 break;
5883
5884 default:
5885 ql_dbg(ql_dbg_tgt, vha, 0xe065,
5886 "qla_target(%d): Received unknown response pkt "
5887 "type %x\n", vha->vp_idx, pkt->entry_type);
5888 break;
5889 }
5890
2d70c103
NB		 5891}
5892
5893/*
5894 * ha->hardware_lock supposed to be held on entry. Might drop it, then reaquire
5895 */
5896void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
5897 uint16_t *mailbox)
5898{
5899 struct qla_hw_data *ha = vha->hw;
0e8cd71c 5900 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
4f1d0f19 5901 int login_code;
2d70c103 5902
3a33dc95 5903 if (!tgt || tgt->tgt_stop || tgt->tgt_stopped)
2d70c103
NB		 5904 return;
5905
2d70c103
NB		 5906 if (((code == MBA_POINT_TO_POINT) || (code == MBA_CHG_IN_CONNECTION)) &&
5907 IS_QLA2100(ha))
5908 return;
5909 /*
5910 * In tgt_stop mode we also should allow all requests to pass.
5911 * Otherwise, some commands can stuck.
5912 */
5913
2d70c103
NB		 5914
5915 switch (code) {
5916 case MBA_RESET: /* Reset */
5917 case MBA_SYSTEM_ERR: /* System Error */
5918 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
5919 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
5920 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03a,
5921 "qla_target(%d): System error async event %#x "
6efb3c0a 5922 "occurred", vha->vp_idx, code);
2d70c103
NB		 5923 break;
5924 case MBA_WAKEUP_THRES: /* Request Queue Wake-up. */
5925 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
5926 break;
5927
5928 case MBA_LOOP_UP:
5929 {
5930 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03b,
6efb3c0a 5931 "qla_target(%d): Async LOOP_UP occurred "
4f1d0f19
AC		 5932 "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx,
5933 le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
5934 le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
2d70c103 5935 if (tgt->link_reinit_iocb_pending) {
82de802a
QT		 5936 qlt_send_notify_ack(ha->base_qpair,
5937 (void *)&tgt->link_reinit_iocb,
2d70c103
NB		 5938 0, 0, 0, 0, 0, 0);
5939 tgt->link_reinit_iocb_pending = 0;
5940 }
5941 break;
5942 }
5943
5944 case MBA_LIP_OCCURRED:
5945 case MBA_LOOP_DOWN:
5946 case MBA_LIP_RESET:
5947 case MBA_RSCN_UPDATE:
5948 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03c,
6efb3c0a 5949 "qla_target(%d): Async event %#x occurred "
4f1d0f19
AC		 5950 "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx, code,
5951 le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
5952 le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
2d70c103
NB		 5953 break;
5954
ead03855 5955 case MBA_REJECTED_FCP_CMD:
83548fe2
QT		 5956 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf017,
5957 "qla_target(%d): Async event LS_REJECT occurred (m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)",
5958 vha->vp_idx,
5959 le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
5960 le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
ead03855
QT		 5961
5962 if (le16_to_cpu(mailbox[3]) == 1) {
5963 /* exchange starvation. */
5964 vha->hw->exch_starvation++;
5965 if (vha->hw->exch_starvation > 5) {
83548fe2 5966 ql_log(ql_log_warn, vha, 0xd03a,
ead03855
QT		 5967 "Exchange starvation-. Resetting RISC\n");
5968
5969 vha->hw->exch_starvation = 0;
5970 if (IS_P3P_TYPE(vha->hw))
5971 set_bit(FCOE_CTX_RESET_NEEDED,
5972 &vha->dpc_flags);
5973 else
5974 set_bit(ISP_ABORT_NEEDED,
5975 &vha->dpc_flags);
5976 qla2xxx_wake_dpc(vha);
5977 }
5978 }
5979 break;
5980
2d70c103
NB		 5981 case MBA_PORT_UPDATE:
5982 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03d,
5983 "qla_target(%d): Port update async event %#x "
6efb3c0a 5984 "occurred: updating the ports database (m[0]=%x, m[1]=%x, "
4f1d0f19
AC		 5985 "m[2]=%x, m[3]=%x)", vha->vp_idx, code,
5986 le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
5987 le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
5988
5989 login_code = le16_to_cpu(mailbox[2]);
ead03855 5990 if (login_code == 0x4) {
2d70c103
NB		 5991 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03e,
5992 "Async MB 2: Got PLOGI Complete\n");
ead03855
QT		 5993 vha->hw->exch_starvation = 0;
5994 } else if (login_code == 0x7)
2d70c103
NB		 5995 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03f,
5996 "Async MB 2: Port Logged Out\n");
5997 break;
2d70c103 5998 default:
2d70c103
NB		 5999 break;
6000 }
6001
2d70c103
NB		 6002}
6003
6004static fc_port_t *qlt_get_port_database(struct scsi_qla_host *vha,
6005 uint16_t loop_id)
6006{
726b8548 6007 fc_port_t *fcport, *tfcp, *del;
2d70c103 6008 int rc;
726b8548
QT		 6009 unsigned long flags;
6010 u8 newfcport = 0;
2d70c103 6011
063b36d6 6012 fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
2d70c103
NB		 6013 if (!fcport) {
6014 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf06f,
6015 "qla_target(%d): Allocation of tmp FC port failed",
6016 vha->vp_idx);
6017 return NULL;
6018 }
6019
2d70c103
NB		 6020 fcport->loop_id = loop_id;
6021
15f30a57 6022 rc = qla24xx_gpdb_wait(vha, fcport, 0);
2d70c103
NB		 6023 if (rc != QLA_SUCCESS) {
6024 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf070,
6025 "qla_target(%d): Failed to retrieve fcport "
6026 "information -- get_port_database() returned %x "
6027 "(loop_id=0x%04x)", vha->vp_idx, rc, loop_id);
6028 kfree(fcport);
6029 return NULL;
6030 }
6031
726b8548
QT		 6032 del = NULL;
6033 spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
6034 tfcp = qla2x00_find_fcport_by_wwpn(vha, fcport->port_name, 1);
6035
6036 if (tfcp) {
6037 tfcp->d_id = fcport->d_id;
6038 tfcp->port_type = fcport->port_type;
6039 tfcp->supported_classes = fcport->supported_classes;
6040 tfcp->flags |= fcport->flags;
76f9a2dd 6041 tfcp->scan_state = QLA_FCPORT_FOUND;
726b8548
QT		 6042
6043 del = fcport;
6044 fcport = tfcp;
6045 } else {
6046 if (vha->hw->current_topology == ISP_CFG_F)
6047 fcport->flags |= FCF_FABRIC_DEVICE;
6048
6049 list_add_tail(&fcport->list, &vha->vp_fcports);
6050 if (!IS_SW_RESV_ADDR(fcport->d_id))
6051 vha->fcport_count++;
6052 fcport->login_gen++;
6053 fcport->disc_state = DSC_LOGIN_COMPLETE;
6054 fcport->login_succ = 1;
6055 newfcport = 1;
6056 }
6057
6058 fcport->deleted = 0;
6059 spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
6060
6061 switch (vha->host->active_mode) {
6062 case MODE_INITIATOR:
6063 case MODE_DUAL:
6064 if (newfcport) {
6065 if (!IS_IIDMA_CAPABLE(vha->hw) || !vha->hw->flags.gpsc_supported) {
cd4ed6b4 6066 qla24xx_sched_upd_fcport(fcport);
726b8548 6067 } else {
83548fe2 6068 ql_dbg(ql_dbg_disc, vha, 0x20ff,
726b8548
QT		 6069 "%s %d %8phC post gpsc fcp_cnt %d\n",
6070 __func__, __LINE__, fcport->port_name, vha->fcport_count);
6071 qla24xx_post_gpsc_work(vha, fcport);
6072 }
6073 }
6074 break;
6075
6076 case MODE_TARGET:
6077 default:
6078 break;
6079 }
6080 if (del)
6081 qla2x00_free_fcport(del);
6082
2d70c103
NB		 6083 return fcport;
6084}
6085
6086/* Must be called under tgt_mutex */
5d964837 6087static struct fc_port *qlt_make_local_sess(struct scsi_qla_host *vha,
df95f39a 6088 be_id_t s_id)
2d70c103 6089{
5d964837 6090 struct fc_port *sess = NULL;
2d70c103
NB		 6091 fc_port_t *fcport = NULL;
6092 int rc, global_resets;
6093 uint16_t loop_id = 0;
6094
df95f39a 6095 if (s_id.domain == 0xFF && s_id.area == 0xFC) {
726b8548
QT		 6096 /*
6097 * This is Domain Controller, so it should be
6098 * OK to drop SCSI commands from it.
6099 */
6100 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf042,
6101 "Unable to find initiator with S_ID %x:%x:%x",
df95f39a 6102 s_id.domain, s_id.area, s_id.al_pa);
726b8548
QT		 6103 return NULL;
6104 }
6105
71cdc079
AP		 6106 mutex_lock(&vha->vha_tgt.tgt_mutex);
6107
2d70c103 6108retry:
0e8cd71c
SK		 6109 global_resets =
6110 atomic_read(&vha->vha_tgt.qla_tgt->tgt_global_resets_count);
2d70c103
NB		 6111
6112 rc = qla24xx_get_loop_id(vha, s_id, &loop_id);
6113 if (rc != 0) {
71cdc079
AP		 6114 mutex_unlock(&vha->vha_tgt.tgt_mutex);
6115
726b8548
QT		 6116 ql_log(ql_log_info, vha, 0xf071,
6117 "qla_target(%d): Unable to find "
6118 "initiator with S_ID %x:%x:%x",
df95f39a 6119 vha->vp_idx, s_id.domain, s_id.area, s_id.al_pa);
71cdc079
AP		 6120
6121 if (rc == -ENOENT) {
6122 qlt_port_logo_t logo;
bd432bb5 6123
df95f39a 6124 logo.id = be_to_port_id(s_id);
71cdc079
AP		 6125 logo.cmd_count = 1;
6126 qlt_send_first_logo(vha, &logo);
6127 }
6128
2d70c103
NB		 6129 return NULL;
6130 }
6131
6132 fcport = qlt_get_port_database(vha, loop_id);
71cdc079
AP		 6133 if (!fcport) {
6134 mutex_unlock(&vha->vha_tgt.tgt_mutex);
2d70c103 6135 return NULL;
71cdc079 6136 }
2d70c103
NB		 6137
6138 if (global_resets !=
0e8cd71c 6139 atomic_read(&vha->vha_tgt.qla_tgt->tgt_global_resets_count)) {
2d70c103
NB		 6140 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf043,
6141 "qla_target(%d): global reset during session discovery "
6142 "(counter was %d, new %d), retrying", vha->vp_idx,
6143 global_resets,
0e8cd71c
SK		 6144 atomic_read(&vha->vha_tgt.
6145 qla_tgt->tgt_global_resets_count));
2d70c103
NB		 6146 goto retry;
6147 }
6148
6149 sess = qlt_create_sess(vha, fcport, true);
6150
71cdc079
AP		 6151 mutex_unlock(&vha->vha_tgt.tgt_mutex);
6152
2d70c103
NB		 6153 return sess;
6154}
6155
6156static void qlt_abort_work(struct qla_tgt *tgt,
6157 struct qla_tgt_sess_work_param *prm)
6158{
6159 struct scsi_qla_host *vha = tgt->vha;
6160 struct qla_hw_data *ha = vha->hw;
5d964837 6161 struct fc_port *sess = NULL;
7560151b 6162 unsigned long flags = 0, flags2 = 0;
df95f39a 6163 be_id_t s_id;
2d70c103
NB		 6164 int rc;
6165
7560151b 6166 spin_lock_irqsave(&ha->tgt.sess_lock, flags2);
2d70c103
NB		 6167
6168 if (tgt->tgt_stop)
7560151b 6169 goto out_term2;
2d70c103 6170
df95f39a 6171 s_id = le_id_to_be(prm->abts.fcp_hdr_le.s_id);
2d70c103 6172
ac452b8e 6173 sess = ha->tgt.tgt_ops->find_sess_by_s_id(vha, s_id);
2d70c103 6174 if (!sess) {
7560151b 6175 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags2);
2d70c103 6176
2d70c103
NB		 6177 sess = qlt_make_local_sess(vha, s_id);
6178 /* sess has got an extra creation ref */
2d70c103 6179
7560151b 6180 spin_lock_irqsave(&ha->tgt.sess_lock, flags2);
2d70c103 6181 if (!sess)
7560151b 6182 goto out_term2;
2d70c103 6183 } else {
726b8548 6184 if (sess->deleted) {
e52a8b45 6185 sess = NULL;
7560151b 6186 goto out_term2;
e52a8b45
AP		 6187 }
6188
726b8548 6189 if (!kref_get_unless_zero(&sess->sess_kref)) {
83548fe2 6190 ql_dbg(ql_dbg_tgt_tmr, vha, 0xf01c,
726b8548
QT		 6191 "%s: kref_get fail %8phC \n",
6192 __func__, sess->port_name);
6193 sess = NULL;
6194 goto out_term2;
6195 }
2d70c103
NB		 6196 }
6197
2d70c103 6198 rc = __qlt_24xx_handle_abts(vha, &prm->abts, sess);
f159b3c7
QT		 6199 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags2);
6200
300ec741
BVA		 6201 ha->tgt.tgt_ops->put_sess(sess);
6202
2d70c103
NB		 6203 if (rc != 0)
6204 goto out_term;
2d70c103
NB		 6205 return;
6206
7560151b 6207out_term2:
300ec741
BVA		 6208 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags2);
6209
2d70c103 6210out_term:
f159b3c7 6211 spin_lock_irqsave(&ha->hardware_lock, flags);
82de802a
QT		 6212 qlt_24xx_send_abts_resp(ha->base_qpair, &prm->abts,
6213 FCP_TMF_REJECTED, false);
7560151b 6214 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2d70c103
NB		 6215}
6216
6217static void qlt_tmr_work(struct qla_tgt *tgt,
6218 struct qla_tgt_sess_work_param *prm)
6219{
6220 struct atio_from_isp *a = &prm->tm_iocb2;
6221 struct scsi_qla_host *vha = tgt->vha;
6222 struct qla_hw_data *ha = vha->hw;
bb6abdd4 6223 struct fc_port *sess;
2d70c103 6224 unsigned long flags;
df95f39a 6225 be_id_t s_id;
2d70c103 6226 int rc;
f775bd14 6227 u64 unpacked_lun;
52c82823 6228 int fn;
2d70c103
NB		 6229 void *iocb;
6230
7560151b 6231 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
2d70c103
NB		 6232
6233 if (tgt->tgt_stop)
f159b3c7 6234 goto out_term2;
2d70c103
NB		 6235
6236 s_id = prm->tm_iocb2.u.isp24.fcp_hdr.s_id;
6237 sess = ha->tgt.tgt_ops->find_sess_by_s_id(vha, s_id);
6238 if (!sess) {
7560151b 6239 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2d70c103 6240
2d70c103
NB		 6241 sess = qlt_make_local_sess(vha, s_id);
6242 /* sess has got an extra creation ref */
2d70c103 6243
7560151b 6244 spin_lock_irqsave(&ha->tgt.sess_lock, flags);
2d70c103 6245 if (!sess)
f159b3c7 6246 goto out_term2;
2d70c103 6247 } else {
726b8548 6248 if (sess->deleted) {
f159b3c7 6249 goto out_term2;
e52a8b45
AP		 6250 }
6251
726b8548 6252 if (!kref_get_unless_zero(&sess->sess_kref)) {
83548fe2 6253 ql_dbg(ql_dbg_tgt_tmr, vha, 0xf020,
726b8548
QT		 6254 "%s: kref_get fail %8phC\n",
6255 __func__, sess->port_name);
f159b3c7 6256 goto out_term2;
726b8548 6257 }
2d70c103
NB		 6258 }
6259
6260 iocb = a;
2d70c103 6261 fn = a->u.isp24.fcp_cmnd.task_mgmt_flags;
f775bd14
QT		 6262 unpacked_lun =
6263 scsilun_to_int((struct scsi_lun *)&a->u.isp24.fcp_cmnd.lun);
2d70c103
NB		 6264
6265 rc = qlt_issue_task_mgmt(sess, unpacked_lun, fn, iocb, 0);
7560151b 6266 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
f159b3c7 6267
300ec741
BVA		 6268 ha->tgt.tgt_ops->put_sess(sess);
6269
f159b3c7
QT		 6270 if (rc != 0)
6271 goto out_term;
2d70c103
NB		 6272 return;
6273
f159b3c7 6274out_term2:
f159b3c7 6275 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);
2d70c103 6276out_term:
82de802a 6277 qlt_send_term_exchange(ha->base_qpair, NULL, &prm->tm_iocb2, 1, 0);
2d70c103
NB		 6278}
6279
6280static void qlt_sess_work_fn(struct work_struct *work)
6281{
6282 struct qla_tgt *tgt = container_of(work, struct qla_tgt, sess_work);
6283 struct scsi_qla_host *vha = tgt->vha;
6284 unsigned long flags;
6285
6286 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf000, "Sess work (tgt %p)", tgt);
6287
6288 spin_lock_irqsave(&tgt->sess_work_lock, flags);
6289 while (!list_empty(&tgt->sess_works_list)) {
6290 struct qla_tgt_sess_work_param *prm = list_entry(
6291 tgt->sess_works_list.next, typeof(*prm),
6292 sess_works_list_entry);
6293
6294 /*
6295 * This work can be scheduled on several CPUs at time, so we
6296 * must delete the entry to eliminate double processing
6297 */
6298 list_del(&prm->sess_works_list_entry);
6299
6300 spin_unlock_irqrestore(&tgt->sess_work_lock, flags);
6301
6302 switch (prm->type) {
6303 case QLA_TGT_SESS_WORK_ABORT:
6304 qlt_abort_work(tgt, prm);
6305 break;
6306 case QLA_TGT_SESS_WORK_TM:
6307 qlt_tmr_work(tgt, prm);
6308 break;
6309 default:
6310 BUG_ON(1);
6311 break;
6312 }
6313
6314 spin_lock_irqsave(&tgt->sess_work_lock, flags);
6315
6316 kfree(prm);
6317 }
6318 spin_unlock_irqrestore(&tgt->sess_work_lock, flags);
6319}
6320
6321/* Must be called under tgt_host_action_mutex */
6322int qlt_add_target(struct qla_hw_data *ha, struct scsi_qla_host *base_vha)
6323{
6324 struct qla_tgt *tgt;
e326d22a
QT		 6325 int rc, i;
6326 struct qla_qpair_hint *h;
2d70c103
NB		 6327
6328 if (!QLA_TGT_MODE_ENABLED())
6329 return 0;
6330
33c36c0a
AE		 6331 if (!IS_TGT_MODE_CAPABLE(ha)) {
6332 ql_log(ql_log_warn, base_vha, 0xe070,
6333 "This adapter does not support target mode.\n");
6334 return 0;
6335 }
6336
2d70c103 6337 ql_dbg(ql_dbg_tgt, base_vha, 0xe03b,
0e8cd71c 6338 "Registering target for host %ld(%p).\n", base_vha->host_no, ha);
2d70c103 6339
0e8cd71c 6340 BUG_ON(base_vha->vha_tgt.qla_tgt != NULL);
2d70c103
NB		 6341
6342 tgt = kzalloc(sizeof(struct qla_tgt), GFP_KERNEL);
6343 if (!tgt) {
6344 ql_dbg(ql_dbg_tgt, base_vha, 0xe066,
6345 "Unable to allocate struct qla_tgt\n");
6346 return -ENOMEM;
6347 }
6348
6396bb22
KC		 6349 tgt->qphints = kcalloc(ha->max_qpairs + 1,
6350 sizeof(struct qla_qpair_hint),
6351 GFP_KERNEL);
e326d22a
QT		 6352 if (!tgt->qphints) {
6353 kfree(tgt);
6354 ql_log(ql_log_warn, base_vha, 0x0197,
6355 "Unable to allocate qpair hints.\n");
6356 return -ENOMEM;
6357 }
6358
2d70c103
NB		 6359 if (!(base_vha->host->hostt->supported_mode & MODE_TARGET))
6360 base_vha->host->hostt->supported_mode |= MODE_TARGET;
6361
e326d22a
QT		 6362 rc = btree_init64(&tgt->lun_qpair_map);
6363 if (rc) {
6364 kfree(tgt->qphints);
6365 kfree(tgt);
6366 ql_log(ql_log_info, base_vha, 0x0198,
6367 "Unable to initialize lun_qpair_map btree\n");
6368 return -EIO;
6369 }
6370 h = &tgt->qphints[0];
6371 h->qpair = ha->base_qpair;
6372 INIT_LIST_HEAD(&h->hint_elem);
6373 h->cpuid = ha->base_qpair->cpuid;
6374 list_add_tail(&h->hint_elem, &ha->base_qpair->hints_list);
6375
6376 for (i = 0; i < ha->max_qpairs; i++) {
6377 unsigned long flags;
6378
6379 struct qla_qpair *qpair = ha->queue_pair_map[i];
bd432bb5 6380
e326d22a
QT		 6381 h = &tgt->qphints[i + 1];
6382 INIT_LIST_HEAD(&h->hint_elem);
6383 if (qpair) {
6384 h->qpair = qpair;
6385 spin_lock_irqsave(qpair->qp_lock_ptr, flags);
6386 list_add_tail(&h->hint_elem, &qpair->hints_list);
6387 spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
6388 h->cpuid = qpair->cpuid;
6389 }
6390 }
6391
2d70c103
NB		 6392 tgt->ha = ha;
6393 tgt->vha = base_vha;
6394 init_waitqueue_head(&tgt->waitQ);
2d70c103 6395 INIT_LIST_HEAD(&tgt->del_sess_list);
2d70c103
NB		 6396 spin_lock_init(&tgt->sess_work_lock);
6397 INIT_WORK(&tgt->sess_work, qlt_sess_work_fn);
6398 INIT_LIST_HEAD(&tgt->sess_works_list);
2d70c103
NB		 6399 atomic_set(&tgt->tgt_global_resets_count, 0);
6400
0e8cd71c 6401 base_vha->vha_tgt.qla_tgt = tgt;
2d70c103
NB		 6402
6403 ql_dbg(ql_dbg_tgt, base_vha, 0xe067,
6404 "qla_target(%d): using 64 Bit PCI addressing",
6405 base_vha->vp_idx);
2d70c103
NB		 6406 /* 3 is reserved */
6407 tgt->sg_tablesize = QLA_TGT_MAX_SG_24XX(base_vha->req->length - 3);
2d70c103
NB		 6408
6409 mutex_lock(&qla_tgt_mutex);
6410 list_add_tail(&tgt->tgt_list_entry, &qla_tgt_glist);
6411 mutex_unlock(&qla_tgt_mutex);
6412
f1443eeb
QT		 6413 if (ha->tgt.tgt_ops && ha->tgt.tgt_ops->add_target)
6414 ha->tgt.tgt_ops->add_target(base_vha);
6415
2d70c103
NB		 6416 return 0;
6417}
6418
6419/* Must be called under tgt_host_action_mutex */
6420int qlt_remove_target(struct qla_hw_data *ha, struct scsi_qla_host *vha)
6421{
0e8cd71c 6422 if (!vha->vha_tgt.qla_tgt)
2d70c103
NB		 6423 return 0;
6424
ddb95145
NB		 6425 if (vha->fc_vport) {
6426 qlt_release(vha->vha_tgt.qla_tgt);
6427 return 0;
6428 }
33e79977
QT		 6429
6430 /* free left over qfull cmds */
6431 qlt_init_term_exchange(vha);
6432
2d70c103
NB		 6433 ql_dbg(ql_dbg_tgt, vha, 0xe03c, "Unregistering target for host %ld(%p)",
6434 vha->host_no, ha);
0e8cd71c 6435 qlt_release(vha->vha_tgt.qla_tgt);
2d70c103
NB		 6436
6437 return 0;
6438}
6439
482c9dc7
QT		 6440void qlt_remove_target_resources(struct qla_hw_data *ha)
6441{
6442 struct scsi_qla_host *node;
6443 u32 key = 0;
6444
6445 btree_for_each_safe32(&ha->tgt.host_map, key, node)
6446 btree_remove32(&ha->tgt.host_map, key);
6447
6448 btree_destroy32(&ha->tgt.host_map);
6449}
6450
2d70c103
NB		 6451static void qlt_lport_dump(struct scsi_qla_host *vha, u64 wwpn,
6452 unsigned char *b)
6453{
09434912
BVA		 6454 pr_debug("qla2xxx HW vha->node_name: %8phC\n", vha->node_name);
6455 pr_debug("qla2xxx HW vha->port_name: %8phC\n", vha->port_name);
2d70c103 6456 put_unaligned_be64(wwpn, b);
09434912 6457 pr_debug("qla2xxx passed configfs WWPN: %8phC\n", b);
2d70c103
NB		 6458}
6459
6460/**
6461 * qla_tgt_lport_register - register lport with external module
6462 *
2d70c103 6463 * @target_lport_ptr: pointer for tcm_qla2xxx specific lport data
807eb907
BVA		 6464 * @phys_wwpn: physical port WWPN
6465 * @npiv_wwpn: NPIV WWPN
6466 * @npiv_wwnn: NPIV WWNN
2db6228d 6467 * @callback: lport initialization callback for tcm_qla2xxx code
2d70c103 6468 */
49a47f2c
NB		 6469int qlt_lport_register(void *target_lport_ptr, u64 phys_wwpn,
6470 u64 npiv_wwpn, u64 npiv_wwnn,
6471 int (*callback)(struct scsi_qla_host *, void *, u64, u64))
2d70c103
NB		 6472{
6473 struct qla_tgt *tgt;
6474 struct scsi_qla_host *vha;
6475 struct qla_hw_data *ha;
6476 struct Scsi_Host *host;
6477 unsigned long flags;
6478 int rc;
6479 u8 b[WWN_SIZE];
6480
6481 mutex_lock(&qla_tgt_mutex);
6482 list_for_each_entry(tgt, &qla_tgt_glist, tgt_list_entry) {
6483 vha = tgt->vha;
6484 ha = vha->hw;
6485
6486 host = vha->host;
6487 if (!host)
6488 continue;
6489
2d70c103
NB		 6490 if (!(host->hostt->supported_mode & MODE_TARGET))
6491 continue;
6492
0645cb83
QT		 6493 if (vha->qlini_mode == QLA2XXX_INI_MODE_ENABLED)
6494 continue;
6495
2d70c103 6496 spin_lock_irqsave(&ha->hardware_lock, flags);
49a47f2c 6497 if ((!npiv_wwpn || !npiv_wwnn) && host->active_mode & MODE_TARGET) {
2d70c103
NB		 6498 pr_debug("MODE_TARGET already active on qla2xxx(%d)\n",
6499 host->host_no);
6500 spin_unlock_irqrestore(&ha->hardware_lock, flags);
6501 continue;
6502 }
ddb95145
NB		 6503 if (tgt->tgt_stop) {
6504 pr_debug("MODE_TARGET in shutdown on qla2xxx(%d)\n",
6505 host->host_no);
6506 spin_unlock_irqrestore(&ha->hardware_lock, flags);
6507 continue;
6508 }
2d70c103
NB		 6509 spin_unlock_irqrestore(&ha->hardware_lock, flags);
6510
6511 if (!scsi_host_get(host)) {
6512 ql_dbg(ql_dbg_tgt, vha, 0xe068,
6513 "Unable to scsi_host_get() for"
6514 " qla2xxx scsi_host\n");
6515 continue;
6516 }
49a47f2c 6517 qlt_lport_dump(vha, phys_wwpn, b);
2d70c103
NB		 6518
6519 if (memcmp(vha->port_name, b, WWN_SIZE)) {
6520 scsi_host_put(host);
6521 continue;
6522 }
49a47f2c
NB		 6523 rc = (*callback)(vha, target_lport_ptr, npiv_wwpn, npiv_wwnn);
6524 if (rc != 0)
6525 scsi_host_put(host);
6526
ddb95145 6527 mutex_unlock(&qla_tgt_mutex);
2d70c103
NB		 6528 return rc;
6529 }
6530 mutex_unlock(&qla_tgt_mutex);
6531
6532 return -ENODEV;
6533}
6534EXPORT_SYMBOL(qlt_lport_register);
6535
6536/**
6537 * qla_tgt_lport_deregister - Degister lport
6538 *
6539 * @vha: Registered scsi_qla_host pointer
6540 */
6541void qlt_lport_deregister(struct scsi_qla_host *vha)
6542{
6543 struct qla_hw_data *ha = vha->hw;
6544 struct Scsi_Host *sh = vha->host;
6545 /*
6546 * Clear the target_lport_ptr qla_target_template pointer in qla_hw_data
6547 */
0e8cd71c 6548 vha->vha_tgt.target_lport_ptr = NULL;
2d70c103
NB		 6549 ha->tgt.tgt_ops = NULL;
6550 /*
6551 * Release the Scsi_Host reference for the underlying qla2xxx host
6552 */
6553 scsi_host_put(sh);
6554}
6555EXPORT_SYMBOL(qlt_lport_deregister);
6556
6557/* Must be called under HW lock */
0645cb83 6558void qlt_set_mode(struct scsi_qla_host *vha)
2d70c103 6559{
0645cb83 6560 switch (vha->qlini_mode) {
2d70c103
NB		 6561 case QLA2XXX_INI_MODE_DISABLED:
6562 case QLA2XXX_INI_MODE_EXCLUSIVE:
6563 vha->host->active_mode = MODE_TARGET;
6564 break;
6565 case QLA2XXX_INI_MODE_ENABLED:
0645cb83 6566 vha->host->active_mode = MODE_INITIATOR;
ead03855
QT		 6567 break;
6568 case QLA2XXX_INI_MODE_DUAL:
6569 vha->host->active_mode = MODE_DUAL;
2d70c103
NB		 6570 break;
6571 default:
6572 break;
6573 }
2d70c103
NB		 6574}
6575
6576/* Must be called under HW lock */
55a9066f 6577static void qlt_clear_mode(struct scsi_qla_host *vha)
2d70c103 6578{
0645cb83 6579 switch (vha->qlini_mode) {
2d70c103
NB		 6580 case QLA2XXX_INI_MODE_DISABLED:
6581 vha->host->active_mode = MODE_UNKNOWN;
6582 break;
6583 case QLA2XXX_INI_MODE_EXCLUSIVE:
6584 vha->host->active_mode = MODE_INITIATOR;
6585 break;
6586 case QLA2XXX_INI_MODE_ENABLED:
ead03855
QT		 6587 case QLA2XXX_INI_MODE_DUAL:
6588 vha->host->active_mode = MODE_INITIATOR;
2d70c103
NB		 6589 break;
6590 default:
6591 break;
6592 }
2d70c103
NB		 6593}
6594
6595/*
6596 * qla_tgt_enable_vha - NO LOCK HELD
6597 *
6598 * host_reset, bring up w/ Target Mode Enabled
6599 */
6600void
6601qlt_enable_vha(struct scsi_qla_host *vha)
6602{
6603 struct qla_hw_data *ha = vha->hw;
0e8cd71c 6604 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
2d70c103 6605 unsigned long flags;
0e8cd71c 6606 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
2d70c103
NB		 6607
6608 if (!tgt) {
6609 ql_dbg(ql_dbg_tgt, vha, 0xe069,
6610 "Unable to locate qla_tgt pointer from"
6611 " struct qla_hw_data\n");
6612 dump_stack();
6613 return;
6614 }
0645cb83
QT		 6615 if (vha->qlini_mode == QLA2XXX_INI_MODE_ENABLED)
6616 return;
2d70c103 6617
178235f4
QT		 6618 if (ha->tgt.num_act_qpairs > ha->max_qpairs)
6619 ha->tgt.num_act_qpairs = ha->max_qpairs;
2d70c103
NB		 6620 spin_lock_irqsave(&ha->hardware_lock, flags);
6621 tgt->tgt_stopped = 0;
6622 qlt_set_mode(vha);
6623 spin_unlock_irqrestore(&ha->hardware_lock, flags);
6624
b6faaaf7
QT		 6625 mutex_lock(&ha->optrom_mutex);
6626 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf021,
6627 "%s.\n", __func__);
0e8cd71c
SK		 6628 if (vha->vp_idx) {
6629 qla24xx_disable_vp(vha);
6630 qla24xx_enable_vp(vha);
6631 } else {
6632 set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
6633 qla2xxx_wake_dpc(base_vha);
e6803efa
BVA		 6634 WARN_ON_ONCE(qla2x00_wait_for_hba_online(base_vha) !=
6635 QLA_SUCCESS);
0e8cd71c 6636 }
b6faaaf7 6637 mutex_unlock(&ha->optrom_mutex);
2d70c103
NB		 6638}
6639EXPORT_SYMBOL(qlt_enable_vha);
6640
6641/*
6642 * qla_tgt_disable_vha - NO LOCK HELD
6643 *
6644 * Disable Target Mode and reset the adapter
6645 */
55a9066f 6646static void qlt_disable_vha(struct scsi_qla_host *vha)
2d70c103
NB		 6647{
6648 struct qla_hw_data *ha = vha->hw;
0e8cd71c 6649 struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
2d70c103
NB		 6650 unsigned long flags;
6651
6652 if (!tgt) {
6653 ql_dbg(ql_dbg_tgt, vha, 0xe06a,
6654 "Unable to locate qla_tgt pointer from"
6655 " struct qla_hw_data\n");
6656 dump_stack();
6657 return;
6658 }
6659
6660 spin_lock_irqsave(&ha->hardware_lock, flags);
6661 qlt_clear_mode(vha);
6662 spin_unlock_irqrestore(&ha->hardware_lock, flags);
6663
6664 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
6665 qla2xxx_wake_dpc(vha);
e6803efa
BVA		 6666 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS)
6667 ql_dbg(ql_dbg_tgt, vha, 0xe081,
6668 "qla2x00_wait_for_hba_online() failed\n");
2d70c103
NB		 6669}
6670
6671/*
6672 * Called from qla_init.c:qla24xx_vport_create() contex to setup
6673 * the target mode specific struct scsi_qla_host and struct qla_hw_data
6674 * members.
6675 */
6676void
6677qlt_vport_create(struct scsi_qla_host *vha, struct qla_hw_data *ha)
6678{
0e8cd71c
SK		 6679 vha->vha_tgt.qla_tgt = NULL;
6680
6681 mutex_init(&vha->vha_tgt.tgt_mutex);
6682 mutex_init(&vha->vha_tgt.tgt_host_action_mutex);
2d70c103
NB		 6683
6684 qlt_clear_mode(vha);
6685
6686 /*
6687 * NOTE: Currently the value is kept the same for <24xx and
6688 * >=24xx ISPs. If it is necessary to change it,
6689 * the check should be added for specific ISPs,
6690 * assigning the value appropriately.
6691 */
6692 ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
0e8cd71c
SK		 6693
6694 qlt_add_target(ha, vha);
2d70c103
NB		 6695}
6696
e374f9f5
QT		 6697u8
6698qlt_rff_id(struct scsi_qla_host *vha)
2d70c103 6699{
e374f9f5 6700 u8 fc4_feature = 0;
2d70c103
NB		 6701 /*
6702 * FC-4 Feature bit 0 indicates target functionality to the name server.
6703 */
6704 if (qla_tgt_mode_enabled(vha)) {
e374f9f5 6705 fc4_feature = BIT_0;
2d70c103 6706 } else if (qla_ini_mode_enabled(vha)) {
e374f9f5 6707 fc4_feature = BIT_1;
726b8548 6708 } else if (qla_dual_mode_enabled(vha))
e374f9f5
QT		 6709 fc4_feature = BIT_0 | BIT_1;
6710
6711 return fc4_feature;
2d70c103
NB		 6712}
6713
6714/*
6715 * qlt_init_atio_q_entries() - Initializes ATIO queue entries.
6716 * @ha: HA context
6717 *
6718 * Beginning of ATIO ring has initialization control block already built
6719 * by nvram config routine.
6720 *
6721 * Returns 0 on success.
6722 */
6723void
6724qlt_init_atio_q_entries(struct scsi_qla_host *vha)
6725{
6726 struct qla_hw_data *ha = vha->hw;
6727 uint16_t cnt;
6728 struct atio_from_isp *pkt = (struct atio_from_isp *)ha->tgt.atio_ring;
6729
ead03855 6730 if (qla_ini_mode_enabled(vha))
2d70c103
NB		 6731 return;
6732
6733 for (cnt = 0; cnt < ha->tgt.atio_q_length; cnt++) {
6734 pkt->u.raw.signature = ATIO_PROCESSED;
6735 pkt++;
6736 }
6737
6738}
6739
6740/*
6741 * qlt_24xx_process_atio_queue() - Process ATIO queue entries.
6742 * @ha: SCSI driver HA context
6743 */
6744void
2f424b9b 6745qlt_24xx_process_atio_queue(struct scsi_qla_host *vha, uint8_t ha_locked)
2d70c103
NB		 6746{
6747 struct qla_hw_data *ha = vha->hw;
2d70c103
NB		 6748 struct atio_from_isp *pkt;
6749 int cnt, i;
6750
ec7193e2 6751 if (!ha->flags.fw_started)
2d70c103
NB		 6752 return;
6753
5f35509d
QT		 6754 while ((ha->tgt.atio_ring_ptr->signature != ATIO_PROCESSED) ||
6755 fcpcmd_is_corrupted(ha->tgt.atio_ring_ptr)) {
2d70c103
NB		 6756 pkt = (struct atio_from_isp *)ha->tgt.atio_ring_ptr;
6757 cnt = pkt->u.raw.entry_count;
6758
5f35509d
QT		 6759 if (unlikely(fcpcmd_is_corrupted(ha->tgt.atio_ring_ptr))) {
6760 /*
6761 * This packet is corrupted. The header + payload
6762 * can not be trusted. There is no point in passing
6763 * it further up.
6764 */
83548fe2 6765 ql_log(ql_log_warn, vha, 0xd03c,
5f35509d 6766 "corrupted fcp frame SID[%3phN] OXID[%04x] EXCG[%x] %64phN\n",
df95f39a 6767 &pkt->u.isp24.fcp_hdr.s_id,
5f35509d
QT		 6768 be16_to_cpu(pkt->u.isp24.fcp_hdr.ox_id),
6769 le32_to_cpu(pkt->u.isp24.exchange_addr), pkt);
6770
6771 adjust_corrupted_atio(pkt);
82de802a
QT		 6772 qlt_send_term_exchange(ha->base_qpair, NULL, pkt,
6773 ha_locked, 0);
5f35509d
QT		 6774 } else {
6775 qlt_24xx_atio_pkt_all_vps(vha,
6776 (struct atio_from_isp *)pkt, ha_locked);
6777 }
2d70c103
NB		 6778
6779 for (i = 0; i < cnt; i++) {
6780 ha->tgt.atio_ring_index++;
6781 if (ha->tgt.atio_ring_index == ha->tgt.atio_q_length) {
6782 ha->tgt.atio_ring_index = 0;
6783 ha->tgt.atio_ring_ptr = ha->tgt.atio_ring;
6784 } else
6785 ha->tgt.atio_ring_ptr++;
6786
6787 pkt->u.raw.signature = ATIO_PROCESSED;
6788 pkt = (struct atio_from_isp *)ha->tgt.atio_ring_ptr;
6789 }
6790 wmb();
6791 }
6792
6793 /* Adjust ring index */
aa230bc5 6794 WRT_REG_DWORD(ISP_ATIO_Q_OUT(vha), ha->tgt.atio_ring_index);
2d70c103
NB		 6795}
6796
6797void
aa230bc5 6798qlt_24xx_config_rings(struct scsi_qla_host *vha)
2d70c103
NB		 6799{
6800 struct qla_hw_data *ha = vha->hw;
d2b292c3
QT		 6801 struct qla_msix_entry *msix = &ha->msix_entries[2];
6802 struct init_cb_24xx *icb = (struct init_cb_24xx *)ha->init_cb;
6803
aa230bc5
AE		 6804 if (!QLA_TGT_MODE_ENABLED())
6805 return;
2d70c103 6806
aa230bc5
AE		 6807 WRT_REG_DWORD(ISP_ATIO_Q_IN(vha), 0);
6808 WRT_REG_DWORD(ISP_ATIO_Q_OUT(vha), 0);
6809 RD_REG_DWORD(ISP_ATIO_Q_OUT(vha));
6810
d2b292c3 6811 if (ha->flags.msix_enabled) {
ecc89f25 6812 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
d2b292c3
QT		 6813 if (IS_QLA2071(ha)) {
6814 /* 4 ports Baker: Enable Interrupt Handshake */
6815 icb->msix_atio = 0;
6816 icb->firmware_options_2 |= BIT_26;
6817 } else {
6818 icb->msix_atio = cpu_to_le16(msix->entry);
6819 icb->firmware_options_2 &= ~BIT_26;
6820 }
6821 ql_dbg(ql_dbg_init, vha, 0xf072,
6822 "Registering ICB vector 0x%x for atio que.\n",
6823 msix->entry);
6824 }
6825 } else {
6826 /* INTx|MSI */
ecc89f25 6827 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
d2b292c3
QT		 6828 icb->msix_atio = 0;
6829 icb->firmware_options_2 |= BIT_26;
6830 ql_dbg(ql_dbg_init, vha, 0xf072,
6831 "%s: Use INTx for ATIOQ.\n", __func__);
6832 }
2d70c103
NB		 6833 }
6834}
6835
6836void
6837qlt_24xx_config_nvram_stage1(struct scsi_qla_host *vha, struct nvram_24xx *nv)
6838{
6839 struct qla_hw_data *ha = vha->hw;
9cd883f0 6840 u32 tmp;
99e1b683
QT		 6841
6842 if (!QLA_TGT_MODE_ENABLED())
6843 return;
2d70c103 6844
ead03855 6845 if (qla_tgt_mode_enabled(vha) || qla_dual_mode_enabled(vha)) {
2d70c103
NB		 6846 if (!ha->tgt.saved_set) {
6847 /* We save only once */
6848 ha->tgt.saved_exchange_count = nv->exchange_count;
6849 ha->tgt.saved_firmware_options_1 =
6850 nv->firmware_options_1;
6851 ha->tgt.saved_firmware_options_2 =
6852 nv->firmware_options_2;
6853 ha->tgt.saved_firmware_options_3 =
6854 nv->firmware_options_3;
6855 ha->tgt.saved_set = 1;
6856 }
6857
99e1b683 6858 if (qla_tgt_mode_enabled(vha))
ead03855 6859 nv->exchange_count = cpu_to_le16(0xFFFF);
99e1b683 6860 else /* dual */
0645cb83 6861 nv->exchange_count = cpu_to_le16(vha->ql2xexchoffld);
2d70c103
NB		 6862
6863 /* Enable target mode */
ad950360 6864 nv->firmware_options_1 |= cpu_to_le32(BIT_4);
2d70c103
NB		 6865
6866 /* Disable ini mode, if requested */
726b8548 6867 if (qla_tgt_mode_enabled(vha))
ad950360 6868 nv->firmware_options_1 |= cpu_to_le32(BIT_5);
2d70c103
NB		 6869
6870 /* Disable Full Login after LIP */
ad950360 6871 nv->firmware_options_1 &= cpu_to_le32(~BIT_13);
2d70c103 6872 /* Enable initial LIP */
ad950360 6873 nv->firmware_options_1 &= cpu_to_le32(~BIT_9);
d154f350
AE		 6874 if (ql2xtgt_tape_enable)
6875 /* Enable FC Tape support */
6876 nv->firmware_options_2 |= cpu_to_le32(BIT_12);
6877 else
6878 /* Disable FC Tape support */
6879 nv->firmware_options_2 &= cpu_to_le32(~BIT_12);
6880
2d70c103 6881 /* Disable Full Login after LIP */
ad950360 6882 nv->host_p &= cpu_to_le32(~BIT_10);
c0f64627
HM		 6883
6884 /*
6885 * clear BIT 15 explicitly as we have seen at least
6886 * a couple of instances where this was set and this
6887 * was causing the firmware to not be initialized.
6888 */
6889 nv->firmware_options_1 &= cpu_to_le32(~BIT_15);
2d70c103 6890 /* Enable target PRLI control */
ad950360 6891 nv->firmware_options_2 |= cpu_to_le32(BIT_14);
9cd883f0
QT		 6892
6893 if (IS_QLA25XX(ha)) {
6894 /* Change Loop-prefer to Pt-Pt */
6895 tmp = ~(BIT_4|BIT_5|BIT_6);
6896 nv->firmware_options_2 &= cpu_to_le32(tmp);
6897 tmp = P2P << 4;
6898 nv->firmware_options_2 |= cpu_to_le32(tmp);
6899 }
2d70c103
NB		 6900 } else {
6901 if (ha->tgt.saved_set) {
6902 nv->exchange_count = ha->tgt.saved_exchange_count;
6903 nv->firmware_options_1 =
6904 ha->tgt.saved_firmware_options_1;
6905 nv->firmware_options_2 =
6906 ha->tgt.saved_firmware_options_2;
6907 nv->firmware_options_3 =
6908 ha->tgt.saved_firmware_options_3;
6909 }
6910 return;
6911 }
6912
7c3f8fd1 6913 if (ha->base_qpair->enable_class_2) {
2d70c103
NB		 6914 if (vha->flags.init_done)
6915 fc_host_supported_classes(vha->host) =
6916 FC_COS_CLASS2 | FC_COS_CLASS3;
6917
ad950360 6918 nv->firmware_options_2 |= cpu_to_le32(BIT_8);
2d70c103
NB		 6919 } else {
6920 if (vha->flags.init_done)
6921 fc_host_supported_classes(vha->host) = FC_COS_CLASS3;
6922
ad950360 6923 nv->firmware_options_2 &= ~cpu_to_le32(BIT_8);
2d70c103
NB		 6924 }
6925}
6926
6927void
6928qlt_24xx_config_nvram_stage2(struct scsi_qla_host *vha,
6929 struct init_cb_24xx *icb)
6930{
6931 struct qla_hw_data *ha = vha->hw;
6932
481ce733
QT		 6933 if (!QLA_TGT_MODE_ENABLED())
6934 return;
6935
2d70c103
NB		 6936 if (ha->tgt.node_name_set) {
6937 memcpy(icb->node_name, ha->tgt.tgt_node_name, WWN_SIZE);
ad950360 6938 icb->firmware_options_1 |= cpu_to_le32(BIT_14);
2d70c103
NB		 6939 }
6940}
6941
aa230bc5
AE		 6942void
6943qlt_81xx_config_nvram_stage1(struct scsi_qla_host *vha, struct nvram_81xx *nv)
6944{
6945 struct qla_hw_data *ha = vha->hw;
9cd883f0 6946 u32 tmp;
aa230bc5
AE		 6947
6948 if (!QLA_TGT_MODE_ENABLED())
6949 return;
6950
ead03855 6951 if (qla_tgt_mode_enabled(vha) || qla_dual_mode_enabled(vha)) {
aa230bc5
AE		 6952 if (!ha->tgt.saved_set) {
6953 /* We save only once */
6954 ha->tgt.saved_exchange_count = nv->exchange_count;
6955 ha->tgt.saved_firmware_options_1 =
6956 nv->firmware_options_1;
6957 ha->tgt.saved_firmware_options_2 =
6958 nv->firmware_options_2;
6959 ha->tgt.saved_firmware_options_3 =
6960 nv->firmware_options_3;
6961 ha->tgt.saved_set = 1;
6962 }
6963
99e1b683 6964 if (qla_tgt_mode_enabled(vha))
ead03855 6965 nv->exchange_count = cpu_to_le16(0xFFFF);
99e1b683 6966 else /* dual */
0645cb83 6967 nv->exchange_count = cpu_to_le16(vha->ql2xexchoffld);
aa230bc5
AE		 6968
6969 /* Enable target mode */
ad950360 6970 nv->firmware_options_1 |= cpu_to_le32(BIT_4);
aa230bc5
AE		 6971
6972 /* Disable ini mode, if requested */
726b8548 6973 if (qla_tgt_mode_enabled(vha))
ad950360 6974 nv->firmware_options_1 |= cpu_to_le32(BIT_5);
aa230bc5 6975 /* Disable Full Login after LIP */
ad950360 6976 nv->firmware_options_1 &= cpu_to_le32(~BIT_13);
aa230bc5 6977 /* Enable initial LIP */
ad950360 6978 nv->firmware_options_1 &= cpu_to_le32(~BIT_9);
c0f64627
HM		 6979 /*
6980 * clear BIT 15 explicitly as we have seen at
6981 * least a couple of instances where this was set
6982 * and this was causing the firmware to not be
6983 * initialized.
6984 */
6985 nv->firmware_options_1 &= cpu_to_le32(~BIT_15);
d154f350
AE		 6986 if (ql2xtgt_tape_enable)
6987 /* Enable FC tape support */
6988 nv->firmware_options_2 |= cpu_to_le32(BIT_12);
6989 else
6990 /* Disable FC tape support */
6991 nv->firmware_options_2 &= cpu_to_le32(~BIT_12);
6992
aa230bc5 6993 /* Disable Full Login after LIP */
ad950360 6994 nv->host_p &= cpu_to_le32(~BIT_10);
aa230bc5 6995 /* Enable target PRLI control */
ad950360 6996 nv->firmware_options_2 |= cpu_to_le32(BIT_14);
9cd883f0
QT		 6997
6998 /* Change Loop-prefer to Pt-Pt */
6999 tmp = ~(BIT_4|BIT_5|BIT_6);
7000 nv->firmware_options_2 &= cpu_to_le32(tmp);
7001 tmp = P2P << 4;
7002 nv->firmware_options_2 |= cpu_to_le32(tmp);
aa230bc5
AE		 7003 } else {
7004 if (ha->tgt.saved_set) {
7005 nv->exchange_count = ha->tgt.saved_exchange_count;
7006 nv->firmware_options_1 =
7007 ha->tgt.saved_firmware_options_1;
7008 nv->firmware_options_2 =
7009 ha->tgt.saved_firmware_options_2;
7010 nv->firmware_options_3 =
7011 ha->tgt.saved_firmware_options_3;
7012 }
7013 return;
7014 }
7015
7c3f8fd1 7016 if (ha->base_qpair->enable_class_2) {
aa230bc5
AE		 7017 if (vha->flags.init_done)
7018 fc_host_supported_classes(vha->host) =
7019 FC_COS_CLASS2 | FC_COS_CLASS3;
7020
ad950360 7021 nv->firmware_options_2 |= cpu_to_le32(BIT_8);
aa230bc5
AE		 7022 } else {
7023 if (vha->flags.init_done)
7024 fc_host_supported_classes(vha->host) = FC_COS_CLASS3;
7025
ad950360 7026 nv->firmware_options_2 &= ~cpu_to_le32(BIT_8);
aa230bc5
AE		 7027 }
7028}
7029
7030void
7031qlt_81xx_config_nvram_stage2(struct scsi_qla_host *vha,
7032 struct init_cb_81xx *icb)
7033{
7034 struct qla_hw_data *ha = vha->hw;
7035
7036 if (!QLA_TGT_MODE_ENABLED())
7037 return;
7038
7039 if (ha->tgt.node_name_set) {
7040 memcpy(icb->node_name, ha->tgt.tgt_node_name, WWN_SIZE);
ad950360 7041 icb->firmware_options_1 |= cpu_to_le32(BIT_14);
aa230bc5
AE		 7042 }
7043}
7044
7045void
7046qlt_83xx_iospace_config(struct qla_hw_data *ha)
7047{
7048 if (!QLA_TGT_MODE_ENABLED())
7049 return;
7050
7051 ha->msix_count += 1; /* For ATIO Q */
7052}
7053
2d70c103
NB		 7054
7055void
7056qlt_modify_vp_config(struct scsi_qla_host *vha,
7057 struct vp_config_entry_24xx *vpmod)
7058{
ead03855
QT		 7059 /* enable target mode. Bit5 = 1 => disable */
7060 if (qla_tgt_mode_enabled(vha) || qla_dual_mode_enabled(vha))
2d70c103 7061 vpmod->options_idx1 &= ~BIT_5;
726b8548 7062
ead03855 7063 /* Disable ini mode, if requested. bit4 = 1 => disable */
726b8548 7064 if (qla_tgt_mode_enabled(vha))
2d70c103
NB		 7065 vpmod->options_idx1 &= ~BIT_4;
7066}
7067
7068void
7069qlt_probe_one_stage1(struct scsi_qla_host *base_vha, struct qla_hw_data *ha)
7070{
482c9dc7
QT		 7071 int rc;
7072
2d70c103
NB		 7073 if (!QLA_TGT_MODE_ENABLED())
7074 return;
7075
ecc89f25
JC		 7076 if ((ql2xenablemsix == 0) || IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
7077 IS_QLA28XX(ha)) {
aa230bc5
AE		 7078 ISP_ATIO_Q_IN(base_vha) = &ha->mqiobase->isp25mq.atio_q_in;
7079 ISP_ATIO_Q_OUT(base_vha) = &ha->mqiobase->isp25mq.atio_q_out;
7080 } else {
7081 ISP_ATIO_Q_IN(base_vha) = &ha->iobase->isp24.atio_q_in;
7082 ISP_ATIO_Q_OUT(base_vha) = &ha->iobase->isp24.atio_q_out;
7083 }
7084
0e8cd71c
SK		 7085 mutex_init(&base_vha->vha_tgt.tgt_mutex);
7086 mutex_init(&base_vha->vha_tgt.tgt_host_action_mutex);
41dc529a
QT		 7087
7088 INIT_LIST_HEAD(&base_vha->unknown_atio_list);
7089 INIT_DELAYED_WORK(&base_vha->unknown_atio_work,
7090 qlt_unknown_atio_work_fn);
7091
2d70c103 7092 qlt_clear_mode(base_vha);
482c9dc7
QT		 7093
7094 rc = btree_init32(&ha->tgt.host_map);
7095 if (rc)
83548fe2 7096 ql_log(ql_log_info, base_vha, 0xd03d,
482c9dc7
QT		 7097 "Unable to initialize ha->host_map btree\n");
7098
7099 qlt_update_vp_map(base_vha, SET_VP_IDX);
2d70c103
NB		 7100}
7101
aa230bc5
AE		 7102irqreturn_t
7103qla83xx_msix_atio_q(int irq, void *dev_id)
7104{
7105 struct rsp_que *rsp;
7106 scsi_qla_host_t *vha;
7107 struct qla_hw_data *ha;
7108 unsigned long flags;
7109
7110 rsp = (struct rsp_que *) dev_id;
7111 ha = rsp->hw;
7112 vha = pci_get_drvdata(ha->pdev);
7113
2f424b9b 7114 spin_lock_irqsave(&ha->tgt.atio_lock, flags);
aa230bc5 7115
2f424b9b 7116 qlt_24xx_process_atio_queue(vha, 0);
aa230bc5 7117
2f424b9b 7118 spin_unlock_irqrestore(&ha->tgt.atio_lock, flags);
aa230bc5
AE		 7119
7120 return IRQ_HANDLED;
7121}
7122
2f424b9b
QT		 7123static void
7124qlt_handle_abts_recv_work(struct work_struct *work)
7125{
7126 struct qla_tgt_sess_op *op = container_of(work,
7127 struct qla_tgt_sess_op, work);
7128 scsi_qla_host_t *vha = op->vha;
7129 struct qla_hw_data *ha = vha->hw;
7130 unsigned long flags;
7131
7c3f8fd1
QT		 7132 if (qla2x00_reset_active(vha) ||
7133 (op->chip_reset != ha->base_qpair->chip_reset))
2f424b9b
QT		 7134 return;
7135
7136 spin_lock_irqsave(&ha->tgt.atio_lock, flags);
7137 qlt_24xx_process_atio_queue(vha, 0);
7138 spin_unlock_irqrestore(&ha->tgt.atio_lock, flags);
7139
7140 spin_lock_irqsave(&ha->hardware_lock, flags);
82de802a 7141 qlt_response_pkt_all_vps(vha, op->rsp, (response_t *)&op->atio);
2f424b9b 7142 spin_unlock_irqrestore(&ha->hardware_lock, flags);
ae940f2c
QT		 7143
7144 kfree(op);
2f424b9b
QT		 7145}
7146
7147void
82de802a
QT		 7148qlt_handle_abts_recv(struct scsi_qla_host *vha, struct rsp_que *rsp,
7149 response_t *pkt)
2f424b9b
QT		 7150{
7151 struct qla_tgt_sess_op *op;
7152
7153 op = kzalloc(sizeof(*op), GFP_ATOMIC);
7154
7155 if (!op) {
7156 /* do not reach for ATIO queue here. This is best effort err
7157 * recovery at this point.
7158 */
82de802a 7159 qlt_response_pkt_all_vps(vha, rsp, pkt);
2f424b9b
QT		 7160 return;
7161 }
7162
7163 memcpy(&op->atio, pkt, sizeof(*pkt));
7164 op->vha = vha;
7c3f8fd1 7165 op->chip_reset = vha->hw->base_qpair->chip_reset;
82de802a 7166 op->rsp = rsp;
2f424b9b
QT		 7167 INIT_WORK(&op->work, qlt_handle_abts_recv_work);
7168 queue_work(qla_tgt_wq, &op->work);
7169 return;
7170}
7171
2d70c103
NB		 7172int
7173qlt_mem_alloc(struct qla_hw_data *ha)
7174{
7175 if (!QLA_TGT_MODE_ENABLED())
7176 return 0;
7177
6396bb22
KC		 7178 ha->tgt.tgt_vp_map = kcalloc(MAX_MULTI_ID_FABRIC,
7179 sizeof(struct qla_tgt_vp_map),
7180 GFP_KERNEL);
2d70c103
NB		 7181 if (!ha->tgt.tgt_vp_map)
7182 return -ENOMEM;
7183
7184 ha->tgt.atio_ring = dma_alloc_coherent(&ha->pdev->dev,
7185 (ha->tgt.atio_q_length + 1) * sizeof(struct atio_from_isp),
7186 &ha->tgt.atio_dma, GFP_KERNEL);
7187 if (!ha->tgt.atio_ring) {
7188 kfree(ha->tgt.tgt_vp_map);
7189 return -ENOMEM;
7190 }
7191 return 0;
7192}
7193
7194void
7195qlt_mem_free(struct qla_hw_data *ha)
7196{
7197 if (!QLA_TGT_MODE_ENABLED())
7198 return;
7199
7200 if (ha->tgt.atio_ring) {
7201 dma_free_coherent(&ha->pdev->dev, (ha->tgt.atio_q_length + 1) *
7202 sizeof(struct atio_from_isp), ha->tgt.atio_ring,
7203 ha->tgt.atio_dma);
7204 }
5365bf99
BVA		 7205 ha->tgt.atio_ring = NULL;
7206 ha->tgt.atio_dma = 0;
2d70c103 7207 kfree(ha->tgt.tgt_vp_map);
5365bf99 7208 ha->tgt.tgt_vp_map = NULL;
2d70c103
NB		 7209}
7210
7211/* vport_slock to be held by the caller */
7212void
7213qlt_update_vp_map(struct scsi_qla_host *vha, int cmd)
7214{
482c9dc7
QT		 7215 void *slot;
7216 u32 key;
7217 int rc;
7218
2d70c103
NB		 7219 if (!QLA_TGT_MODE_ENABLED())
7220 return;
7221
482c9dc7
QT		 7222 key = vha->d_id.b24;
7223
2d70c103
NB		 7224 switch (cmd) {
7225 case SET_VP_IDX:
7226 vha->hw->tgt.tgt_vp_map[vha->vp_idx].vha = vha;
7227 break;
7228 case SET_AL_PA:
482c9dc7
QT		 7229 slot = btree_lookup32(&vha->hw->tgt.host_map, key);
7230 if (!slot) {
83548fe2 7231 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf018,
482c9dc7
QT		 7232 "Save vha in host_map %p %06x\n", vha, key);
7233 rc = btree_insert32(&vha->hw->tgt.host_map,
7234 key, vha, GFP_ATOMIC);
7235 if (rc)
83548fe2 7236 ql_log(ql_log_info, vha, 0xd03e,
482c9dc7
QT		 7237 "Unable to insert s_id into host_map: %06x\n",
7238 key);
7239 return;
7240 }
83548fe2
QT		 7241 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf019,
7242 "replace existing vha in host_map %p %06x\n", vha, key);
482c9dc7 7243 btree_update32(&vha->hw->tgt.host_map, key, vha);
2d70c103
NB		 7244 break;
7245 case RESET_VP_IDX:
7246 vha->hw->tgt.tgt_vp_map[vha->vp_idx].vha = NULL;
7247 break;
7248 case RESET_AL_PA:
83548fe2 7249 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf01a,
482c9dc7
QT		 7250 "clear vha in host_map %p %06x\n", vha, key);
7251 slot = btree_lookup32(&vha->hw->tgt.host_map, key);
7252 if (slot)
7253 btree_remove32(&vha->hw->tgt.host_map, key);
7254 vha->d_id.b24 = 0;
2d70c103
NB		 7255 break;
7256 }
7257}
7258
482c9dc7
QT		 7259void qlt_update_host_map(struct scsi_qla_host *vha, port_id_t id)
7260{
482c9dc7
QT		 7261
7262 if (!vha->d_id.b24) {
482c9dc7
QT		 7263 vha->d_id = id;
7264 qlt_update_vp_map(vha, SET_AL_PA);
482c9dc7 7265 } else if (vha->d_id.b24 != id.b24) {
482c9dc7
QT		 7266 qlt_update_vp_map(vha, RESET_AL_PA);
7267 vha->d_id = id;
7268 qlt_update_vp_map(vha, SET_AL_PA);
482c9dc7
QT		 7269 }
7270}
7271
2d70c103
NB		 7272static int __init qlt_parse_ini_mode(void)
7273{
7274 if (strcasecmp(qlini_mode, QLA2XXX_INI_MODE_STR_EXCLUSIVE) == 0)
7275 ql2x_ini_mode = QLA2XXX_INI_MODE_EXCLUSIVE;
7276 else if (strcasecmp(qlini_mode, QLA2XXX_INI_MODE_STR_DISABLED) == 0)
7277 ql2x_ini_mode = QLA2XXX_INI_MODE_DISABLED;
7278 else if (strcasecmp(qlini_mode, QLA2XXX_INI_MODE_STR_ENABLED) == 0)
7279 ql2x_ini_mode = QLA2XXX_INI_MODE_ENABLED;
ead03855
QT		 7280 else if (strcasecmp(qlini_mode, QLA2XXX_INI_MODE_STR_DUAL) == 0)
7281 ql2x_ini_mode = QLA2XXX_INI_MODE_DUAL;
2d70c103
NB		 7282 else
7283 return false;
7284
7285 return true;
7286}
7287
7288int __init qlt_init(void)
7289{
7290 int ret;
7291
bc04459c
BVA		 7292 BUILD_BUG_ON(sizeof(struct ctio7_to_24xx) != 64);
7293 BUILD_BUG_ON(sizeof(struct ctio_to_2xxx) != 64);
7294
2d70c103
NB		 7295 if (!qlt_parse_ini_mode()) {
7296 ql_log(ql_log_fatal, NULL, 0xe06b,
7297 "qlt_parse_ini_mode() failed\n");
7298 return -EINVAL;
7299 }
7300
7301 if (!QLA_TGT_MODE_ENABLED())
7302 return 0;
7303
2d70c103
NB		 7304 qla_tgt_mgmt_cmd_cachep = kmem_cache_create("qla_tgt_mgmt_cmd_cachep",
7305 sizeof(struct qla_tgt_mgmt_cmd), __alignof__(struct
7306 qla_tgt_mgmt_cmd), 0, NULL);
7307 if (!qla_tgt_mgmt_cmd_cachep) {
83548fe2 7308 ql_log(ql_log_fatal, NULL, 0xd04b,
2d70c103 7309 "kmem_cache_create for qla_tgt_mgmt_cmd_cachep failed\n");
51a07f84 7310 return -ENOMEM;
2d70c103
NB		 7311 }
7312
b7bd104e 7313 qla_tgt_plogi_cachep = kmem_cache_create("qla_tgt_plogi_cachep",
5d964837
QT		 7314 sizeof(struct qlt_plogi_ack_t), __alignof__(struct qlt_plogi_ack_t),
7315 0, NULL);
b7bd104e
AP		 7316
7317 if (!qla_tgt_plogi_cachep) {
7318 ql_log(ql_log_fatal, NULL, 0xe06d,
7319 "kmem_cache_create for qla_tgt_plogi_cachep failed\n");
7320 ret = -ENOMEM;
7321 goto out_mgmt_cmd_cachep;
7322 }
7323
2d70c103
NB		 7324 qla_tgt_mgmt_cmd_mempool = mempool_create(25, mempool_alloc_slab,
7325 mempool_free_slab, qla_tgt_mgmt_cmd_cachep);
7326 if (!qla_tgt_mgmt_cmd_mempool) {
7327 ql_log(ql_log_fatal, NULL, 0xe06e,
7328 "mempool_create for qla_tgt_mgmt_cmd_mempool failed\n");
7329 ret = -ENOMEM;
b7bd104e 7330 goto out_plogi_cachep;
2d70c103
NB		 7331 }
7332
7333 qla_tgt_wq = alloc_workqueue("qla_tgt_wq", 0, 0);
7334 if (!qla_tgt_wq) {
7335 ql_log(ql_log_fatal, NULL, 0xe06f,
7336 "alloc_workqueue for qla_tgt_wq failed\n");
7337 ret = -ENOMEM;
7338 goto out_cmd_mempool;
7339 }
7340 /*
7341 * Return 1 to signal that initiator-mode is being disabled
7342 */
7343 return (ql2x_ini_mode == QLA2XXX_INI_MODE_DISABLED) ? 1 : 0;
7344
7345out_cmd_mempool:
7346 mempool_destroy(qla_tgt_mgmt_cmd_mempool);
b7bd104e
AP		 7347out_plogi_cachep:
7348 kmem_cache_destroy(qla_tgt_plogi_cachep);
2d70c103
NB		 7349out_mgmt_cmd_cachep:
7350 kmem_cache_destroy(qla_tgt_mgmt_cmd_cachep);
2d70c103
NB		 7351 return ret;
7352}
7353
7354void qlt_exit(void)
7355{
7356 if (!QLA_TGT_MODE_ENABLED())
7357 return;
7358
7359 destroy_workqueue(qla_tgt_wq);
7360 mempool_destroy(qla_tgt_mgmt_cmd_mempool);
b7bd104e 7361 kmem_cache_destroy(qla_tgt_plogi_cachep);
2d70c103 7362 kmem_cache_destroy(qla_tgt_mgmt_cmd_cachep);
2d70c103 7363}
Linux 6.x block layer and io_uring tree(s)