]>
Commit | Line | Data |
---|---|---|
d613b6a7 JS |
1 | /******************************************************************* |
2 | * This file is part of the Emulex Linux Device Driver for * | |
d080abe0 JS |
3 | * Fibre Channsel Host Bus Adapters. * |
4 | * Copyright (C) 2017 Broadcom. All Rights Reserved. The term * | |
5 | * “Broadcom” refers to Broadcom Limited and/or its subsidiaries. * | |
d613b6a7 JS |
6 | * Copyright (C) 2004-2016 Emulex. All rights reserved. * |
7 | * EMULEX and SLI are trademarks of Emulex. * | |
d080abe0 | 8 | * www.broadcom.com * |
d613b6a7 JS |
9 | * Portions Copyright (C) 2004-2005 Christoph Hellwig * |
10 | * * | |
11 | * This program is free software; you can redistribute it and/or * | |
12 | * modify it under the terms of version 2 of the GNU General * | |
13 | * Public License as published by the Free Software Foundation. * | |
14 | * This program is distributed in the hope that it will be useful. * | |
15 | * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * | |
16 | * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * | |
17 | * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * | |
18 | * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * | |
19 | * TO BE LEGALLY INVALID. See the GNU General Public License for * | |
20 | * more details, a copy of which can be found in the file COPYING * | |
21 | * included with this package. * | |
22 | ********************************************************************/ | |
23 | #include <linux/pci.h> | |
24 | #include <linux/slab.h> | |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/delay.h> | |
27 | #include <asm/unaligned.h> | |
28 | #include <linux/crc-t10dif.h> | |
29 | #include <net/checksum.h> | |
30 | ||
31 | #include <scsi/scsi.h> | |
32 | #include <scsi/scsi_device.h> | |
33 | #include <scsi/scsi_eh.h> | |
34 | #include <scsi/scsi_host.h> | |
35 | #include <scsi/scsi_tcq.h> | |
36 | #include <scsi/scsi_transport_fc.h> | |
37 | #include <scsi/fc/fc_fs.h> | |
38 | ||
39 | #include <../drivers/nvme/host/nvme.h> | |
40 | #include <linux/nvme-fc-driver.h> | |
41 | ||
42 | #include "lpfc_version.h" | |
43 | #include "lpfc_hw4.h" | |
44 | #include "lpfc_hw.h" | |
45 | #include "lpfc_sli.h" | |
46 | #include "lpfc_sli4.h" | |
47 | #include "lpfc_nl.h" | |
48 | #include "lpfc_disc.h" | |
49 | #include "lpfc.h" | |
50 | #include "lpfc_scsi.h" | |
51 | #include "lpfc_nvme.h" | |
52 | #include "lpfc_nvmet.h" | |
53 | #include "lpfc_logmsg.h" | |
54 | #include "lpfc_crtn.h" | |
55 | #include "lpfc_vport.h" | |
2b65e182 | 56 | #include "lpfc_debugfs.h" |
d613b6a7 JS |
57 | |
58 | static struct lpfc_iocbq *lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *, | |
59 | struct lpfc_nvmet_rcv_ctx *, | |
60 | dma_addr_t rspbuf, | |
61 | uint16_t rspsize); | |
62 | static struct lpfc_iocbq *lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *, | |
63 | struct lpfc_nvmet_rcv_ctx *); | |
64 | static int lpfc_nvmet_sol_fcp_issue_abort(struct lpfc_hba *, | |
65 | struct lpfc_nvmet_rcv_ctx *, | |
66 | uint32_t, uint16_t); | |
67 | static int lpfc_nvmet_unsol_fcp_issue_abort(struct lpfc_hba *, | |
68 | struct lpfc_nvmet_rcv_ctx *, | |
69 | uint32_t, uint16_t); | |
70 | static int lpfc_nvmet_unsol_ls_issue_abort(struct lpfc_hba *, | |
71 | struct lpfc_nvmet_rcv_ctx *, | |
72 | uint32_t, uint16_t); | |
73 | ||
74 | /** | |
75 | * lpfc_nvmet_xmt_ls_rsp_cmp - Completion handler for LS Response | |
76 | * @phba: Pointer to HBA context object. | |
77 | * @cmdwqe: Pointer to driver command WQE object. | |
78 | * @wcqe: Pointer to driver response CQE object. | |
79 | * | |
80 | * The function is called from SLI ring event handler with no | |
81 | * lock held. This function is the completion handler for NVME LS commands | |
82 | * The function frees memory resources used for the NVME commands. | |
83 | **/ | |
84 | static void | |
85 | lpfc_nvmet_xmt_ls_rsp_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
86 | struct lpfc_wcqe_complete *wcqe) | |
87 | { | |
88 | struct lpfc_nvmet_tgtport *tgtp; | |
89 | struct nvmefc_tgt_ls_req *rsp; | |
90 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
91 | uint32_t status, result; | |
92 | ||
93 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
94 | result = wcqe->parameter; | |
95 | if (!phba->targetport) | |
96 | goto out; | |
97 | ||
98 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
99 | ||
100 | if (status) | |
101 | atomic_inc(&tgtp->xmt_ls_rsp_error); | |
102 | else | |
103 | atomic_inc(&tgtp->xmt_ls_rsp_cmpl); | |
104 | ||
105 | out: | |
106 | ctxp = cmdwqe->context2; | |
107 | rsp = &ctxp->ctx.ls_req; | |
108 | ||
2b65e182 JS |
109 | lpfc_nvmeio_data(phba, "NVMET LS CMPL: xri x%x stat x%x result x%x\n", |
110 | ctxp->oxid, status, result); | |
111 | ||
d613b6a7 JS |
112 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, |
113 | "6038 %s: Entrypoint: ctx %p status %x/%x\n", __func__, | |
114 | ctxp, status, result); | |
115 | ||
116 | lpfc_nlp_put(cmdwqe->context1); | |
117 | cmdwqe->context2 = NULL; | |
118 | cmdwqe->context3 = NULL; | |
119 | lpfc_sli_release_iocbq(phba, cmdwqe); | |
120 | rsp->done(rsp); | |
121 | kfree(ctxp); | |
122 | } | |
123 | ||
124 | /** | |
125 | * lpfc_nvmet_rq_post - Repost a NVMET RQ DMA buffer and clean up context | |
126 | * @phba: HBA buffer is associated with | |
127 | * @ctxp: context to clean up | |
128 | * @mp: Buffer to free | |
129 | * | |
130 | * Description: Frees the given DMA buffer in the appropriate way given by | |
131 | * reposting it to its associated RQ so it can be reused. | |
132 | * | |
133 | * Notes: Takes phba->hbalock. Can be called with or without other locks held. | |
134 | * | |
135 | * Returns: None | |
136 | **/ | |
137 | void | |
138 | lpfc_nvmet_rq_post(struct lpfc_hba *phba, struct lpfc_nvmet_rcv_ctx *ctxp, | |
139 | struct lpfc_dmabuf *mp) | |
140 | { | |
141 | if (ctxp) { | |
142 | if (ctxp->txrdy) { | |
143 | pci_pool_free(phba->txrdy_payload_pool, ctxp->txrdy, | |
144 | ctxp->txrdy_phys); | |
145 | ctxp->txrdy = NULL; | |
146 | ctxp->txrdy_phys = 0; | |
147 | } | |
148 | ctxp->state = LPFC_NVMET_STE_FREE; | |
149 | } | |
150 | lpfc_rq_buf_free(phba, mp); | |
151 | } | |
152 | ||
2b65e182 JS |
153 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
154 | static void | |
155 | lpfc_nvmet_ktime(struct lpfc_hba *phba, | |
156 | struct lpfc_nvmet_rcv_ctx *ctxp) | |
157 | { | |
158 | uint64_t seg1, seg2, seg3, seg4, seg5; | |
159 | uint64_t seg6, seg7, seg8, seg9, seg10; | |
160 | ||
161 | if (!phba->ktime_on) | |
162 | return; | |
163 | ||
164 | if (!ctxp->ts_isr_cmd || !ctxp->ts_cmd_nvme || | |
165 | !ctxp->ts_nvme_data || !ctxp->ts_data_wqput || | |
166 | !ctxp->ts_isr_data || !ctxp->ts_data_nvme || | |
167 | !ctxp->ts_nvme_status || !ctxp->ts_status_wqput || | |
168 | !ctxp->ts_isr_status || !ctxp->ts_status_nvme) | |
169 | return; | |
170 | ||
171 | if (ctxp->ts_isr_cmd > ctxp->ts_cmd_nvme) | |
172 | return; | |
173 | if (ctxp->ts_cmd_nvme > ctxp->ts_nvme_data) | |
174 | return; | |
175 | if (ctxp->ts_nvme_data > ctxp->ts_data_wqput) | |
176 | return; | |
177 | if (ctxp->ts_data_wqput > ctxp->ts_isr_data) | |
178 | return; | |
179 | if (ctxp->ts_isr_data > ctxp->ts_data_nvme) | |
180 | return; | |
181 | if (ctxp->ts_data_nvme > ctxp->ts_nvme_status) | |
182 | return; | |
183 | if (ctxp->ts_nvme_status > ctxp->ts_status_wqput) | |
184 | return; | |
185 | if (ctxp->ts_status_wqput > ctxp->ts_isr_status) | |
186 | return; | |
187 | if (ctxp->ts_isr_status > ctxp->ts_status_nvme) | |
188 | return; | |
189 | /* | |
190 | * Segment 1 - Time from FCP command received by MSI-X ISR | |
191 | * to FCP command is passed to NVME Layer. | |
192 | * Segment 2 - Time from FCP command payload handed | |
193 | * off to NVME Layer to Driver receives a Command op | |
194 | * from NVME Layer. | |
195 | * Segment 3 - Time from Driver receives a Command op | |
196 | * from NVME Layer to Command is put on WQ. | |
197 | * Segment 4 - Time from Driver WQ put is done | |
198 | * to MSI-X ISR for Command cmpl. | |
199 | * Segment 5 - Time from MSI-X ISR for Command cmpl to | |
200 | * Command cmpl is passed to NVME Layer. | |
201 | * Segment 6 - Time from Command cmpl is passed to NVME | |
202 | * Layer to Driver receives a RSP op from NVME Layer. | |
203 | * Segment 7 - Time from Driver receives a RSP op from | |
204 | * NVME Layer to WQ put is done on TRSP FCP Status. | |
205 | * Segment 8 - Time from Driver WQ put is done on TRSP | |
206 | * FCP Status to MSI-X ISR for TRSP cmpl. | |
207 | * Segment 9 - Time from MSI-X ISR for TRSP cmpl to | |
208 | * TRSP cmpl is passed to NVME Layer. | |
209 | * Segment 10 - Time from FCP command received by | |
210 | * MSI-X ISR to command is completed on wire. | |
211 | * (Segments 1 thru 8) for READDATA / WRITEDATA | |
212 | * (Segments 1 thru 4) for READDATA_RSP | |
213 | */ | |
214 | seg1 = ctxp->ts_cmd_nvme - ctxp->ts_isr_cmd; | |
215 | seg2 = (ctxp->ts_nvme_data - ctxp->ts_isr_cmd) - seg1; | |
216 | seg3 = (ctxp->ts_data_wqput - ctxp->ts_isr_cmd) - | |
217 | seg1 - seg2; | |
218 | seg4 = (ctxp->ts_isr_data - ctxp->ts_isr_cmd) - | |
219 | seg1 - seg2 - seg3; | |
220 | seg5 = (ctxp->ts_data_nvme - ctxp->ts_isr_cmd) - | |
221 | seg1 - seg2 - seg3 - seg4; | |
222 | ||
223 | /* For auto rsp commands seg6 thru seg10 will be 0 */ | |
224 | if (ctxp->ts_nvme_status > ctxp->ts_data_nvme) { | |
225 | seg6 = (ctxp->ts_nvme_status - | |
226 | ctxp->ts_isr_cmd) - | |
227 | seg1 - seg2 - seg3 - seg4 - seg5; | |
228 | seg7 = (ctxp->ts_status_wqput - | |
229 | ctxp->ts_isr_cmd) - | |
230 | seg1 - seg2 - seg3 - | |
231 | seg4 - seg5 - seg6; | |
232 | seg8 = (ctxp->ts_isr_status - | |
233 | ctxp->ts_isr_cmd) - | |
234 | seg1 - seg2 - seg3 - seg4 - | |
235 | seg5 - seg6 - seg7; | |
236 | seg9 = (ctxp->ts_status_nvme - | |
237 | ctxp->ts_isr_cmd) - | |
238 | seg1 - seg2 - seg3 - seg4 - | |
239 | seg5 - seg6 - seg7 - seg8; | |
240 | seg10 = (ctxp->ts_isr_status - | |
241 | ctxp->ts_isr_cmd); | |
242 | } else { | |
243 | seg6 = 0; | |
244 | seg7 = 0; | |
245 | seg8 = 0; | |
246 | seg9 = 0; | |
247 | seg10 = (ctxp->ts_isr_data - ctxp->ts_isr_cmd); | |
248 | } | |
249 | ||
250 | phba->ktime_seg1_total += seg1; | |
251 | if (seg1 < phba->ktime_seg1_min) | |
252 | phba->ktime_seg1_min = seg1; | |
253 | else if (seg1 > phba->ktime_seg1_max) | |
254 | phba->ktime_seg1_max = seg1; | |
255 | ||
256 | phba->ktime_seg2_total += seg2; | |
257 | if (seg2 < phba->ktime_seg2_min) | |
258 | phba->ktime_seg2_min = seg2; | |
259 | else if (seg2 > phba->ktime_seg2_max) | |
260 | phba->ktime_seg2_max = seg2; | |
261 | ||
262 | phba->ktime_seg3_total += seg3; | |
263 | if (seg3 < phba->ktime_seg3_min) | |
264 | phba->ktime_seg3_min = seg3; | |
265 | else if (seg3 > phba->ktime_seg3_max) | |
266 | phba->ktime_seg3_max = seg3; | |
267 | ||
268 | phba->ktime_seg4_total += seg4; | |
269 | if (seg4 < phba->ktime_seg4_min) | |
270 | phba->ktime_seg4_min = seg4; | |
271 | else if (seg4 > phba->ktime_seg4_max) | |
272 | phba->ktime_seg4_max = seg4; | |
273 | ||
274 | phba->ktime_seg5_total += seg5; | |
275 | if (seg5 < phba->ktime_seg5_min) | |
276 | phba->ktime_seg5_min = seg5; | |
277 | else if (seg5 > phba->ktime_seg5_max) | |
278 | phba->ktime_seg5_max = seg5; | |
279 | ||
280 | phba->ktime_data_samples++; | |
281 | if (!seg6) | |
282 | goto out; | |
283 | ||
284 | phba->ktime_seg6_total += seg6; | |
285 | if (seg6 < phba->ktime_seg6_min) | |
286 | phba->ktime_seg6_min = seg6; | |
287 | else if (seg6 > phba->ktime_seg6_max) | |
288 | phba->ktime_seg6_max = seg6; | |
289 | ||
290 | phba->ktime_seg7_total += seg7; | |
291 | if (seg7 < phba->ktime_seg7_min) | |
292 | phba->ktime_seg7_min = seg7; | |
293 | else if (seg7 > phba->ktime_seg7_max) | |
294 | phba->ktime_seg7_max = seg7; | |
295 | ||
296 | phba->ktime_seg8_total += seg8; | |
297 | if (seg8 < phba->ktime_seg8_min) | |
298 | phba->ktime_seg8_min = seg8; | |
299 | else if (seg8 > phba->ktime_seg8_max) | |
300 | phba->ktime_seg8_max = seg8; | |
301 | ||
302 | phba->ktime_seg9_total += seg9; | |
303 | if (seg9 < phba->ktime_seg9_min) | |
304 | phba->ktime_seg9_min = seg9; | |
305 | else if (seg9 > phba->ktime_seg9_max) | |
306 | phba->ktime_seg9_max = seg9; | |
307 | out: | |
308 | phba->ktime_seg10_total += seg10; | |
309 | if (seg10 < phba->ktime_seg10_min) | |
310 | phba->ktime_seg10_min = seg10; | |
311 | else if (seg10 > phba->ktime_seg10_max) | |
312 | phba->ktime_seg10_max = seg10; | |
313 | phba->ktime_status_samples++; | |
314 | } | |
315 | #endif | |
316 | ||
d613b6a7 JS |
317 | /** |
318 | * lpfc_nvmet_xmt_fcp_op_cmp - Completion handler for FCP Response | |
319 | * @phba: Pointer to HBA context object. | |
320 | * @cmdwqe: Pointer to driver command WQE object. | |
321 | * @wcqe: Pointer to driver response CQE object. | |
322 | * | |
323 | * The function is called from SLI ring event handler with no | |
324 | * lock held. This function is the completion handler for NVME FCP commands | |
325 | * The function frees memory resources used for the NVME commands. | |
326 | **/ | |
327 | static void | |
328 | lpfc_nvmet_xmt_fcp_op_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
329 | struct lpfc_wcqe_complete *wcqe) | |
330 | { | |
331 | struct lpfc_nvmet_tgtport *tgtp; | |
332 | struct nvmefc_tgt_fcp_req *rsp; | |
333 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
334 | uint32_t status, result, op, start_clean; | |
2b65e182 JS |
335 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
336 | uint32_t id; | |
337 | #endif | |
d613b6a7 JS |
338 | |
339 | ctxp = cmdwqe->context2; | |
340 | rsp = &ctxp->ctx.fcp_req; | |
341 | op = rsp->op; | |
342 | ctxp->flag &= ~LPFC_NVMET_IO_INP; | |
343 | ||
344 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
345 | result = wcqe->parameter; | |
346 | ||
347 | if (!phba->targetport) | |
348 | goto out; | |
349 | ||
2b65e182 JS |
350 | lpfc_nvmeio_data(phba, "NVMET FCP CMPL: xri x%x op x%x status x%x\n", |
351 | ctxp->oxid, op, status); | |
352 | ||
d613b6a7 JS |
353 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; |
354 | if (status) { | |
355 | rsp->fcp_error = NVME_SC_DATA_XFER_ERROR; | |
356 | rsp->transferred_length = 0; | |
357 | atomic_inc(&tgtp->xmt_fcp_rsp_error); | |
358 | } else { | |
359 | rsp->fcp_error = NVME_SC_SUCCESS; | |
360 | if (op == NVMET_FCOP_RSP) | |
361 | rsp->transferred_length = rsp->rsplen; | |
362 | else | |
363 | rsp->transferred_length = rsp->transfer_length; | |
364 | atomic_inc(&tgtp->xmt_fcp_rsp_cmpl); | |
365 | } | |
366 | ||
367 | out: | |
368 | if ((op == NVMET_FCOP_READDATA_RSP) || | |
369 | (op == NVMET_FCOP_RSP)) { | |
370 | /* Sanity check */ | |
371 | ctxp->state = LPFC_NVMET_STE_DONE; | |
372 | ctxp->entry_cnt++; | |
2b65e182 JS |
373 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
374 | if (phba->ktime_on) { | |
375 | if (rsp->op == NVMET_FCOP_READDATA_RSP) { | |
376 | ctxp->ts_isr_data = | |
377 | cmdwqe->isr_timestamp; | |
378 | ctxp->ts_data_nvme = | |
379 | ktime_get_ns(); | |
380 | ctxp->ts_nvme_status = | |
381 | ctxp->ts_data_nvme; | |
382 | ctxp->ts_status_wqput = | |
383 | ctxp->ts_data_nvme; | |
384 | ctxp->ts_isr_status = | |
385 | ctxp->ts_data_nvme; | |
386 | ctxp->ts_status_nvme = | |
387 | ctxp->ts_data_nvme; | |
388 | } else { | |
389 | ctxp->ts_isr_status = | |
390 | cmdwqe->isr_timestamp; | |
391 | ctxp->ts_status_nvme = | |
392 | ktime_get_ns(); | |
393 | } | |
394 | } | |
395 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_IO) { | |
396 | id = smp_processor_id(); | |
397 | if (ctxp->cpu != id) | |
398 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
399 | "6703 CPU Check cmpl: " | |
400 | "cpu %d expect %d\n", | |
401 | id, ctxp->cpu); | |
402 | if (ctxp->cpu < LPFC_CHECK_CPU_CNT) | |
403 | phba->cpucheck_cmpl_io[id]++; | |
404 | } | |
405 | #endif | |
d613b6a7 | 406 | rsp->done(rsp); |
2b65e182 JS |
407 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
408 | if (phba->ktime_on) | |
409 | lpfc_nvmet_ktime(phba, ctxp); | |
410 | #endif | |
d613b6a7 JS |
411 | /* Let Abort cmpl repost the context */ |
412 | if (!(ctxp->flag & LPFC_NVMET_ABORT_OP)) | |
413 | lpfc_nvmet_rq_post(phba, ctxp, &ctxp->rqb_buffer->hbuf); | |
414 | } else { | |
415 | ctxp->entry_cnt++; | |
416 | start_clean = offsetof(struct lpfc_iocbq, wqe); | |
417 | memset(((char *)cmdwqe) + start_clean, 0, | |
418 | (sizeof(struct lpfc_iocbq) - start_clean)); | |
2b65e182 JS |
419 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
420 | if (phba->ktime_on) { | |
421 | ctxp->ts_isr_data = cmdwqe->isr_timestamp; | |
422 | ctxp->ts_data_nvme = ktime_get_ns(); | |
423 | } | |
424 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_IO) { | |
425 | id = smp_processor_id(); | |
426 | if (ctxp->cpu != id) | |
427 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
428 | "6704 CPU Check cmdcmpl: " | |
429 | "cpu %d expect %d\n", | |
430 | id, ctxp->cpu); | |
431 | if (ctxp->cpu < LPFC_CHECK_CPU_CNT) | |
432 | phba->cpucheck_ccmpl_io[id]++; | |
433 | } | |
434 | #endif | |
d613b6a7 JS |
435 | rsp->done(rsp); |
436 | } | |
437 | } | |
438 | ||
439 | static int | |
440 | lpfc_nvmet_xmt_ls_rsp(struct nvmet_fc_target_port *tgtport, | |
441 | struct nvmefc_tgt_ls_req *rsp) | |
442 | { | |
443 | struct lpfc_nvmet_rcv_ctx *ctxp = | |
444 | container_of(rsp, struct lpfc_nvmet_rcv_ctx, ctx.ls_req); | |
445 | struct lpfc_hba *phba = ctxp->phba; | |
446 | struct hbq_dmabuf *nvmebuf = | |
447 | (struct hbq_dmabuf *)ctxp->rqb_buffer; | |
448 | struct lpfc_iocbq *nvmewqeq; | |
449 | struct lpfc_nvmet_tgtport *nvmep = tgtport->private; | |
450 | struct lpfc_dmabuf dmabuf; | |
451 | struct ulp_bde64 bpl; | |
452 | int rc; | |
453 | ||
454 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
455 | "6023 %s: Entrypoint ctx %p %p\n", __func__, | |
456 | ctxp, tgtport); | |
457 | ||
458 | nvmewqeq = lpfc_nvmet_prep_ls_wqe(phba, ctxp, rsp->rspdma, | |
459 | rsp->rsplen); | |
460 | if (nvmewqeq == NULL) { | |
461 | atomic_inc(&nvmep->xmt_ls_drop); | |
462 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
463 | "6150 LS Drop IO x%x: Prep\n", | |
464 | ctxp->oxid); | |
465 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
466 | lpfc_nvmet_unsol_ls_issue_abort(phba, ctxp, | |
467 | ctxp->sid, ctxp->oxid); | |
468 | return -ENOMEM; | |
469 | } | |
470 | ||
471 | /* Save numBdes for bpl2sgl */ | |
472 | nvmewqeq->rsvd2 = 1; | |
473 | nvmewqeq->hba_wqidx = 0; | |
474 | nvmewqeq->context3 = &dmabuf; | |
475 | dmabuf.virt = &bpl; | |
476 | bpl.addrLow = nvmewqeq->wqe.xmit_sequence.bde.addrLow; | |
477 | bpl.addrHigh = nvmewqeq->wqe.xmit_sequence.bde.addrHigh; | |
478 | bpl.tus.f.bdeSize = rsp->rsplen; | |
479 | bpl.tus.f.bdeFlags = 0; | |
480 | bpl.tus.w = le32_to_cpu(bpl.tus.w); | |
481 | ||
482 | nvmewqeq->wqe_cmpl = lpfc_nvmet_xmt_ls_rsp_cmp; | |
483 | nvmewqeq->iocb_cmpl = NULL; | |
484 | nvmewqeq->context2 = ctxp; | |
485 | ||
2b65e182 JS |
486 | lpfc_nvmeio_data(phba, "NVMET LS RESP: xri x%x wqidx x%x len x%x\n", |
487 | ctxp->oxid, nvmewqeq->hba_wqidx, rsp->rsplen); | |
488 | ||
d613b6a7 JS |
489 | rc = lpfc_sli4_issue_wqe(phba, LPFC_ELS_RING, nvmewqeq); |
490 | if (rc == WQE_SUCCESS) { | |
491 | /* | |
492 | * Okay to repost buffer here, but wait till cmpl | |
493 | * before freeing ctxp and iocbq. | |
494 | */ | |
495 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
496 | ctxp->rqb_buffer = 0; | |
497 | atomic_inc(&nvmep->xmt_ls_rsp); | |
498 | return 0; | |
499 | } | |
500 | /* Give back resources */ | |
501 | atomic_inc(&nvmep->xmt_ls_drop); | |
502 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
503 | "6151 LS Drop IO x%x: Issue %d\n", | |
504 | ctxp->oxid, rc); | |
505 | ||
506 | lpfc_nlp_put(nvmewqeq->context1); | |
507 | ||
508 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
509 | lpfc_nvmet_unsol_ls_issue_abort(phba, ctxp, ctxp->sid, ctxp->oxid); | |
510 | return -ENXIO; | |
511 | } | |
512 | ||
513 | static int | |
514 | lpfc_nvmet_xmt_fcp_op(struct nvmet_fc_target_port *tgtport, | |
515 | struct nvmefc_tgt_fcp_req *rsp) | |
516 | { | |
517 | struct lpfc_nvmet_tgtport *lpfc_nvmep = tgtport->private; | |
518 | struct lpfc_nvmet_rcv_ctx *ctxp = | |
519 | container_of(rsp, struct lpfc_nvmet_rcv_ctx, ctx.fcp_req); | |
520 | struct lpfc_hba *phba = ctxp->phba; | |
521 | struct lpfc_iocbq *nvmewqeq; | |
522 | unsigned long iflags; | |
223b78ea | 523 | int rc; |
2b65e182 JS |
524 | |
525 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS | |
526 | if (phba->ktime_on) { | |
527 | if (rsp->op == NVMET_FCOP_RSP) | |
528 | ctxp->ts_nvme_status = ktime_get_ns(); | |
529 | else | |
530 | ctxp->ts_nvme_data = ktime_get_ns(); | |
531 | } | |
532 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_IO) { | |
223b78ea | 533 | int id = smp_processor_id(); |
2b65e182 JS |
534 | ctxp->cpu = id; |
535 | if (id < LPFC_CHECK_CPU_CNT) | |
536 | phba->cpucheck_xmt_io[id]++; | |
537 | if (rsp->hwqid != id) { | |
538 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
539 | "6705 CPU Check OP: " | |
540 | "cpu %d expect %d\n", | |
541 | id, rsp->hwqid); | |
542 | ctxp->cpu = rsp->hwqid; | |
543 | } | |
544 | } | |
545 | #endif | |
d613b6a7 JS |
546 | |
547 | if (rsp->op == NVMET_FCOP_ABORT) { | |
548 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
549 | "6103 Abort op: oxri x%x %d cnt %d\n", | |
550 | ctxp->oxid, ctxp->state, ctxp->entry_cnt); | |
2b65e182 JS |
551 | |
552 | lpfc_nvmeio_data(phba, "NVMET FCP ABRT: " | |
553 | "xri x%x state x%x cnt x%x\n", | |
554 | ctxp->oxid, ctxp->state, ctxp->entry_cnt); | |
555 | ||
d613b6a7 JS |
556 | atomic_inc(&lpfc_nvmep->xmt_fcp_abort); |
557 | ctxp->entry_cnt++; | |
558 | ctxp->flag |= LPFC_NVMET_ABORT_OP; | |
559 | if (ctxp->flag & LPFC_NVMET_IO_INP) | |
560 | lpfc_nvmet_sol_fcp_issue_abort(phba, ctxp, ctxp->sid, | |
561 | ctxp->oxid); | |
562 | else | |
563 | lpfc_nvmet_unsol_fcp_issue_abort(phba, ctxp, ctxp->sid, | |
564 | ctxp->oxid); | |
565 | return 0; | |
566 | } | |
567 | ||
568 | /* Sanity check */ | |
569 | if (ctxp->state == LPFC_NVMET_STE_ABORT) { | |
570 | atomic_inc(&lpfc_nvmep->xmt_fcp_drop); | |
571 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
572 | "6102 Bad state IO x%x aborted\n", | |
573 | ctxp->oxid); | |
a5068b46 | 574 | rc = -ENXIO; |
d613b6a7 JS |
575 | goto aerr; |
576 | } | |
577 | ||
578 | nvmewqeq = lpfc_nvmet_prep_fcp_wqe(phba, ctxp); | |
579 | if (nvmewqeq == NULL) { | |
580 | atomic_inc(&lpfc_nvmep->xmt_fcp_drop); | |
581 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
582 | "6152 FCP Drop IO x%x: Prep\n", | |
583 | ctxp->oxid); | |
a5068b46 | 584 | rc = -ENXIO; |
d613b6a7 JS |
585 | goto aerr; |
586 | } | |
587 | ||
588 | nvmewqeq->wqe_cmpl = lpfc_nvmet_xmt_fcp_op_cmp; | |
589 | nvmewqeq->iocb_cmpl = NULL; | |
590 | nvmewqeq->context2 = ctxp; | |
591 | nvmewqeq->iocb_flag |= LPFC_IO_NVMET; | |
592 | ctxp->wqeq->hba_wqidx = rsp->hwqid; | |
593 | ||
2b65e182 JS |
594 | lpfc_nvmeio_data(phba, "NVMET FCP CMND: xri x%x op x%x len x%x\n", |
595 | ctxp->oxid, rsp->op, rsp->rsplen); | |
596 | ||
d613b6a7 JS |
597 | /* For now we take hbalock */ |
598 | spin_lock_irqsave(&phba->hbalock, iflags); | |
599 | rc = lpfc_sli4_issue_wqe(phba, LPFC_FCP_RING, nvmewqeq); | |
600 | spin_unlock_irqrestore(&phba->hbalock, iflags); | |
601 | if (rc == WQE_SUCCESS) { | |
602 | ctxp->flag |= LPFC_NVMET_IO_INP; | |
2b65e182 JS |
603 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
604 | if (!phba->ktime_on) | |
605 | return 0; | |
606 | if (rsp->op == NVMET_FCOP_RSP) | |
607 | ctxp->ts_status_wqput = ktime_get_ns(); | |
608 | else | |
609 | ctxp->ts_data_wqput = ktime_get_ns(); | |
610 | #endif | |
d613b6a7 JS |
611 | return 0; |
612 | } | |
613 | ||
614 | /* Give back resources */ | |
615 | atomic_inc(&lpfc_nvmep->xmt_fcp_drop); | |
616 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
617 | "6153 FCP Drop IO x%x: Issue: %d\n", | |
618 | ctxp->oxid, rc); | |
619 | ||
620 | ctxp->wqeq->hba_wqidx = 0; | |
621 | nvmewqeq->context2 = NULL; | |
622 | nvmewqeq->context3 = NULL; | |
a5068b46 | 623 | rc = -EBUSY; |
d613b6a7 | 624 | aerr: |
a5068b46 | 625 | return rc; |
d613b6a7 JS |
626 | } |
627 | ||
628 | static void | |
629 | lpfc_nvmet_targetport_delete(struct nvmet_fc_target_port *targetport) | |
630 | { | |
631 | struct lpfc_nvmet_tgtport *tport = targetport->private; | |
632 | ||
633 | /* release any threads waiting for the unreg to complete */ | |
634 | complete(&tport->tport_unreg_done); | |
635 | } | |
636 | ||
637 | static struct nvmet_fc_target_template lpfc_tgttemplate = { | |
638 | .targetport_delete = lpfc_nvmet_targetport_delete, | |
639 | .xmt_ls_rsp = lpfc_nvmet_xmt_ls_rsp, | |
640 | .fcp_op = lpfc_nvmet_xmt_fcp_op, | |
641 | ||
642 | .max_hw_queues = 1, | |
643 | .max_sgl_segments = LPFC_NVMET_DEFAULT_SEGS, | |
644 | .max_dif_sgl_segments = LPFC_NVMET_DEFAULT_SEGS, | |
645 | .dma_boundary = 0xFFFFFFFF, | |
646 | ||
647 | /* optional features */ | |
648 | .target_features = 0, | |
649 | /* sizes of additional private data for data structures */ | |
650 | .target_priv_sz = sizeof(struct lpfc_nvmet_tgtport), | |
651 | }; | |
652 | ||
653 | int | |
654 | lpfc_nvmet_create_targetport(struct lpfc_hba *phba) | |
655 | { | |
656 | struct lpfc_vport *vport = phba->pport; | |
657 | struct lpfc_nvmet_tgtport *tgtp; | |
658 | struct nvmet_fc_port_info pinfo; | |
659 | int error = 0; | |
660 | ||
661 | if (phba->targetport) | |
662 | return 0; | |
663 | ||
664 | memset(&pinfo, 0, sizeof(struct nvmet_fc_port_info)); | |
665 | pinfo.node_name = wwn_to_u64(vport->fc_nodename.u.wwn); | |
666 | pinfo.port_name = wwn_to_u64(vport->fc_portname.u.wwn); | |
667 | pinfo.port_id = vport->fc_myDID; | |
668 | ||
669 | lpfc_tgttemplate.max_hw_queues = phba->cfg_nvme_io_channel; | |
670 | lpfc_tgttemplate.max_sgl_segments = phba->cfg_sg_seg_cnt; | |
671 | lpfc_tgttemplate.target_features = NVMET_FCTGTFEAT_READDATA_RSP | | |
672 | NVMET_FCTGTFEAT_NEEDS_CMD_CPUSCHED; | |
673 | ||
7d708033 | 674 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
675 | error = nvmet_fc_register_targetport(&pinfo, &lpfc_tgttemplate, |
676 | &phba->pcidev->dev, | |
677 | &phba->targetport); | |
166d7211 JS |
678 | #else |
679 | error = -ENOMEM; | |
680 | #endif | |
d613b6a7 JS |
681 | if (error) { |
682 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
683 | "6025 Cannot register NVME targetport " | |
684 | "x%x\n", error); | |
685 | phba->targetport = NULL; | |
686 | } else { | |
687 | tgtp = (struct lpfc_nvmet_tgtport *) | |
688 | phba->targetport->private; | |
689 | tgtp->phba = phba; | |
690 | ||
691 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
692 | "6026 Registered NVME " | |
693 | "targetport: %p, private %p " | |
694 | "portnm %llx nodenm %llx\n", | |
695 | phba->targetport, tgtp, | |
696 | pinfo.port_name, pinfo.node_name); | |
697 | ||
698 | atomic_set(&tgtp->rcv_ls_req_in, 0); | |
699 | atomic_set(&tgtp->rcv_ls_req_out, 0); | |
700 | atomic_set(&tgtp->rcv_ls_req_drop, 0); | |
701 | atomic_set(&tgtp->xmt_ls_abort, 0); | |
702 | atomic_set(&tgtp->xmt_ls_rsp, 0); | |
703 | atomic_set(&tgtp->xmt_ls_drop, 0); | |
704 | atomic_set(&tgtp->xmt_ls_rsp_error, 0); | |
705 | atomic_set(&tgtp->xmt_ls_rsp_cmpl, 0); | |
706 | atomic_set(&tgtp->rcv_fcp_cmd_in, 0); | |
707 | atomic_set(&tgtp->rcv_fcp_cmd_out, 0); | |
708 | atomic_set(&tgtp->rcv_fcp_cmd_drop, 0); | |
709 | atomic_set(&tgtp->xmt_fcp_abort, 0); | |
710 | atomic_set(&tgtp->xmt_fcp_drop, 0); | |
711 | atomic_set(&tgtp->xmt_fcp_read_rsp, 0); | |
712 | atomic_set(&tgtp->xmt_fcp_read, 0); | |
713 | atomic_set(&tgtp->xmt_fcp_write, 0); | |
714 | atomic_set(&tgtp->xmt_fcp_rsp, 0); | |
715 | atomic_set(&tgtp->xmt_fcp_rsp_cmpl, 0); | |
716 | atomic_set(&tgtp->xmt_fcp_rsp_error, 0); | |
717 | atomic_set(&tgtp->xmt_fcp_rsp_drop, 0); | |
718 | atomic_set(&tgtp->xmt_abort_rsp, 0); | |
719 | atomic_set(&tgtp->xmt_abort_rsp_error, 0); | |
720 | atomic_set(&tgtp->xmt_abort_cmpl, 0); | |
721 | } | |
722 | return error; | |
723 | } | |
724 | ||
725 | int | |
726 | lpfc_nvmet_update_targetport(struct lpfc_hba *phba) | |
727 | { | |
728 | struct lpfc_vport *vport = phba->pport; | |
729 | ||
730 | if (!phba->targetport) | |
731 | return 0; | |
732 | ||
733 | lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME, | |
734 | "6007 Update NVMET port %p did x%x\n", | |
735 | phba->targetport, vport->fc_myDID); | |
736 | ||
737 | phba->targetport->port_id = vport->fc_myDID; | |
738 | return 0; | |
739 | } | |
740 | ||
318083ad JS |
741 | /** |
742 | * lpfc_sli4_nvmet_xri_aborted - Fast-path process of nvmet xri abort | |
743 | * @phba: pointer to lpfc hba data structure. | |
744 | * @axri: pointer to the nvmet xri abort wcqe structure. | |
745 | * | |
746 | * This routine is invoked by the worker thread to process a SLI4 fast-path | |
747 | * NVMET aborted xri. | |
748 | **/ | |
749 | void | |
750 | lpfc_sli4_nvmet_xri_aborted(struct lpfc_hba *phba, | |
751 | struct sli4_wcqe_xri_aborted *axri) | |
752 | { | |
753 | /* TODO: work in progress */ | |
754 | } | |
755 | ||
d613b6a7 JS |
756 | void |
757 | lpfc_nvmet_destroy_targetport(struct lpfc_hba *phba) | |
758 | { | |
7d708033 | 759 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
760 | struct lpfc_nvmet_tgtport *tgtp; |
761 | ||
762 | if (phba->nvmet_support == 0) | |
763 | return; | |
764 | if (phba->targetport) { | |
765 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
766 | init_completion(&tgtp->tport_unreg_done); | |
767 | nvmet_fc_unregister_targetport(phba->targetport); | |
768 | wait_for_completion_timeout(&tgtp->tport_unreg_done, 5); | |
769 | } | |
770 | phba->targetport = NULL; | |
166d7211 | 771 | #endif |
d613b6a7 JS |
772 | } |
773 | ||
774 | /** | |
775 | * lpfc_nvmet_unsol_ls_buffer - Process an unsolicited event data buffer | |
776 | * @phba: pointer to lpfc hba data structure. | |
777 | * @pring: pointer to a SLI ring. | |
778 | * @nvmebuf: pointer to lpfc nvme command HBQ data structure. | |
779 | * | |
780 | * This routine is used for processing the WQE associated with a unsolicited | |
781 | * event. It first determines whether there is an existing ndlp that matches | |
782 | * the DID from the unsolicited WQE. If not, it will create a new one with | |
783 | * the DID from the unsolicited WQE. The ELS command from the unsolicited | |
784 | * WQE is then used to invoke the proper routine and to set up proper state | |
785 | * of the discovery state machine. | |
786 | **/ | |
787 | static void | |
788 | lpfc_nvmet_unsol_ls_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, | |
789 | struct hbq_dmabuf *nvmebuf) | |
790 | { | |
7d708033 | 791 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
792 | struct lpfc_nvmet_tgtport *tgtp; |
793 | struct fc_frame_header *fc_hdr; | |
794 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
795 | uint32_t *payload; | |
796 | uint32_t size, oxid, sid, rc; | |
797 | ||
798 | if (!nvmebuf || !phba->targetport) { | |
799 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
800 | "6154 LS Drop IO\n"); | |
2b65e182 JS |
801 | oxid = 0; |
802 | size = 0; | |
803 | sid = 0; | |
d613b6a7 JS |
804 | goto dropit; |
805 | } | |
806 | ||
807 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
808 | payload = (uint32_t *)(nvmebuf->dbuf.virt); | |
809 | fc_hdr = (struct fc_frame_header *)(nvmebuf->hbuf.virt); | |
810 | size = bf_get(lpfc_rcqe_length, &nvmebuf->cq_event.cqe.rcqe_cmpl); | |
811 | oxid = be16_to_cpu(fc_hdr->fh_ox_id); | |
812 | sid = sli4_sid_from_fc_hdr(fc_hdr); | |
813 | ||
814 | ctxp = kzalloc(sizeof(struct lpfc_nvmet_rcv_ctx), GFP_ATOMIC); | |
815 | if (ctxp == NULL) { | |
816 | atomic_inc(&tgtp->rcv_ls_req_drop); | |
817 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
818 | "6155 LS Drop IO x%x: Alloc\n", | |
819 | oxid); | |
820 | dropit: | |
2b65e182 JS |
821 | lpfc_nvmeio_data(phba, "NVMET LS DROP: " |
822 | "xri x%x sz %d from %06x\n", | |
823 | oxid, size, sid); | |
d613b6a7 JS |
824 | if (nvmebuf) |
825 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
826 | return; | |
827 | } | |
828 | ctxp->phba = phba; | |
829 | ctxp->size = size; | |
830 | ctxp->oxid = oxid; | |
831 | ctxp->sid = sid; | |
832 | ctxp->wqeq = NULL; | |
833 | ctxp->state = LPFC_NVMET_STE_RCV; | |
834 | ctxp->rqb_buffer = (void *)nvmebuf; | |
2b65e182 JS |
835 | |
836 | lpfc_nvmeio_data(phba, "NVMET LS RCV: xri x%x sz %d from %06x\n", | |
837 | oxid, size, sid); | |
d613b6a7 JS |
838 | /* |
839 | * The calling sequence should be: | |
840 | * nvmet_fc_rcv_ls_req -> lpfc_nvmet_xmt_ls_rsp/cmp ->_req->done | |
841 | * lpfc_nvmet_xmt_ls_rsp_cmp should free the allocated ctxp. | |
842 | */ | |
843 | atomic_inc(&tgtp->rcv_ls_req_in); | |
844 | rc = nvmet_fc_rcv_ls_req(phba->targetport, &ctxp->ctx.ls_req, | |
845 | payload, size); | |
846 | ||
847 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
848 | "6037 %s: ctx %p sz %d rc %d: %08x %08x %08x " | |
849 | "%08x %08x %08x\n", __func__, ctxp, size, rc, | |
850 | *payload, *(payload+1), *(payload+2), | |
851 | *(payload+3), *(payload+4), *(payload+5)); | |
2b65e182 | 852 | |
d613b6a7 JS |
853 | if (rc == 0) { |
854 | atomic_inc(&tgtp->rcv_ls_req_out); | |
855 | return; | |
856 | } | |
2b65e182 JS |
857 | |
858 | lpfc_nvmeio_data(phba, "NVMET LS DROP: xri x%x sz %d from %06x\n", | |
859 | oxid, size, sid); | |
860 | ||
d613b6a7 JS |
861 | atomic_inc(&tgtp->rcv_ls_req_drop); |
862 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
863 | "6156 LS Drop IO x%x: nvmet_fc_rcv_ls_req %d\n", | |
864 | ctxp->oxid, rc); | |
865 | ||
866 | /* We assume a rcv'ed cmd ALWAYs fits into 1 buffer */ | |
867 | if (nvmebuf) | |
868 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
869 | ||
870 | atomic_inc(&tgtp->xmt_ls_abort); | |
871 | lpfc_nvmet_unsol_ls_issue_abort(phba, ctxp, sid, oxid); | |
166d7211 | 872 | #endif |
d613b6a7 JS |
873 | } |
874 | ||
875 | /** | |
876 | * lpfc_nvmet_unsol_fcp_buffer - Process an unsolicited event data buffer | |
877 | * @phba: pointer to lpfc hba data structure. | |
878 | * @pring: pointer to a SLI ring. | |
879 | * @nvmebuf: pointer to lpfc nvme command HBQ data structure. | |
880 | * | |
881 | * This routine is used for processing the WQE associated with a unsolicited | |
882 | * event. It first determines whether there is an existing ndlp that matches | |
883 | * the DID from the unsolicited WQE. If not, it will create a new one with | |
884 | * the DID from the unsolicited WQE. The ELS command from the unsolicited | |
885 | * WQE is then used to invoke the proper routine and to set up proper state | |
886 | * of the discovery state machine. | |
887 | **/ | |
888 | static void | |
889 | lpfc_nvmet_unsol_fcp_buffer(struct lpfc_hba *phba, | |
890 | struct lpfc_sli_ring *pring, | |
891 | struct rqb_dmabuf *nvmebuf, | |
892 | uint64_t isr_timestamp) | |
893 | { | |
7d708033 | 894 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
895 | struct lpfc_nvmet_rcv_ctx *ctxp; |
896 | struct lpfc_nvmet_tgtport *tgtp; | |
897 | struct fc_frame_header *fc_hdr; | |
898 | uint32_t *payload; | |
899 | uint32_t size, oxid, sid, rc; | |
2b65e182 JS |
900 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
901 | uint32_t id; | |
902 | #endif | |
d613b6a7 | 903 | |
d613b6a7 JS |
904 | if (!nvmebuf || !phba->targetport) { |
905 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
906 | "6157 FCP Drop IO\n"); | |
2b65e182 JS |
907 | oxid = 0; |
908 | size = 0; | |
909 | sid = 0; | |
d613b6a7 JS |
910 | goto dropit; |
911 | } | |
912 | ||
913 | ||
914 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
915 | payload = (uint32_t *)(nvmebuf->dbuf.virt); | |
916 | fc_hdr = (struct fc_frame_header *)(nvmebuf->hbuf.virt); | |
917 | size = nvmebuf->bytes_recv; | |
918 | oxid = be16_to_cpu(fc_hdr->fh_ox_id); | |
919 | sid = sli4_sid_from_fc_hdr(fc_hdr); | |
920 | ||
921 | ctxp = (struct lpfc_nvmet_rcv_ctx *)nvmebuf->context; | |
922 | if (ctxp == NULL) { | |
923 | atomic_inc(&tgtp->rcv_fcp_cmd_drop); | |
924 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
925 | "6158 FCP Drop IO x%x: Alloc\n", | |
926 | oxid); | |
927 | lpfc_nvmet_rq_post(phba, NULL, &nvmebuf->hbuf); | |
928 | /* Cannot send ABTS without context */ | |
929 | return; | |
930 | } | |
931 | memset(ctxp, 0, sizeof(ctxp->ctx)); | |
932 | ctxp->wqeq = NULL; | |
933 | ctxp->txrdy = NULL; | |
934 | ctxp->offset = 0; | |
935 | ctxp->phba = phba; | |
936 | ctxp->size = size; | |
937 | ctxp->oxid = oxid; | |
938 | ctxp->sid = sid; | |
939 | ctxp->state = LPFC_NVMET_STE_RCV; | |
940 | ctxp->rqb_buffer = nvmebuf; | |
941 | ctxp->entry_cnt = 1; | |
942 | ctxp->flag = 0; | |
943 | ||
2b65e182 JS |
944 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
945 | if (phba->ktime_on) { | |
946 | ctxp->ts_isr_cmd = isr_timestamp; | |
947 | ctxp->ts_cmd_nvme = ktime_get_ns(); | |
948 | ctxp->ts_nvme_data = 0; | |
949 | ctxp->ts_data_wqput = 0; | |
950 | ctxp->ts_isr_data = 0; | |
951 | ctxp->ts_data_nvme = 0; | |
952 | ctxp->ts_nvme_status = 0; | |
953 | ctxp->ts_status_wqput = 0; | |
954 | ctxp->ts_isr_status = 0; | |
955 | ctxp->ts_status_nvme = 0; | |
956 | } | |
957 | ||
958 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_RCV) { | |
959 | id = smp_processor_id(); | |
960 | if (id < LPFC_CHECK_CPU_CNT) | |
961 | phba->cpucheck_rcv_io[id]++; | |
962 | } | |
963 | #endif | |
964 | ||
965 | lpfc_nvmeio_data(phba, "NVMET FCP RCV: xri x%x sz %d from %06x\n", | |
966 | oxid, size, sid); | |
967 | ||
d613b6a7 JS |
968 | atomic_inc(&tgtp->rcv_fcp_cmd_in); |
969 | /* | |
970 | * The calling sequence should be: | |
971 | * nvmet_fc_rcv_fcp_req -> lpfc_nvmet_xmt_fcp_op/cmp -> req->done | |
972 | * lpfc_nvmet_xmt_fcp_op_cmp should free the allocated ctxp. | |
973 | */ | |
974 | rc = nvmet_fc_rcv_fcp_req(phba->targetport, &ctxp->ctx.fcp_req, | |
975 | payload, size); | |
976 | ||
977 | /* Process FCP command */ | |
978 | if (rc == 0) { | |
979 | atomic_inc(&tgtp->rcv_fcp_cmd_out); | |
980 | return; | |
981 | } | |
982 | ||
983 | atomic_inc(&tgtp->rcv_fcp_cmd_drop); | |
984 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
318083ad | 985 | "6159 FCP Drop IO x%x: err x%x\n", |
d613b6a7 JS |
986 | ctxp->oxid, rc); |
987 | dropit: | |
2b65e182 JS |
988 | lpfc_nvmeio_data(phba, "NVMET FCP DROP: xri x%x sz %d from %06x\n", |
989 | oxid, size, sid); | |
d613b6a7 JS |
990 | if (oxid) { |
991 | lpfc_nvmet_unsol_fcp_issue_abort(phba, ctxp, sid, oxid); | |
992 | return; | |
993 | } | |
994 | ||
995 | if (nvmebuf) { | |
996 | nvmebuf->iocbq->hba_wqidx = 0; | |
997 | /* We assume a rcv'ed cmd ALWAYs fits into 1 buffer */ | |
998 | lpfc_nvmet_rq_post(phba, NULL, &nvmebuf->hbuf); | |
999 | } | |
166d7211 | 1000 | #endif |
d613b6a7 JS |
1001 | } |
1002 | ||
1003 | /** | |
1004 | * lpfc_nvmet_unsol_ls_event - Process an unsolicited event from an nvme nport | |
1005 | * @phba: pointer to lpfc hba data structure. | |
1006 | * @pring: pointer to a SLI ring. | |
1007 | * @nvmebuf: pointer to received nvme data structure. | |
1008 | * | |
1009 | * This routine is used to process an unsolicited event received from a SLI | |
1010 | * (Service Level Interface) ring. The actual processing of the data buffer | |
1011 | * associated with the unsolicited event is done by invoking the routine | |
1012 | * lpfc_nvmet_unsol_ls_buffer() after properly set up the buffer from the | |
1013 | * SLI RQ on which the unsolicited event was received. | |
1014 | **/ | |
1015 | void | |
1016 | lpfc_nvmet_unsol_ls_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, | |
1017 | struct lpfc_iocbq *piocb) | |
1018 | { | |
1019 | struct lpfc_dmabuf *d_buf; | |
1020 | struct hbq_dmabuf *nvmebuf; | |
1021 | ||
1022 | d_buf = piocb->context2; | |
1023 | nvmebuf = container_of(d_buf, struct hbq_dmabuf, dbuf); | |
1024 | ||
1025 | if (phba->nvmet_support == 0) { | |
1026 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
1027 | return; | |
1028 | } | |
1029 | lpfc_nvmet_unsol_ls_buffer(phba, pring, nvmebuf); | |
1030 | } | |
1031 | ||
1032 | /** | |
1033 | * lpfc_nvmet_unsol_fcp_event - Process an unsolicited event from an nvme nport | |
1034 | * @phba: pointer to lpfc hba data structure. | |
1035 | * @pring: pointer to a SLI ring. | |
1036 | * @nvmebuf: pointer to received nvme data structure. | |
1037 | * | |
1038 | * This routine is used to process an unsolicited event received from a SLI | |
1039 | * (Service Level Interface) ring. The actual processing of the data buffer | |
1040 | * associated with the unsolicited event is done by invoking the routine | |
1041 | * lpfc_nvmet_unsol_fcp_buffer() after properly set up the buffer from the | |
1042 | * SLI RQ on which the unsolicited event was received. | |
1043 | **/ | |
1044 | void | |
1045 | lpfc_nvmet_unsol_fcp_event(struct lpfc_hba *phba, | |
1046 | struct lpfc_sli_ring *pring, | |
1047 | struct rqb_dmabuf *nvmebuf, | |
1048 | uint64_t isr_timestamp) | |
1049 | { | |
1050 | if (phba->nvmet_support == 0) { | |
1051 | lpfc_nvmet_rq_post(phba, NULL, &nvmebuf->hbuf); | |
1052 | return; | |
1053 | } | |
1054 | lpfc_nvmet_unsol_fcp_buffer(phba, pring, nvmebuf, | |
1055 | isr_timestamp); | |
1056 | } | |
1057 | ||
1058 | /** | |
1059 | * lpfc_nvmet_prep_ls_wqe - Allocate and prepare a lpfc wqe data structure | |
1060 | * @phba: pointer to a host N_Port data structure. | |
1061 | * @ctxp: Context info for NVME LS Request | |
1062 | * @rspbuf: DMA buffer of NVME command. | |
1063 | * @rspsize: size of the NVME command. | |
1064 | * | |
1065 | * This routine is used for allocating a lpfc-WQE data structure from | |
1066 | * the driver lpfc-WQE free-list and prepare the WQE with the parameters | |
1067 | * passed into the routine for discovery state machine to issue an Extended | |
1068 | * Link Service (NVME) commands. It is a generic lpfc-WQE allocation | |
1069 | * and preparation routine that is used by all the discovery state machine | |
1070 | * routines and the NVME command-specific fields will be later set up by | |
1071 | * the individual discovery machine routines after calling this routine | |
1072 | * allocating and preparing a generic WQE data structure. It fills in the | |
1073 | * Buffer Descriptor Entries (BDEs), allocates buffers for both command | |
1074 | * payload and response payload (if expected). The reference count on the | |
1075 | * ndlp is incremented by 1 and the reference to the ndlp is put into | |
1076 | * context1 of the WQE data structure for this WQE to hold the ndlp | |
1077 | * reference for the command's callback function to access later. | |
1078 | * | |
1079 | * Return code | |
1080 | * Pointer to the newly allocated/prepared nvme wqe data structure | |
1081 | * NULL - when nvme wqe data structure allocation/preparation failed | |
1082 | **/ | |
1083 | static struct lpfc_iocbq * | |
1084 | lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *phba, | |
1085 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
1086 | dma_addr_t rspbuf, uint16_t rspsize) | |
1087 | { | |
1088 | struct lpfc_nodelist *ndlp; | |
1089 | struct lpfc_iocbq *nvmewqe; | |
1090 | union lpfc_wqe *wqe; | |
1091 | ||
1092 | if (!lpfc_is_link_up(phba)) { | |
1093 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
1094 | "6104 lpfc_nvmet_prep_ls_wqe: link err: " | |
1095 | "NPORT x%x oxid:x%x\n", | |
1096 | ctxp->sid, ctxp->oxid); | |
1097 | return NULL; | |
1098 | } | |
1099 | ||
1100 | /* Allocate buffer for command wqe */ | |
1101 | nvmewqe = lpfc_sli_get_iocbq(phba); | |
1102 | if (nvmewqe == NULL) { | |
1103 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
1104 | "6105 lpfc_nvmet_prep_ls_wqe: No WQE: " | |
1105 | "NPORT x%x oxid:x%x\n", | |
1106 | ctxp->sid, ctxp->oxid); | |
1107 | return NULL; | |
1108 | } | |
1109 | ||
1110 | ndlp = lpfc_findnode_did(phba->pport, ctxp->sid); | |
1111 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
1112 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
1113 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
1114 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
1115 | "6106 lpfc_nvmet_prep_ls_wqe: No ndlp: " | |
1116 | "NPORT x%x oxid:x%x\n", | |
1117 | ctxp->sid, ctxp->oxid); | |
1118 | goto nvme_wqe_free_wqeq_exit; | |
1119 | } | |
1120 | ctxp->wqeq = nvmewqe; | |
1121 | ||
1122 | /* prevent preparing wqe with NULL ndlp reference */ | |
1123 | nvmewqe->context1 = lpfc_nlp_get(ndlp); | |
1124 | if (nvmewqe->context1 == NULL) | |
1125 | goto nvme_wqe_free_wqeq_exit; | |
1126 | nvmewqe->context2 = ctxp; | |
1127 | ||
1128 | wqe = &nvmewqe->wqe; | |
1129 | memset(wqe, 0, sizeof(union lpfc_wqe)); | |
1130 | ||
1131 | /* Words 0 - 2 */ | |
1132 | wqe->xmit_sequence.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1133 | wqe->xmit_sequence.bde.tus.f.bdeSize = rspsize; | |
1134 | wqe->xmit_sequence.bde.addrLow = le32_to_cpu(putPaddrLow(rspbuf)); | |
1135 | wqe->xmit_sequence.bde.addrHigh = le32_to_cpu(putPaddrHigh(rspbuf)); | |
1136 | ||
1137 | /* Word 3 */ | |
1138 | ||
1139 | /* Word 4 */ | |
1140 | ||
1141 | /* Word 5 */ | |
1142 | bf_set(wqe_dfctl, &wqe->xmit_sequence.wge_ctl, 0); | |
1143 | bf_set(wqe_ls, &wqe->xmit_sequence.wge_ctl, 1); | |
1144 | bf_set(wqe_la, &wqe->xmit_sequence.wge_ctl, 0); | |
8b361639 | 1145 | bf_set(wqe_rctl, &wqe->xmit_sequence.wge_ctl, FC_RCTL_ELS4_REP); |
d613b6a7 JS |
1146 | bf_set(wqe_type, &wqe->xmit_sequence.wge_ctl, FC_TYPE_NVME); |
1147 | ||
1148 | /* Word 6 */ | |
1149 | bf_set(wqe_ctxt_tag, &wqe->xmit_sequence.wqe_com, | |
1150 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1151 | bf_set(wqe_xri_tag, &wqe->xmit_sequence.wqe_com, nvmewqe->sli4_xritag); | |
1152 | ||
1153 | /* Word 7 */ | |
1154 | bf_set(wqe_cmnd, &wqe->xmit_sequence.wqe_com, | |
1155 | CMD_XMIT_SEQUENCE64_WQE); | |
1156 | bf_set(wqe_ct, &wqe->xmit_sequence.wqe_com, SLI4_CT_RPI); | |
1157 | bf_set(wqe_class, &wqe->xmit_sequence.wqe_com, CLASS3); | |
1158 | bf_set(wqe_pu, &wqe->xmit_sequence.wqe_com, 0); | |
1159 | ||
1160 | /* Word 8 */ | |
1161 | wqe->xmit_sequence.wqe_com.abort_tag = nvmewqe->iotag; | |
1162 | ||
1163 | /* Word 9 */ | |
1164 | bf_set(wqe_reqtag, &wqe->xmit_sequence.wqe_com, nvmewqe->iotag); | |
1165 | /* Needs to be set by caller */ | |
1166 | bf_set(wqe_rcvoxid, &wqe->xmit_sequence.wqe_com, ctxp->oxid); | |
1167 | ||
1168 | /* Word 10 */ | |
1169 | bf_set(wqe_dbde, &wqe->xmit_sequence.wqe_com, 1); | |
1170 | bf_set(wqe_iod, &wqe->xmit_sequence.wqe_com, LPFC_WQE_IOD_WRITE); | |
1171 | bf_set(wqe_lenloc, &wqe->xmit_sequence.wqe_com, | |
1172 | LPFC_WQE_LENLOC_WORD12); | |
1173 | bf_set(wqe_ebde_cnt, &wqe->xmit_sequence.wqe_com, 0); | |
1174 | ||
1175 | /* Word 11 */ | |
1176 | bf_set(wqe_cqid, &wqe->xmit_sequence.wqe_com, | |
1177 | LPFC_WQE_CQ_ID_DEFAULT); | |
1178 | bf_set(wqe_cmd_type, &wqe->xmit_sequence.wqe_com, | |
1179 | OTHER_COMMAND); | |
1180 | ||
1181 | /* Word 12 */ | |
1182 | wqe->xmit_sequence.xmit_len = rspsize; | |
1183 | ||
1184 | nvmewqe->retry = 1; | |
1185 | nvmewqe->vport = phba->pport; | |
1186 | nvmewqe->drvrTimeout = (phba->fc_ratov * 3) + LPFC_DRVR_TIMEOUT; | |
1187 | nvmewqe->iocb_flag |= LPFC_IO_NVME_LS; | |
1188 | ||
1189 | /* Xmit NVME response to remote NPORT <did> */ | |
1190 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
1191 | "6039 Xmit NVME LS response to remote " | |
1192 | "NPORT x%x iotag:x%x oxid:x%x size:x%x\n", | |
1193 | ndlp->nlp_DID, nvmewqe->iotag, ctxp->oxid, | |
1194 | rspsize); | |
1195 | return nvmewqe; | |
1196 | ||
1197 | nvme_wqe_free_wqeq_exit: | |
1198 | nvmewqe->context2 = NULL; | |
1199 | nvmewqe->context3 = NULL; | |
1200 | lpfc_sli_release_iocbq(phba, nvmewqe); | |
1201 | return NULL; | |
1202 | } | |
1203 | ||
1204 | ||
1205 | static struct lpfc_iocbq * | |
1206 | lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba, | |
1207 | struct lpfc_nvmet_rcv_ctx *ctxp) | |
1208 | { | |
1209 | struct nvmefc_tgt_fcp_req *rsp = &ctxp->ctx.fcp_req; | |
1210 | struct lpfc_nvmet_tgtport *tgtp; | |
1211 | struct sli4_sge *sgl; | |
1212 | struct lpfc_nodelist *ndlp; | |
1213 | struct lpfc_iocbq *nvmewqe; | |
1214 | struct scatterlist *sgel; | |
1215 | union lpfc_wqe128 *wqe; | |
1216 | uint32_t *txrdy; | |
1217 | dma_addr_t physaddr; | |
1218 | int i, cnt; | |
1219 | int xc = 1; | |
1220 | ||
1221 | if (!lpfc_is_link_up(phba)) { | |
1222 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1223 | "6107 lpfc_nvmet_prep_fcp_wqe: link err:" | |
1224 | "NPORT x%x oxid:x%x\n", ctxp->sid, | |
1225 | ctxp->oxid); | |
1226 | return NULL; | |
1227 | } | |
1228 | ||
1229 | ndlp = lpfc_findnode_did(phba->pport, ctxp->sid); | |
1230 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
1231 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
1232 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
1233 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1234 | "6108 lpfc_nvmet_prep_fcp_wqe: no ndlp: " | |
1235 | "NPORT x%x oxid:x%x\n", | |
1236 | ctxp->sid, ctxp->oxid); | |
1237 | return NULL; | |
1238 | } | |
1239 | ||
1240 | if (rsp->sg_cnt > phba->cfg_sg_seg_cnt) { | |
1241 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1242 | "6109 lpfc_nvmet_prep_fcp_wqe: seg cnt err: " | |
1243 | "NPORT x%x oxid:x%x\n", | |
1244 | ctxp->sid, ctxp->oxid); | |
1245 | return NULL; | |
1246 | } | |
1247 | ||
1248 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1249 | nvmewqe = ctxp->wqeq; | |
1250 | if (nvmewqe == NULL) { | |
1251 | /* Allocate buffer for command wqe */ | |
1252 | nvmewqe = ctxp->rqb_buffer->iocbq; | |
1253 | if (nvmewqe == NULL) { | |
1254 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1255 | "6110 lpfc_nvmet_prep_fcp_wqe: No " | |
1256 | "WQE: NPORT x%x oxid:x%x\n", | |
1257 | ctxp->sid, ctxp->oxid); | |
1258 | return NULL; | |
1259 | } | |
1260 | ctxp->wqeq = nvmewqe; | |
1261 | xc = 0; /* create new XRI */ | |
1262 | nvmewqe->sli4_lxritag = NO_XRI; | |
1263 | nvmewqe->sli4_xritag = NO_XRI; | |
1264 | } | |
1265 | ||
1266 | /* Sanity check */ | |
1267 | if (((ctxp->state == LPFC_NVMET_STE_RCV) && | |
1268 | (ctxp->entry_cnt == 1)) || | |
1269 | ((ctxp->state == LPFC_NVMET_STE_DATA) && | |
1270 | (ctxp->entry_cnt > 1))) { | |
1271 | wqe = (union lpfc_wqe128 *)&nvmewqe->wqe; | |
1272 | } else { | |
1273 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1274 | "6111 Wrong state %s: %d cnt %d\n", | |
1275 | __func__, ctxp->state, ctxp->entry_cnt); | |
1276 | return NULL; | |
1277 | } | |
1278 | ||
1279 | sgl = (struct sli4_sge *)ctxp->rqb_buffer->sglq->sgl; | |
1280 | switch (rsp->op) { | |
1281 | case NVMET_FCOP_READDATA: | |
1282 | case NVMET_FCOP_READDATA_RSP: | |
1283 | /* Words 0 - 2 : The first sg segment */ | |
1284 | sgel = &rsp->sg[0]; | |
1285 | physaddr = sg_dma_address(sgel); | |
1286 | wqe->fcp_tsend.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1287 | wqe->fcp_tsend.bde.tus.f.bdeSize = sg_dma_len(sgel); | |
1288 | wqe->fcp_tsend.bde.addrLow = cpu_to_le32(putPaddrLow(physaddr)); | |
1289 | wqe->fcp_tsend.bde.addrHigh = | |
1290 | cpu_to_le32(putPaddrHigh(physaddr)); | |
1291 | ||
1292 | /* Word 3 */ | |
1293 | wqe->fcp_tsend.payload_offset_len = 0; | |
1294 | ||
1295 | /* Word 4 */ | |
1296 | wqe->fcp_tsend.relative_offset = ctxp->offset; | |
1297 | ||
1298 | /* Word 5 */ | |
1299 | ||
1300 | /* Word 6 */ | |
1301 | bf_set(wqe_ctxt_tag, &wqe->fcp_tsend.wqe_com, | |
1302 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1303 | bf_set(wqe_xri_tag, &wqe->fcp_tsend.wqe_com, | |
1304 | nvmewqe->sli4_xritag); | |
1305 | ||
1306 | /* Word 7 */ | |
1307 | bf_set(wqe_cmnd, &wqe->fcp_tsend.wqe_com, CMD_FCP_TSEND64_WQE); | |
1308 | ||
1309 | /* Word 8 */ | |
1310 | wqe->fcp_tsend.wqe_com.abort_tag = nvmewqe->iotag; | |
1311 | ||
1312 | /* Word 9 */ | |
1313 | bf_set(wqe_reqtag, &wqe->fcp_tsend.wqe_com, nvmewqe->iotag); | |
1314 | bf_set(wqe_rcvoxid, &wqe->fcp_tsend.wqe_com, ctxp->oxid); | |
1315 | ||
1316 | /* Word 10 */ | |
1317 | bf_set(wqe_nvme, &wqe->fcp_tsend.wqe_com, 1); | |
1318 | bf_set(wqe_dbde, &wqe->fcp_tsend.wqe_com, 1); | |
1319 | bf_set(wqe_iod, &wqe->fcp_tsend.wqe_com, LPFC_WQE_IOD_WRITE); | |
1320 | bf_set(wqe_lenloc, &wqe->fcp_tsend.wqe_com, | |
1321 | LPFC_WQE_LENLOC_WORD12); | |
1322 | bf_set(wqe_ebde_cnt, &wqe->fcp_tsend.wqe_com, 0); | |
1323 | bf_set(wqe_xc, &wqe->fcp_tsend.wqe_com, xc); | |
1324 | bf_set(wqe_nvme, &wqe->fcp_tsend.wqe_com, 1); | |
1325 | if (phba->cfg_nvme_oas) | |
1326 | bf_set(wqe_oas, &wqe->fcp_tsend.wqe_com, 1); | |
1327 | ||
1328 | /* Word 11 */ | |
1329 | bf_set(wqe_cqid, &wqe->fcp_tsend.wqe_com, | |
1330 | LPFC_WQE_CQ_ID_DEFAULT); | |
1331 | bf_set(wqe_cmd_type, &wqe->fcp_tsend.wqe_com, | |
1332 | FCP_COMMAND_TSEND); | |
1333 | ||
1334 | /* Word 12 */ | |
1335 | wqe->fcp_tsend.fcp_data_len = rsp->transfer_length; | |
1336 | ||
1337 | /* Setup 2 SKIP SGEs */ | |
1338 | sgl->addr_hi = 0; | |
1339 | sgl->addr_lo = 0; | |
1340 | sgl->word2 = 0; | |
1341 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_SKIP); | |
1342 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1343 | sgl->sge_len = 0; | |
1344 | sgl++; | |
1345 | sgl->addr_hi = 0; | |
1346 | sgl->addr_lo = 0; | |
1347 | sgl->word2 = 0; | |
1348 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_SKIP); | |
1349 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1350 | sgl->sge_len = 0; | |
1351 | sgl++; | |
1352 | if (rsp->op == NVMET_FCOP_READDATA_RSP) { | |
1353 | atomic_inc(&tgtp->xmt_fcp_read_rsp); | |
1354 | bf_set(wqe_ar, &wqe->fcp_tsend.wqe_com, 1); | |
1355 | if ((ndlp->nlp_flag & NLP_SUPPRESS_RSP) && | |
1356 | (rsp->rsplen == 12)) { | |
1357 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 1); | |
1358 | bf_set(wqe_wqes, &wqe->fcp_tsend.wqe_com, 0); | |
1359 | bf_set(wqe_irsp, &wqe->fcp_tsend.wqe_com, 0); | |
1360 | bf_set(wqe_irsplen, &wqe->fcp_tsend.wqe_com, 0); | |
1361 | } else { | |
1362 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1363 | bf_set(wqe_wqes, &wqe->fcp_tsend.wqe_com, 1); | |
1364 | bf_set(wqe_irsp, &wqe->fcp_tsend.wqe_com, 1); | |
1365 | bf_set(wqe_irsplen, &wqe->fcp_tsend.wqe_com, | |
1366 | ((rsp->rsplen >> 2) - 1)); | |
1367 | memcpy(&wqe->words[16], rsp->rspaddr, | |
1368 | rsp->rsplen); | |
1369 | } | |
1370 | } else { | |
1371 | atomic_inc(&tgtp->xmt_fcp_read); | |
1372 | ||
1373 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1374 | bf_set(wqe_wqes, &wqe->fcp_tsend.wqe_com, 0); | |
1375 | bf_set(wqe_irsp, &wqe->fcp_tsend.wqe_com, 0); | |
1376 | bf_set(wqe_ar, &wqe->fcp_tsend.wqe_com, 0); | |
1377 | bf_set(wqe_irsplen, &wqe->fcp_tsend.wqe_com, 0); | |
1378 | } | |
1379 | ctxp->state = LPFC_NVMET_STE_DATA; | |
1380 | break; | |
1381 | ||
1382 | case NVMET_FCOP_WRITEDATA: | |
1383 | /* Words 0 - 2 : The first sg segment */ | |
1384 | txrdy = pci_pool_alloc(phba->txrdy_payload_pool, | |
1385 | GFP_KERNEL, &physaddr); | |
1386 | if (!txrdy) { | |
1387 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1388 | "6041 Bad txrdy buffer: oxid x%x\n", | |
1389 | ctxp->oxid); | |
1390 | return NULL; | |
1391 | } | |
1392 | ctxp->txrdy = txrdy; | |
1393 | ctxp->txrdy_phys = physaddr; | |
1394 | wqe->fcp_treceive.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1395 | wqe->fcp_treceive.bde.tus.f.bdeSize = TXRDY_PAYLOAD_LEN; | |
1396 | wqe->fcp_treceive.bde.addrLow = | |
1397 | cpu_to_le32(putPaddrLow(physaddr)); | |
1398 | wqe->fcp_treceive.bde.addrHigh = | |
1399 | cpu_to_le32(putPaddrHigh(physaddr)); | |
1400 | ||
1401 | /* Word 3 */ | |
1402 | wqe->fcp_treceive.payload_offset_len = TXRDY_PAYLOAD_LEN; | |
1403 | ||
1404 | /* Word 4 */ | |
1405 | wqe->fcp_treceive.relative_offset = ctxp->offset; | |
1406 | ||
1407 | /* Word 5 */ | |
1408 | ||
1409 | /* Word 6 */ | |
1410 | bf_set(wqe_ctxt_tag, &wqe->fcp_treceive.wqe_com, | |
1411 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1412 | bf_set(wqe_xri_tag, &wqe->fcp_treceive.wqe_com, | |
1413 | nvmewqe->sli4_xritag); | |
1414 | ||
1415 | /* Word 7 */ | |
1416 | bf_set(wqe_ar, &wqe->fcp_treceive.wqe_com, 0); | |
1417 | bf_set(wqe_cmnd, &wqe->fcp_treceive.wqe_com, | |
1418 | CMD_FCP_TRECEIVE64_WQE); | |
1419 | ||
1420 | /* Word 8 */ | |
1421 | wqe->fcp_treceive.wqe_com.abort_tag = nvmewqe->iotag; | |
1422 | ||
1423 | /* Word 9 */ | |
1424 | bf_set(wqe_reqtag, &wqe->fcp_treceive.wqe_com, nvmewqe->iotag); | |
1425 | bf_set(wqe_rcvoxid, &wqe->fcp_treceive.wqe_com, ctxp->oxid); | |
1426 | ||
1427 | /* Word 10 */ | |
1428 | bf_set(wqe_nvme, &wqe->fcp_treceive.wqe_com, 1); | |
1429 | bf_set(wqe_dbde, &wqe->fcp_treceive.wqe_com, 1); | |
1430 | bf_set(wqe_iod, &wqe->fcp_treceive.wqe_com, LPFC_WQE_IOD_READ); | |
1431 | bf_set(wqe_lenloc, &wqe->fcp_treceive.wqe_com, | |
1432 | LPFC_WQE_LENLOC_WORD12); | |
1433 | bf_set(wqe_xc, &wqe->fcp_treceive.wqe_com, xc); | |
1434 | bf_set(wqe_wqes, &wqe->fcp_treceive.wqe_com, 0); | |
1435 | bf_set(wqe_irsp, &wqe->fcp_treceive.wqe_com, 0); | |
1436 | bf_set(wqe_irsplen, &wqe->fcp_treceive.wqe_com, 0); | |
1437 | bf_set(wqe_nvme, &wqe->fcp_treceive.wqe_com, 1); | |
1438 | if (phba->cfg_nvme_oas) | |
1439 | bf_set(wqe_oas, &wqe->fcp_treceive.wqe_com, 1); | |
1440 | ||
1441 | /* Word 11 */ | |
1442 | bf_set(wqe_cqid, &wqe->fcp_treceive.wqe_com, | |
1443 | LPFC_WQE_CQ_ID_DEFAULT); | |
1444 | bf_set(wqe_cmd_type, &wqe->fcp_treceive.wqe_com, | |
1445 | FCP_COMMAND_TRECEIVE); | |
1446 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1447 | ||
1448 | /* Word 12 */ | |
1449 | wqe->fcp_tsend.fcp_data_len = rsp->transfer_length; | |
1450 | ||
1451 | /* Setup 1 TXRDY and 1 SKIP SGE */ | |
1452 | txrdy[0] = 0; | |
1453 | txrdy[1] = cpu_to_be32(rsp->transfer_length); | |
1454 | txrdy[2] = 0; | |
1455 | ||
1456 | sgl->addr_hi = putPaddrHigh(physaddr); | |
1457 | sgl->addr_lo = putPaddrLow(physaddr); | |
1458 | sgl->word2 = 0; | |
1459 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA); | |
1460 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1461 | sgl->sge_len = cpu_to_le32(TXRDY_PAYLOAD_LEN); | |
1462 | sgl++; | |
1463 | sgl->addr_hi = 0; | |
1464 | sgl->addr_lo = 0; | |
1465 | sgl->word2 = 0; | |
1466 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_SKIP); | |
1467 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1468 | sgl->sge_len = 0; | |
1469 | sgl++; | |
1470 | ctxp->state = LPFC_NVMET_STE_DATA; | |
1471 | atomic_inc(&tgtp->xmt_fcp_write); | |
1472 | break; | |
1473 | ||
1474 | case NVMET_FCOP_RSP: | |
1475 | /* Words 0 - 2 */ | |
d613b6a7 JS |
1476 | physaddr = rsp->rspdma; |
1477 | wqe->fcp_trsp.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1478 | wqe->fcp_trsp.bde.tus.f.bdeSize = rsp->rsplen; | |
1479 | wqe->fcp_trsp.bde.addrLow = | |
1480 | cpu_to_le32(putPaddrLow(physaddr)); | |
1481 | wqe->fcp_trsp.bde.addrHigh = | |
1482 | cpu_to_le32(putPaddrHigh(physaddr)); | |
1483 | ||
1484 | /* Word 3 */ | |
1485 | wqe->fcp_trsp.response_len = rsp->rsplen; | |
1486 | ||
1487 | /* Word 4 */ | |
1488 | wqe->fcp_trsp.rsvd_4_5[0] = 0; | |
1489 | ||
1490 | ||
1491 | /* Word 5 */ | |
1492 | ||
1493 | /* Word 6 */ | |
1494 | bf_set(wqe_ctxt_tag, &wqe->fcp_trsp.wqe_com, | |
1495 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1496 | bf_set(wqe_xri_tag, &wqe->fcp_trsp.wqe_com, | |
1497 | nvmewqe->sli4_xritag); | |
1498 | ||
1499 | /* Word 7 */ | |
1500 | bf_set(wqe_ag, &wqe->fcp_trsp.wqe_com, 1); | |
1501 | bf_set(wqe_cmnd, &wqe->fcp_trsp.wqe_com, CMD_FCP_TRSP64_WQE); | |
1502 | ||
1503 | /* Word 8 */ | |
1504 | wqe->fcp_trsp.wqe_com.abort_tag = nvmewqe->iotag; | |
1505 | ||
1506 | /* Word 9 */ | |
1507 | bf_set(wqe_reqtag, &wqe->fcp_trsp.wqe_com, nvmewqe->iotag); | |
1508 | bf_set(wqe_rcvoxid, &wqe->fcp_trsp.wqe_com, ctxp->oxid); | |
1509 | ||
1510 | /* Word 10 */ | |
1511 | bf_set(wqe_nvme, &wqe->fcp_trsp.wqe_com, 1); | |
1512 | bf_set(wqe_dbde, &wqe->fcp_trsp.wqe_com, 0); | |
1513 | bf_set(wqe_iod, &wqe->fcp_trsp.wqe_com, LPFC_WQE_IOD_WRITE); | |
1514 | bf_set(wqe_lenloc, &wqe->fcp_trsp.wqe_com, | |
1515 | LPFC_WQE_LENLOC_WORD3); | |
1516 | bf_set(wqe_xc, &wqe->fcp_trsp.wqe_com, xc); | |
1517 | bf_set(wqe_nvme, &wqe->fcp_trsp.wqe_com, 1); | |
1518 | if (phba->cfg_nvme_oas) | |
1519 | bf_set(wqe_oas, &wqe->fcp_trsp.wqe_com, 1); | |
1520 | ||
1521 | /* Word 11 */ | |
1522 | bf_set(wqe_cqid, &wqe->fcp_trsp.wqe_com, | |
1523 | LPFC_WQE_CQ_ID_DEFAULT); | |
1524 | bf_set(wqe_cmd_type, &wqe->fcp_trsp.wqe_com, | |
1525 | FCP_COMMAND_TRSP); | |
1526 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1527 | ctxp->state = LPFC_NVMET_STE_RSP; | |
1528 | ||
1529 | if (rsp->rsplen == LPFC_NVMET_SUCCESS_LEN) { | |
1530 | /* Good response - all zero's on wire */ | |
1531 | bf_set(wqe_wqes, &wqe->fcp_trsp.wqe_com, 0); | |
1532 | bf_set(wqe_irsp, &wqe->fcp_trsp.wqe_com, 0); | |
1533 | bf_set(wqe_irsplen, &wqe->fcp_trsp.wqe_com, 0); | |
1534 | } else { | |
1535 | bf_set(wqe_wqes, &wqe->fcp_trsp.wqe_com, 1); | |
1536 | bf_set(wqe_irsp, &wqe->fcp_trsp.wqe_com, 1); | |
1537 | bf_set(wqe_irsplen, &wqe->fcp_trsp.wqe_com, | |
1538 | ((rsp->rsplen >> 2) - 1)); | |
1539 | memcpy(&wqe->words[16], rsp->rspaddr, rsp->rsplen); | |
1540 | } | |
1541 | ||
1542 | /* Use rspbuf, NOT sg list */ | |
1543 | rsp->sg_cnt = 0; | |
1544 | sgl->word2 = 0; | |
1545 | atomic_inc(&tgtp->xmt_fcp_rsp); | |
1546 | break; | |
1547 | ||
1548 | default: | |
1549 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_IOERR, | |
1550 | "6064 Unknown Rsp Op %d\n", | |
1551 | rsp->op); | |
1552 | return NULL; | |
1553 | } | |
1554 | ||
1555 | nvmewqe->retry = 1; | |
1556 | nvmewqe->vport = phba->pport; | |
1557 | nvmewqe->drvrTimeout = (phba->fc_ratov * 3) + LPFC_DRVR_TIMEOUT; | |
1558 | nvmewqe->context1 = ndlp; | |
1559 | ||
1560 | for (i = 0; i < rsp->sg_cnt; i++) { | |
1561 | sgel = &rsp->sg[i]; | |
1562 | physaddr = sg_dma_address(sgel); | |
1563 | cnt = sg_dma_len(sgel); | |
1564 | sgl->addr_hi = putPaddrHigh(physaddr); | |
1565 | sgl->addr_lo = putPaddrLow(physaddr); | |
1566 | sgl->word2 = 0; | |
1567 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA); | |
1568 | bf_set(lpfc_sli4_sge_offset, sgl, ctxp->offset); | |
1569 | if ((i+1) == rsp->sg_cnt) | |
1570 | bf_set(lpfc_sli4_sge_last, sgl, 1); | |
1571 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1572 | sgl->sge_len = cpu_to_le32(cnt); | |
1573 | sgl++; | |
1574 | ctxp->offset += cnt; | |
1575 | } | |
1576 | return nvmewqe; | |
1577 | } | |
1578 | ||
1579 | /** | |
1580 | * lpfc_nvmet_sol_fcp_abort_cmp - Completion handler for ABTS | |
1581 | * @phba: Pointer to HBA context object. | |
1582 | * @cmdwqe: Pointer to driver command WQE object. | |
1583 | * @wcqe: Pointer to driver response CQE object. | |
1584 | * | |
1585 | * The function is called from SLI ring event handler with no | |
1586 | * lock held. This function is the completion handler for NVME ABTS for FCP cmds | |
1587 | * The function frees memory resources used for the NVME commands. | |
1588 | **/ | |
1589 | static void | |
1590 | lpfc_nvmet_sol_fcp_abort_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
1591 | struct lpfc_wcqe_complete *wcqe) | |
1592 | { | |
1593 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
1594 | struct lpfc_nvmet_tgtport *tgtp; | |
1595 | uint32_t status, result; | |
1596 | ||
1597 | ctxp = cmdwqe->context2; | |
1598 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
1599 | result = wcqe->parameter; | |
1600 | ||
1601 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1602 | atomic_inc(&tgtp->xmt_abort_cmpl); | |
1603 | ||
1604 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS, | |
1605 | "6165 Abort cmpl: xri x%x WCQE: %08x %08x %08x %08x\n", | |
1606 | ctxp->oxid, wcqe->word0, wcqe->total_data_placed, | |
1607 | result, wcqe->word3); | |
1608 | ||
1609 | ctxp->state = LPFC_NVMET_STE_DONE; | |
1610 | lpfc_nvmet_rq_post(phba, ctxp, &ctxp->rqb_buffer->hbuf); | |
1611 | ||
1612 | cmdwqe->context2 = NULL; | |
1613 | cmdwqe->context3 = NULL; | |
1614 | lpfc_sli_release_iocbq(phba, cmdwqe); | |
1615 | } | |
1616 | ||
1617 | /** | |
1618 | * lpfc_nvmet_xmt_fcp_abort_cmp - Completion handler for ABTS | |
1619 | * @phba: Pointer to HBA context object. | |
1620 | * @cmdwqe: Pointer to driver command WQE object. | |
1621 | * @wcqe: Pointer to driver response CQE object. | |
1622 | * | |
1623 | * The function is called from SLI ring event handler with no | |
1624 | * lock held. This function is the completion handler for NVME ABTS for FCP cmds | |
1625 | * The function frees memory resources used for the NVME commands. | |
1626 | **/ | |
1627 | static void | |
1628 | lpfc_nvmet_xmt_fcp_abort_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
1629 | struct lpfc_wcqe_complete *wcqe) | |
1630 | { | |
1631 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
1632 | struct lpfc_nvmet_tgtport *tgtp; | |
1633 | uint32_t status, result; | |
1634 | ||
1635 | ctxp = cmdwqe->context2; | |
1636 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
1637 | result = wcqe->parameter; | |
1638 | ||
1639 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1640 | atomic_inc(&tgtp->xmt_abort_cmpl); | |
1641 | ||
1642 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
1643 | "6070 Abort cmpl: ctx %p WCQE: %08x %08x %08x %08x\n", | |
1644 | ctxp, wcqe->word0, wcqe->total_data_placed, | |
1645 | result, wcqe->word3); | |
1646 | ||
1647 | if (ctxp) { | |
1648 | /* Sanity check */ | |
1649 | if (ctxp->state != LPFC_NVMET_STE_ABORT) { | |
1650 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS, | |
1651 | "6112 ABORT Wrong state:%d oxid x%x\n", | |
1652 | ctxp->state, ctxp->oxid); | |
1653 | } | |
1654 | ctxp->state = LPFC_NVMET_STE_DONE; | |
1655 | lpfc_nvmet_rq_post(phba, ctxp, &ctxp->rqb_buffer->hbuf); | |
1656 | cmdwqe->context2 = NULL; | |
1657 | cmdwqe->context3 = NULL; | |
1658 | } | |
1659 | } | |
1660 | ||
1661 | /** | |
1662 | * lpfc_nvmet_xmt_ls_abort_cmp - Completion handler for ABTS | |
1663 | * @phba: Pointer to HBA context object. | |
1664 | * @cmdwqe: Pointer to driver command WQE object. | |
1665 | * @wcqe: Pointer to driver response CQE object. | |
1666 | * | |
1667 | * The function is called from SLI ring event handler with no | |
1668 | * lock held. This function is the completion handler for NVME ABTS for LS cmds | |
1669 | * The function frees memory resources used for the NVME commands. | |
1670 | **/ | |
1671 | static void | |
1672 | lpfc_nvmet_xmt_ls_abort_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
1673 | struct lpfc_wcqe_complete *wcqe) | |
1674 | { | |
1675 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
1676 | struct lpfc_nvmet_tgtport *tgtp; | |
1677 | uint32_t status, result; | |
1678 | ||
1679 | ctxp = cmdwqe->context2; | |
1680 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
1681 | result = wcqe->parameter; | |
1682 | ||
1683 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1684 | atomic_inc(&tgtp->xmt_abort_cmpl); | |
1685 | ||
1686 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
1687 | "6083 Abort cmpl: ctx %p WCQE: %08x %08x %08x %08x\n", | |
1688 | ctxp, wcqe->word0, wcqe->total_data_placed, | |
1689 | result, wcqe->word3); | |
1690 | ||
1691 | if (ctxp) { | |
1692 | cmdwqe->context2 = NULL; | |
1693 | cmdwqe->context3 = NULL; | |
1694 | lpfc_sli_release_iocbq(phba, cmdwqe); | |
1695 | kfree(ctxp); | |
1696 | } else | |
1697 | lpfc_sli_release_iocbq(phba, cmdwqe); | |
1698 | } | |
1699 | ||
1700 | static int | |
1701 | lpfc_nvmet_unsol_issue_abort(struct lpfc_hba *phba, | |
1702 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
1703 | uint32_t sid, uint16_t xri) | |
1704 | { | |
1705 | struct lpfc_nvmet_tgtport *tgtp; | |
1706 | struct lpfc_iocbq *abts_wqeq; | |
1707 | union lpfc_wqe *wqe_abts; | |
1708 | struct lpfc_nodelist *ndlp; | |
1709 | ||
1710 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
318083ad JS |
1711 | "6067 Abort: sid %x xri x%x/x%x\n", |
1712 | sid, xri, ctxp->wqeq->sli4_xritag); | |
d613b6a7 JS |
1713 | |
1714 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1715 | ||
1716 | ndlp = lpfc_findnode_did(phba->pport, sid); | |
1717 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
1718 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
1719 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
1720 | atomic_inc(&tgtp->xmt_abort_rsp_error); | |
1721 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
1722 | "6134 Drop ABTS - wrong NDLP state x%x.\n", | |
b5ccc7d6 | 1723 | (ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE); |
d613b6a7 JS |
1724 | |
1725 | /* No failure to an ABTS request. */ | |
1726 | return 0; | |
1727 | } | |
1728 | ||
1729 | abts_wqeq = ctxp->wqeq; | |
1730 | wqe_abts = &abts_wqeq->wqe; | |
1731 | ctxp->state = LPFC_NVMET_STE_ABORT; | |
1732 | ||
1733 | /* | |
1734 | * Since we zero the whole WQE, we need to ensure we set the WQE fields | |
1735 | * that were initialized in lpfc_sli4_nvmet_alloc. | |
1736 | */ | |
1737 | memset(wqe_abts, 0, sizeof(union lpfc_wqe)); | |
1738 | ||
1739 | /* Word 5 */ | |
1740 | bf_set(wqe_dfctl, &wqe_abts->xmit_sequence.wge_ctl, 0); | |
1741 | bf_set(wqe_ls, &wqe_abts->xmit_sequence.wge_ctl, 1); | |
1742 | bf_set(wqe_la, &wqe_abts->xmit_sequence.wge_ctl, 0); | |
1743 | bf_set(wqe_rctl, &wqe_abts->xmit_sequence.wge_ctl, FC_RCTL_BA_ABTS); | |
1744 | bf_set(wqe_type, &wqe_abts->xmit_sequence.wge_ctl, FC_TYPE_BLS); | |
1745 | ||
1746 | /* Word 6 */ | |
1747 | bf_set(wqe_ctxt_tag, &wqe_abts->xmit_sequence.wqe_com, | |
1748 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1749 | bf_set(wqe_xri_tag, &wqe_abts->xmit_sequence.wqe_com, | |
1750 | abts_wqeq->sli4_xritag); | |
1751 | ||
1752 | /* Word 7 */ | |
1753 | bf_set(wqe_cmnd, &wqe_abts->xmit_sequence.wqe_com, | |
1754 | CMD_XMIT_SEQUENCE64_WQE); | |
1755 | bf_set(wqe_ct, &wqe_abts->xmit_sequence.wqe_com, SLI4_CT_RPI); | |
1756 | bf_set(wqe_class, &wqe_abts->xmit_sequence.wqe_com, CLASS3); | |
1757 | bf_set(wqe_pu, &wqe_abts->xmit_sequence.wqe_com, 0); | |
1758 | ||
1759 | /* Word 8 */ | |
1760 | wqe_abts->xmit_sequence.wqe_com.abort_tag = abts_wqeq->iotag; | |
1761 | ||
1762 | /* Word 9 */ | |
1763 | bf_set(wqe_reqtag, &wqe_abts->xmit_sequence.wqe_com, abts_wqeq->iotag); | |
1764 | /* Needs to be set by caller */ | |
1765 | bf_set(wqe_rcvoxid, &wqe_abts->xmit_sequence.wqe_com, xri); | |
1766 | ||
1767 | /* Word 10 */ | |
1768 | bf_set(wqe_dbde, &wqe_abts->xmit_sequence.wqe_com, 1); | |
1769 | bf_set(wqe_iod, &wqe_abts->xmit_sequence.wqe_com, LPFC_WQE_IOD_WRITE); | |
1770 | bf_set(wqe_lenloc, &wqe_abts->xmit_sequence.wqe_com, | |
1771 | LPFC_WQE_LENLOC_WORD12); | |
1772 | bf_set(wqe_ebde_cnt, &wqe_abts->xmit_sequence.wqe_com, 0); | |
1773 | bf_set(wqe_qosd, &wqe_abts->xmit_sequence.wqe_com, 0); | |
1774 | ||
1775 | /* Word 11 */ | |
1776 | bf_set(wqe_cqid, &wqe_abts->xmit_sequence.wqe_com, | |
1777 | LPFC_WQE_CQ_ID_DEFAULT); | |
1778 | bf_set(wqe_cmd_type, &wqe_abts->xmit_sequence.wqe_com, | |
1779 | OTHER_COMMAND); | |
1780 | ||
1781 | abts_wqeq->vport = phba->pport; | |
1782 | abts_wqeq->context1 = ndlp; | |
1783 | abts_wqeq->context2 = ctxp; | |
1784 | abts_wqeq->context3 = NULL; | |
1785 | abts_wqeq->rsvd2 = 0; | |
1786 | /* hba_wqidx should already be setup from command we are aborting */ | |
1787 | abts_wqeq->iocb.ulpCommand = CMD_XMIT_SEQUENCE64_CR; | |
1788 | abts_wqeq->iocb.ulpLe = 1; | |
1789 | ||
1790 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
1791 | "6069 Issue ABTS to xri x%x reqtag x%x\n", | |
1792 | xri, abts_wqeq->iotag); | |
1793 | return 1; | |
1794 | } | |
1795 | ||
1796 | static int | |
1797 | lpfc_nvmet_sol_fcp_issue_abort(struct lpfc_hba *phba, | |
1798 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
1799 | uint32_t sid, uint16_t xri) | |
1800 | { | |
1801 | struct lpfc_nvmet_tgtport *tgtp; | |
1802 | struct lpfc_iocbq *abts_wqeq; | |
1803 | union lpfc_wqe *abts_wqe; | |
1804 | struct lpfc_nodelist *ndlp; | |
1805 | unsigned long flags; | |
1806 | int rc; | |
1807 | ||
1808 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1809 | if (!ctxp->wqeq) { | |
1810 | ctxp->wqeq = ctxp->rqb_buffer->iocbq; | |
1811 | ctxp->wqeq->hba_wqidx = 0; | |
1812 | } | |
1813 | ||
1814 | ndlp = lpfc_findnode_did(phba->pport, sid); | |
1815 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
1816 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
1817 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
1818 | atomic_inc(&tgtp->xmt_abort_rsp_error); | |
1819 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
1820 | "6160 Drop ABTS - wrong NDLP state x%x.\n", | |
b5ccc7d6 | 1821 | (ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE); |
d613b6a7 JS |
1822 | |
1823 | /* No failure to an ABTS request. */ | |
1824 | return 0; | |
1825 | } | |
1826 | ||
1827 | /* Issue ABTS for this WQE based on iotag */ | |
1828 | ctxp->abort_wqeq = lpfc_sli_get_iocbq(phba); | |
1829 | if (!ctxp->abort_wqeq) { | |
1830 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
1831 | "6161 Abort failed: No wqeqs: " | |
1832 | "xri: x%x\n", ctxp->oxid); | |
1833 | /* No failure to an ABTS request. */ | |
1834 | return 0; | |
1835 | } | |
1836 | abts_wqeq = ctxp->abort_wqeq; | |
1837 | abts_wqe = &abts_wqeq->wqe; | |
1838 | ctxp->state = LPFC_NVMET_STE_ABORT; | |
1839 | ||
1840 | /* Announce entry to new IO submit field. */ | |
1841 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS, | |
1842 | "6162 Abort Request to rport DID x%06x " | |
1843 | "for xri x%x x%x\n", | |
1844 | ctxp->sid, ctxp->oxid, ctxp->wqeq->sli4_xritag); | |
1845 | ||
1846 | /* If the hba is getting reset, this flag is set. It is | |
1847 | * cleared when the reset is complete and rings reestablished. | |
1848 | */ | |
1849 | spin_lock_irqsave(&phba->hbalock, flags); | |
1850 | /* driver queued commands are in process of being flushed */ | |
1851 | if (phba->hba_flag & HBA_NVME_IOQ_FLUSH) { | |
1852 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
1853 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, | |
1854 | "6163 Driver in reset cleanup - flushing " | |
1855 | "NVME Req now. hba_flag x%x oxid x%x\n", | |
1856 | phba->hba_flag, ctxp->oxid); | |
1857 | lpfc_sli_release_iocbq(phba, abts_wqeq); | |
1858 | return 0; | |
1859 | } | |
1860 | ||
1861 | /* Outstanding abort is in progress */ | |
1862 | if (abts_wqeq->iocb_flag & LPFC_DRIVER_ABORTED) { | |
1863 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
1864 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, | |
1865 | "6164 Outstanding NVME I/O Abort Request " | |
1866 | "still pending on oxid x%x\n", | |
1867 | ctxp->oxid); | |
1868 | lpfc_sli_release_iocbq(phba, abts_wqeq); | |
1869 | return 0; | |
1870 | } | |
1871 | ||
1872 | /* Ready - mark outstanding as aborted by driver. */ | |
1873 | abts_wqeq->iocb_flag |= LPFC_DRIVER_ABORTED; | |
1874 | ||
1875 | /* WQEs are reused. Clear stale data and set key fields to | |
1876 | * zero like ia, iaab, iaar, xri_tag, and ctxt_tag. | |
1877 | */ | |
1878 | memset(abts_wqe, 0, sizeof(union lpfc_wqe)); | |
1879 | ||
1880 | /* word 3 */ | |
1881 | bf_set(abort_cmd_criteria, &abts_wqe->abort_cmd, T_XRI_TAG); | |
1882 | ||
1883 | /* word 7 */ | |
1884 | bf_set(wqe_ct, &abts_wqe->abort_cmd.wqe_com, 0); | |
1885 | bf_set(wqe_cmnd, &abts_wqe->abort_cmd.wqe_com, CMD_ABORT_XRI_CX); | |
1886 | ||
1887 | /* word 8 - tell the FW to abort the IO associated with this | |
1888 | * outstanding exchange ID. | |
1889 | */ | |
1890 | abts_wqe->abort_cmd.wqe_com.abort_tag = ctxp->wqeq->sli4_xritag; | |
1891 | ||
1892 | /* word 9 - this is the iotag for the abts_wqe completion. */ | |
1893 | bf_set(wqe_reqtag, &abts_wqe->abort_cmd.wqe_com, | |
1894 | abts_wqeq->iotag); | |
1895 | ||
1896 | /* word 10 */ | |
1897 | bf_set(wqe_qosd, &abts_wqe->abort_cmd.wqe_com, 1); | |
1898 | bf_set(wqe_lenloc, &abts_wqe->abort_cmd.wqe_com, LPFC_WQE_LENLOC_NONE); | |
1899 | ||
1900 | /* word 11 */ | |
1901 | bf_set(wqe_cmd_type, &abts_wqe->abort_cmd.wqe_com, OTHER_COMMAND); | |
1902 | bf_set(wqe_wqec, &abts_wqe->abort_cmd.wqe_com, 1); | |
1903 | bf_set(wqe_cqid, &abts_wqe->abort_cmd.wqe_com, LPFC_WQE_CQ_ID_DEFAULT); | |
1904 | ||
1905 | /* ABTS WQE must go to the same WQ as the WQE to be aborted */ | |
1906 | abts_wqeq->hba_wqidx = ctxp->wqeq->hba_wqidx; | |
1907 | abts_wqeq->wqe_cmpl = lpfc_nvmet_sol_fcp_abort_cmp; | |
1908 | abts_wqeq->iocb_cmpl = 0; | |
1909 | abts_wqeq->iocb_flag |= LPFC_IO_NVME; | |
1910 | abts_wqeq->context2 = ctxp; | |
1911 | rc = lpfc_sli4_issue_wqe(phba, LPFC_FCP_RING, abts_wqeq); | |
1912 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
1913 | if (rc == WQE_SUCCESS) | |
1914 | return 0; | |
1915 | ||
1916 | lpfc_sli_release_iocbq(phba, abts_wqeq); | |
1917 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, | |
1918 | "6166 Failed abts issue_wqe with status x%x " | |
1919 | "for oxid x%x.\n", | |
1920 | rc, ctxp->oxid); | |
1921 | return 1; | |
1922 | } | |
1923 | ||
1924 | ||
1925 | static int | |
1926 | lpfc_nvmet_unsol_fcp_issue_abort(struct lpfc_hba *phba, | |
1927 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
1928 | uint32_t sid, uint16_t xri) | |
1929 | { | |
1930 | struct lpfc_nvmet_tgtport *tgtp; | |
1931 | struct lpfc_iocbq *abts_wqeq; | |
1932 | unsigned long flags; | |
1933 | int rc; | |
1934 | ||
1935 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1936 | if (!ctxp->wqeq) { | |
1937 | ctxp->wqeq = ctxp->rqb_buffer->iocbq; | |
1938 | ctxp->wqeq->hba_wqidx = 0; | |
1939 | } | |
1940 | ||
1941 | rc = lpfc_nvmet_unsol_issue_abort(phba, ctxp, sid, xri); | |
1942 | if (rc == 0) | |
1943 | goto aerr; | |
1944 | ||
1945 | spin_lock_irqsave(&phba->hbalock, flags); | |
1946 | abts_wqeq = ctxp->wqeq; | |
1947 | abts_wqeq->wqe_cmpl = lpfc_nvmet_xmt_fcp_abort_cmp; | |
1948 | abts_wqeq->iocb_cmpl = 0; | |
1949 | abts_wqeq->iocb_flag |= LPFC_IO_NVMET; | |
1950 | rc = lpfc_sli4_issue_wqe(phba, LPFC_FCP_RING, abts_wqeq); | |
1951 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
1952 | if (rc == WQE_SUCCESS) { | |
1953 | atomic_inc(&tgtp->xmt_abort_rsp); | |
1954 | return 0; | |
1955 | } | |
1956 | ||
1957 | aerr: | |
1958 | lpfc_nvmet_rq_post(phba, ctxp, &ctxp->rqb_buffer->hbuf); | |
1959 | atomic_inc(&tgtp->xmt_abort_rsp_error); | |
1960 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
1961 | "6135 Failed to Issue ABTS for oxid x%x. Status x%x\n", | |
1962 | ctxp->oxid, rc); | |
1963 | return 1; | |
1964 | } | |
1965 | ||
1966 | static int | |
1967 | lpfc_nvmet_unsol_ls_issue_abort(struct lpfc_hba *phba, | |
1968 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
1969 | uint32_t sid, uint16_t xri) | |
1970 | { | |
1971 | struct lpfc_nvmet_tgtport *tgtp; | |
1972 | struct lpfc_iocbq *abts_wqeq; | |
1973 | union lpfc_wqe *wqe_abts; | |
1974 | unsigned long flags; | |
1975 | int rc; | |
1976 | ||
1977 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1978 | if (!ctxp->wqeq) { | |
1979 | /* Issue ABTS for this WQE based on iotag */ | |
1980 | ctxp->wqeq = lpfc_sli_get_iocbq(phba); | |
1981 | if (!ctxp->wqeq) { | |
1982 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
1983 | "6068 Abort failed: No wqeqs: " | |
1984 | "xri: x%x\n", xri); | |
1985 | /* No failure to an ABTS request. */ | |
1986 | kfree(ctxp); | |
1987 | return 0; | |
1988 | } | |
1989 | } | |
1990 | abts_wqeq = ctxp->wqeq; | |
1991 | wqe_abts = &abts_wqeq->wqe; | |
1992 | lpfc_nvmet_unsol_issue_abort(phba, ctxp, sid, xri); | |
1993 | ||
1994 | spin_lock_irqsave(&phba->hbalock, flags); | |
1995 | abts_wqeq->wqe_cmpl = lpfc_nvmet_xmt_ls_abort_cmp; | |
1996 | abts_wqeq->iocb_cmpl = 0; | |
1997 | abts_wqeq->iocb_flag |= LPFC_IO_NVME_LS; | |
1998 | rc = lpfc_sli4_issue_wqe(phba, LPFC_ELS_RING, abts_wqeq); | |
1999 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
2000 | if (rc == WQE_SUCCESS) { | |
2001 | atomic_inc(&tgtp->xmt_abort_rsp); | |
2002 | return 0; | |
2003 | } | |
2004 | ||
2005 | atomic_inc(&tgtp->xmt_abort_rsp_error); | |
2006 | abts_wqeq->context2 = NULL; | |
2007 | abts_wqeq->context3 = NULL; | |
2008 | lpfc_sli_release_iocbq(phba, abts_wqeq); | |
2009 | kfree(ctxp); | |
2010 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
2011 | "6056 Failed to Issue ABTS. Status x%x\n", rc); | |
2012 | return 0; | |
2013 | } |