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