Commit | Line | Data |
---|---|---|
a3667aae NKI |
1 | /* |
2 | * This file is part of the Chelsio FCoE driver for Linux. | |
3 | * | |
4 | * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved. | |
5 | * | |
6 | * This software is available to you under a choice of one of two | |
7 | * licenses. You may choose to be licensed under the terms of the GNU | |
8 | * General Public License (GPL) Version 2, available from the file | |
9 | * COPYING in the main directory of this source tree, or the | |
10 | * OpenIB.org BSD license below: | |
11 | * | |
12 | * Redistribution and use in source and binary forms, with or | |
13 | * without modification, are permitted provided that the following | |
14 | * conditions are met: | |
15 | * | |
16 | * - Redistributions of source code must retain the above | |
17 | * copyright notice, this list of conditions and the following | |
18 | * disclaimer. | |
19 | * | |
20 | * - Redistributions in binary form must reproduce the above | |
21 | * copyright notice, this list of conditions and the following | |
22 | * disclaimer in the documentation and/or other materials | |
23 | * provided with the distribution. | |
24 | * | |
25 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
26 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
27 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
28 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
29 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
30 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
31 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
32 | * SOFTWARE. | |
33 | */ | |
34 | ||
35 | #include <linux/device.h> | |
36 | #include <linux/delay.h> | |
37 | #include <linux/ctype.h> | |
38 | #include <linux/kernel.h> | |
39 | #include <linux/slab.h> | |
40 | #include <linux/string.h> | |
41 | #include <linux/compiler.h> | |
42 | #include <linux/export.h> | |
43 | #include <linux/module.h> | |
44 | #include <asm/unaligned.h> | |
45 | #include <asm/page.h> | |
46 | #include <scsi/scsi.h> | |
47 | #include <scsi/scsi_device.h> | |
48 | #include <scsi/scsi_transport_fc.h> | |
49 | ||
50 | #include "csio_hw.h" | |
51 | #include "csio_lnode.h" | |
52 | #include "csio_rnode.h" | |
53 | #include "csio_scsi.h" | |
54 | #include "csio_init.h" | |
55 | ||
56 | int csio_scsi_eqsize = 65536; | |
57 | int csio_scsi_iqlen = 128; | |
58 | int csio_scsi_ioreqs = 2048; | |
59 | uint32_t csio_max_scan_tmo; | |
60 | uint32_t csio_delta_scan_tmo = 5; | |
61 | int csio_lun_qdepth = 32; | |
62 | ||
63 | static int csio_ddp_descs = 128; | |
64 | ||
65 | static int csio_do_abrt_cls(struct csio_hw *, | |
66 | struct csio_ioreq *, bool); | |
67 | ||
68 | static void csio_scsis_uninit(struct csio_ioreq *, enum csio_scsi_ev); | |
69 | static void csio_scsis_io_active(struct csio_ioreq *, enum csio_scsi_ev); | |
70 | static void csio_scsis_tm_active(struct csio_ioreq *, enum csio_scsi_ev); | |
71 | static void csio_scsis_aborting(struct csio_ioreq *, enum csio_scsi_ev); | |
72 | static void csio_scsis_closing(struct csio_ioreq *, enum csio_scsi_ev); | |
73 | static void csio_scsis_shost_cmpl_await(struct csio_ioreq *, enum csio_scsi_ev); | |
74 | ||
75 | /* | |
76 | * csio_scsi_match_io - Match an ioreq with the given SCSI level data. | |
77 | * @ioreq: The I/O request | |
78 | * @sld: Level information | |
79 | * | |
80 | * Should be called with lock held. | |
81 | * | |
82 | */ | |
83 | static bool | |
84 | csio_scsi_match_io(struct csio_ioreq *ioreq, struct csio_scsi_level_data *sld) | |
85 | { | |
86 | struct scsi_cmnd *scmnd = csio_scsi_cmnd(ioreq); | |
87 | ||
88 | switch (sld->level) { | |
89 | case CSIO_LEV_LUN: | |
90 | if (scmnd == NULL) | |
91 | return false; | |
92 | ||
93 | return ((ioreq->lnode == sld->lnode) && | |
94 | (ioreq->rnode == sld->rnode) && | |
95 | ((uint64_t)scmnd->device->lun == sld->oslun)); | |
96 | ||
97 | case CSIO_LEV_RNODE: | |
98 | return ((ioreq->lnode == sld->lnode) && | |
99 | (ioreq->rnode == sld->rnode)); | |
100 | case CSIO_LEV_LNODE: | |
101 | return (ioreq->lnode == sld->lnode); | |
102 | case CSIO_LEV_ALL: | |
103 | return true; | |
104 | default: | |
105 | return false; | |
106 | } | |
107 | } | |
108 | ||
109 | /* | |
110 | * csio_scsi_gather_active_ios - Gather active I/Os based on level | |
111 | * @scm: SCSI module | |
112 | * @sld: Level information | |
113 | * @dest: The queue where these I/Os have to be gathered. | |
114 | * | |
115 | * Should be called with lock held. | |
116 | */ | |
117 | static void | |
118 | csio_scsi_gather_active_ios(struct csio_scsim *scm, | |
119 | struct csio_scsi_level_data *sld, | |
120 | struct list_head *dest) | |
121 | { | |
122 | struct list_head *tmp, *next; | |
123 | ||
124 | if (list_empty(&scm->active_q)) | |
125 | return; | |
126 | ||
127 | /* Just splice the entire active_q into dest */ | |
128 | if (sld->level == CSIO_LEV_ALL) { | |
129 | list_splice_tail_init(&scm->active_q, dest); | |
130 | return; | |
131 | } | |
132 | ||
133 | list_for_each_safe(tmp, next, &scm->active_q) { | |
134 | if (csio_scsi_match_io((struct csio_ioreq *)tmp, sld)) { | |
135 | list_del_init(tmp); | |
136 | list_add_tail(tmp, dest); | |
137 | } | |
138 | } | |
139 | } | |
140 | ||
141 | static inline bool | |
142 | csio_scsi_itnexus_loss_error(uint16_t error) | |
143 | { | |
144 | switch (error) { | |
145 | case FW_ERR_LINK_DOWN: | |
146 | case FW_RDEV_NOT_READY: | |
147 | case FW_ERR_RDEV_LOST: | |
148 | case FW_ERR_RDEV_LOGO: | |
149 | case FW_ERR_RDEV_IMPL_LOGO: | |
150 | return 1; | |
151 | } | |
152 | return 0; | |
153 | } | |
154 | ||
a3667aae NKI |
155 | /* |
156 | * csio_scsi_fcp_cmnd - Frame the SCSI FCP command paylod. | |
157 | * @req: IO req structure. | |
158 | * @addr: DMA location to place the payload. | |
159 | * | |
160 | * This routine is shared between FCP_WRITE, FCP_READ and FCP_CMD requests. | |
161 | */ | |
162 | static inline void | |
163 | csio_scsi_fcp_cmnd(struct csio_ioreq *req, void *addr) | |
164 | { | |
165 | struct fcp_cmnd *fcp_cmnd = (struct fcp_cmnd *)addr; | |
166 | struct scsi_cmnd *scmnd = csio_scsi_cmnd(req); | |
167 | ||
168 | /* Check for Task Management */ | |
169 | if (likely(scmnd->SCp.Message == 0)) { | |
170 | int_to_scsilun(scmnd->device->lun, &fcp_cmnd->fc_lun); | |
171 | fcp_cmnd->fc_tm_flags = 0; | |
172 | fcp_cmnd->fc_cmdref = 0; | |
a3667aae NKI |
173 | |
174 | memcpy(fcp_cmnd->fc_cdb, scmnd->cmnd, 16); | |
ea6bb33e | 175 | fcp_cmnd->fc_pri_ta = FCP_PTA_SIMPLE; |
a3667aae NKI |
176 | fcp_cmnd->fc_dl = cpu_to_be32(scsi_bufflen(scmnd)); |
177 | ||
178 | if (req->nsge) | |
179 | if (req->datadir == DMA_TO_DEVICE) | |
180 | fcp_cmnd->fc_flags = FCP_CFL_WRDATA; | |
181 | else | |
182 | fcp_cmnd->fc_flags = FCP_CFL_RDDATA; | |
183 | else | |
184 | fcp_cmnd->fc_flags = 0; | |
185 | } else { | |
186 | memset(fcp_cmnd, 0, sizeof(*fcp_cmnd)); | |
187 | int_to_scsilun(scmnd->device->lun, &fcp_cmnd->fc_lun); | |
188 | fcp_cmnd->fc_tm_flags = (uint8_t)scmnd->SCp.Message; | |
189 | } | |
190 | } | |
191 | ||
192 | /* | |
193 | * csio_scsi_init_cmd_wr - Initialize the SCSI CMD WR. | |
194 | * @req: IO req structure. | |
195 | * @addr: DMA location to place the payload. | |
196 | * @size: Size of WR (including FW WR + immed data + rsp SG entry | |
197 | * | |
198 | * Wrapper for populating fw_scsi_cmd_wr. | |
199 | */ | |
200 | static inline void | |
201 | csio_scsi_init_cmd_wr(struct csio_ioreq *req, void *addr, uint32_t size) | |
202 | { | |
203 | struct csio_hw *hw = req->lnode->hwp; | |
204 | struct csio_rnode *rn = req->rnode; | |
205 | struct fw_scsi_cmd_wr *wr = (struct fw_scsi_cmd_wr *)addr; | |
206 | struct csio_dma_buf *dma_buf; | |
207 | uint8_t imm = csio_hw_to_scsim(hw)->proto_cmd_len; | |
208 | ||
e2ac9628 | 209 | wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_SCSI_CMD_WR) | |
a3667aae | 210 | FW_SCSI_CMD_WR_IMMDLEN(imm)); |
e2ac9628 HS |
211 | wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(rn->flowid) | |
212 | FW_WR_LEN16_V( | |
a3667aae NKI |
213 | DIV_ROUND_UP(size, 16))); |
214 | ||
215 | wr->cookie = (uintptr_t) req; | |
5036f0a0 | 216 | wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx)); |
a3667aae NKI |
217 | wr->tmo_val = (uint8_t) req->tmo; |
218 | wr->r3 = 0; | |
219 | memset(&wr->r5, 0, 8); | |
220 | ||
221 | /* Get RSP DMA buffer */ | |
222 | dma_buf = &req->dma_buf; | |
223 | ||
224 | /* Prepare RSP SGL */ | |
225 | wr->rsp_dmalen = cpu_to_be32(dma_buf->len); | |
226 | wr->rsp_dmaaddr = cpu_to_be64(dma_buf->paddr); | |
227 | ||
228 | wr->r6 = 0; | |
229 | ||
230 | wr->u.fcoe.ctl_pri = 0; | |
231 | wr->u.fcoe.cp_en_class = 0; | |
232 | wr->u.fcoe.r4_lo[0] = 0; | |
233 | wr->u.fcoe.r4_lo[1] = 0; | |
234 | ||
235 | /* Frame a FCP command */ | |
236 | csio_scsi_fcp_cmnd(req, (void *)((uintptr_t)addr + | |
237 | sizeof(struct fw_scsi_cmd_wr))); | |
238 | } | |
239 | ||
240 | #define CSIO_SCSI_CMD_WR_SZ(_imm) \ | |
241 | (sizeof(struct fw_scsi_cmd_wr) + /* WR size */ \ | |
242 | ALIGN((_imm), 16)) /* Immed data */ | |
243 | ||
244 | #define CSIO_SCSI_CMD_WR_SZ_16(_imm) \ | |
245 | (ALIGN(CSIO_SCSI_CMD_WR_SZ((_imm)), 16)) | |
246 | ||
247 | /* | |
248 | * csio_scsi_cmd - Create a SCSI CMD WR. | |
249 | * @req: IO req structure. | |
250 | * | |
251 | * Gets a WR slot in the ingress queue and initializes it with SCSI CMD WR. | |
252 | * | |
253 | */ | |
254 | static inline void | |
255 | csio_scsi_cmd(struct csio_ioreq *req) | |
256 | { | |
257 | struct csio_wr_pair wrp; | |
258 | struct csio_hw *hw = req->lnode->hwp; | |
259 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
260 | uint32_t size = CSIO_SCSI_CMD_WR_SZ_16(scsim->proto_cmd_len); | |
261 | ||
262 | req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp); | |
263 | if (unlikely(req->drv_status != 0)) | |
264 | return; | |
265 | ||
266 | if (wrp.size1 >= size) { | |
267 | /* Initialize WR in one shot */ | |
268 | csio_scsi_init_cmd_wr(req, wrp.addr1, size); | |
269 | } else { | |
270 | uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx); | |
271 | ||
272 | /* | |
273 | * Make a temporary copy of the WR and write back | |
274 | * the copy into the WR pair. | |
275 | */ | |
276 | csio_scsi_init_cmd_wr(req, (void *)tmpwr, size); | |
277 | memcpy(wrp.addr1, tmpwr, wrp.size1); | |
278 | memcpy(wrp.addr2, tmpwr + wrp.size1, size - wrp.size1); | |
279 | } | |
280 | } | |
281 | ||
282 | /* | |
283 | * csio_scsi_init_ulptx_dsgl - Fill in a ULP_TX_SC_DSGL | |
284 | * @hw: HW module | |
285 | * @req: IO request | |
286 | * @sgl: ULP TX SGL pointer. | |
287 | * | |
288 | */ | |
289 | static inline void | |
290 | csio_scsi_init_ultptx_dsgl(struct csio_hw *hw, struct csio_ioreq *req, | |
291 | struct ulptx_sgl *sgl) | |
292 | { | |
293 | struct ulptx_sge_pair *sge_pair = NULL; | |
294 | struct scatterlist *sgel; | |
295 | uint32_t i = 0; | |
296 | uint32_t xfer_len; | |
297 | struct list_head *tmp; | |
298 | struct csio_dma_buf *dma_buf; | |
299 | struct scsi_cmnd *scmnd = csio_scsi_cmnd(req); | |
300 | ||
bdc590b9 HS |
301 | sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) | ULPTX_MORE_F | |
302 | ULPTX_NSGE_V(req->nsge)); | |
a3667aae NKI |
303 | /* Now add the data SGLs */ |
304 | if (likely(!req->dcopy)) { | |
305 | scsi_for_each_sg(scmnd, sgel, req->nsge, i) { | |
306 | if (i == 0) { | |
307 | sgl->addr0 = cpu_to_be64(sg_dma_address(sgel)); | |
308 | sgl->len0 = cpu_to_be32(sg_dma_len(sgel)); | |
309 | sge_pair = (struct ulptx_sge_pair *)(sgl + 1); | |
310 | continue; | |
311 | } | |
312 | if ((i - 1) & 0x1) { | |
313 | sge_pair->addr[1] = cpu_to_be64( | |
314 | sg_dma_address(sgel)); | |
315 | sge_pair->len[1] = cpu_to_be32( | |
316 | sg_dma_len(sgel)); | |
317 | sge_pair++; | |
318 | } else { | |
319 | sge_pair->addr[0] = cpu_to_be64( | |
320 | sg_dma_address(sgel)); | |
321 | sge_pair->len[0] = cpu_to_be32( | |
322 | sg_dma_len(sgel)); | |
323 | } | |
324 | } | |
325 | } else { | |
326 | /* Program sg elements with driver's DDP buffer */ | |
327 | xfer_len = scsi_bufflen(scmnd); | |
328 | list_for_each(tmp, &req->gen_list) { | |
329 | dma_buf = (struct csio_dma_buf *)tmp; | |
330 | if (i == 0) { | |
331 | sgl->addr0 = cpu_to_be64(dma_buf->paddr); | |
332 | sgl->len0 = cpu_to_be32( | |
333 | min(xfer_len, dma_buf->len)); | |
334 | sge_pair = (struct ulptx_sge_pair *)(sgl + 1); | |
335 | } else if ((i - 1) & 0x1) { | |
336 | sge_pair->addr[1] = cpu_to_be64(dma_buf->paddr); | |
337 | sge_pair->len[1] = cpu_to_be32( | |
338 | min(xfer_len, dma_buf->len)); | |
339 | sge_pair++; | |
340 | } else { | |
341 | sge_pair->addr[0] = cpu_to_be64(dma_buf->paddr); | |
342 | sge_pair->len[0] = cpu_to_be32( | |
343 | min(xfer_len, dma_buf->len)); | |
344 | } | |
345 | xfer_len -= min(xfer_len, dma_buf->len); | |
346 | i++; | |
347 | } | |
348 | } | |
349 | } | |
350 | ||
351 | /* | |
352 | * csio_scsi_init_read_wr - Initialize the READ SCSI WR. | |
353 | * @req: IO req structure. | |
354 | * @wrp: DMA location to place the payload. | |
355 | * @size: Size of WR (including FW WR + immed data + rsp SG entry + data SGL | |
356 | * | |
357 | * Wrapper for populating fw_scsi_read_wr. | |
358 | */ | |
359 | static inline void | |
360 | csio_scsi_init_read_wr(struct csio_ioreq *req, void *wrp, uint32_t size) | |
361 | { | |
362 | struct csio_hw *hw = req->lnode->hwp; | |
363 | struct csio_rnode *rn = req->rnode; | |
364 | struct fw_scsi_read_wr *wr = (struct fw_scsi_read_wr *)wrp; | |
365 | struct ulptx_sgl *sgl; | |
366 | struct csio_dma_buf *dma_buf; | |
367 | uint8_t imm = csio_hw_to_scsim(hw)->proto_cmd_len; | |
368 | struct scsi_cmnd *scmnd = csio_scsi_cmnd(req); | |
369 | ||
e2ac9628 | 370 | wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_SCSI_READ_WR) | |
a3667aae | 371 | FW_SCSI_READ_WR_IMMDLEN(imm)); |
e2ac9628 HS |
372 | wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(rn->flowid) | |
373 | FW_WR_LEN16_V(DIV_ROUND_UP(size, 16))); | |
a3667aae | 374 | wr->cookie = (uintptr_t)req; |
5036f0a0 | 375 | wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx)); |
a3667aae NKI |
376 | wr->tmo_val = (uint8_t)(req->tmo); |
377 | wr->use_xfer_cnt = 1; | |
378 | wr->xfer_cnt = cpu_to_be32(scsi_bufflen(scmnd)); | |
379 | wr->ini_xfer_cnt = cpu_to_be32(scsi_bufflen(scmnd)); | |
380 | /* Get RSP DMA buffer */ | |
381 | dma_buf = &req->dma_buf; | |
382 | ||
383 | /* Prepare RSP SGL */ | |
384 | wr->rsp_dmalen = cpu_to_be32(dma_buf->len); | |
385 | wr->rsp_dmaaddr = cpu_to_be64(dma_buf->paddr); | |
386 | ||
387 | wr->r4 = 0; | |
388 | ||
389 | wr->u.fcoe.ctl_pri = 0; | |
390 | wr->u.fcoe.cp_en_class = 0; | |
391 | wr->u.fcoe.r3_lo[0] = 0; | |
392 | wr->u.fcoe.r3_lo[1] = 0; | |
393 | csio_scsi_fcp_cmnd(req, (void *)((uintptr_t)wrp + | |
394 | sizeof(struct fw_scsi_read_wr))); | |
395 | ||
396 | /* Move WR pointer past command and immediate data */ | |
397 | sgl = (struct ulptx_sgl *)((uintptr_t)wrp + | |
398 | sizeof(struct fw_scsi_read_wr) + ALIGN(imm, 16)); | |
399 | ||
400 | /* Fill in the DSGL */ | |
401 | csio_scsi_init_ultptx_dsgl(hw, req, sgl); | |
402 | } | |
403 | ||
404 | /* | |
405 | * csio_scsi_init_write_wr - Initialize the WRITE SCSI WR. | |
406 | * @req: IO req structure. | |
407 | * @wrp: DMA location to place the payload. | |
408 | * @size: Size of WR (including FW WR + immed data + rsp SG entry + data SGL | |
409 | * | |
410 | * Wrapper for populating fw_scsi_write_wr. | |
411 | */ | |
412 | static inline void | |
413 | csio_scsi_init_write_wr(struct csio_ioreq *req, void *wrp, uint32_t size) | |
414 | { | |
415 | struct csio_hw *hw = req->lnode->hwp; | |
416 | struct csio_rnode *rn = req->rnode; | |
417 | struct fw_scsi_write_wr *wr = (struct fw_scsi_write_wr *)wrp; | |
418 | struct ulptx_sgl *sgl; | |
419 | struct csio_dma_buf *dma_buf; | |
420 | uint8_t imm = csio_hw_to_scsim(hw)->proto_cmd_len; | |
421 | struct scsi_cmnd *scmnd = csio_scsi_cmnd(req); | |
422 | ||
e2ac9628 | 423 | wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_SCSI_WRITE_WR) | |
a3667aae | 424 | FW_SCSI_WRITE_WR_IMMDLEN(imm)); |
e2ac9628 HS |
425 | wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(rn->flowid) | |
426 | FW_WR_LEN16_V(DIV_ROUND_UP(size, 16))); | |
a3667aae | 427 | wr->cookie = (uintptr_t)req; |
5036f0a0 | 428 | wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx)); |
a3667aae NKI |
429 | wr->tmo_val = (uint8_t)(req->tmo); |
430 | wr->use_xfer_cnt = 1; | |
431 | wr->xfer_cnt = cpu_to_be32(scsi_bufflen(scmnd)); | |
432 | wr->ini_xfer_cnt = cpu_to_be32(scsi_bufflen(scmnd)); | |
433 | /* Get RSP DMA buffer */ | |
434 | dma_buf = &req->dma_buf; | |
435 | ||
436 | /* Prepare RSP SGL */ | |
437 | wr->rsp_dmalen = cpu_to_be32(dma_buf->len); | |
438 | wr->rsp_dmaaddr = cpu_to_be64(dma_buf->paddr); | |
439 | ||
440 | wr->r4 = 0; | |
441 | ||
442 | wr->u.fcoe.ctl_pri = 0; | |
443 | wr->u.fcoe.cp_en_class = 0; | |
444 | wr->u.fcoe.r3_lo[0] = 0; | |
445 | wr->u.fcoe.r3_lo[1] = 0; | |
446 | csio_scsi_fcp_cmnd(req, (void *)((uintptr_t)wrp + | |
447 | sizeof(struct fw_scsi_write_wr))); | |
448 | ||
449 | /* Move WR pointer past command and immediate data */ | |
450 | sgl = (struct ulptx_sgl *)((uintptr_t)wrp + | |
451 | sizeof(struct fw_scsi_write_wr) + ALIGN(imm, 16)); | |
452 | ||
453 | /* Fill in the DSGL */ | |
454 | csio_scsi_init_ultptx_dsgl(hw, req, sgl); | |
455 | } | |
456 | ||
457 | /* Calculate WR size needed for fw_scsi_read_wr/fw_scsi_write_wr */ | |
458 | #define CSIO_SCSI_DATA_WRSZ(req, oper, sz, imm) \ | |
459 | do { \ | |
460 | (sz) = sizeof(struct fw_scsi_##oper##_wr) + /* WR size */ \ | |
461 | ALIGN((imm), 16) + /* Immed data */ \ | |
462 | sizeof(struct ulptx_sgl); /* ulptx_sgl */ \ | |
463 | \ | |
464 | if (unlikely((req)->nsge > 1)) \ | |
465 | (sz) += (sizeof(struct ulptx_sge_pair) * \ | |
466 | (ALIGN(((req)->nsge - 1), 2) / 2)); \ | |
467 | /* Data SGE */ \ | |
468 | } while (0) | |
469 | ||
470 | /* | |
471 | * csio_scsi_read - Create a SCSI READ WR. | |
472 | * @req: IO req structure. | |
473 | * | |
474 | * Gets a WR slot in the ingress queue and initializes it with | |
475 | * SCSI READ WR. | |
476 | * | |
477 | */ | |
478 | static inline void | |
479 | csio_scsi_read(struct csio_ioreq *req) | |
480 | { | |
481 | struct csio_wr_pair wrp; | |
482 | uint32_t size; | |
483 | struct csio_hw *hw = req->lnode->hwp; | |
484 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
485 | ||
486 | CSIO_SCSI_DATA_WRSZ(req, read, size, scsim->proto_cmd_len); | |
487 | size = ALIGN(size, 16); | |
488 | ||
489 | req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp); | |
490 | if (likely(req->drv_status == 0)) { | |
491 | if (likely(wrp.size1 >= size)) { | |
492 | /* Initialize WR in one shot */ | |
493 | csio_scsi_init_read_wr(req, wrp.addr1, size); | |
494 | } else { | |
495 | uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx); | |
496 | /* | |
497 | * Make a temporary copy of the WR and write back | |
498 | * the copy into the WR pair. | |
499 | */ | |
500 | csio_scsi_init_read_wr(req, (void *)tmpwr, size); | |
501 | memcpy(wrp.addr1, tmpwr, wrp.size1); | |
502 | memcpy(wrp.addr2, tmpwr + wrp.size1, size - wrp.size1); | |
503 | } | |
504 | } | |
505 | } | |
506 | ||
507 | /* | |
508 | * csio_scsi_write - Create a SCSI WRITE WR. | |
509 | * @req: IO req structure. | |
510 | * | |
511 | * Gets a WR slot in the ingress queue and initializes it with | |
512 | * SCSI WRITE WR. | |
513 | * | |
514 | */ | |
515 | static inline void | |
516 | csio_scsi_write(struct csio_ioreq *req) | |
517 | { | |
518 | struct csio_wr_pair wrp; | |
519 | uint32_t size; | |
520 | struct csio_hw *hw = req->lnode->hwp; | |
521 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
522 | ||
523 | CSIO_SCSI_DATA_WRSZ(req, write, size, scsim->proto_cmd_len); | |
524 | size = ALIGN(size, 16); | |
525 | ||
526 | req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp); | |
527 | if (likely(req->drv_status == 0)) { | |
528 | if (likely(wrp.size1 >= size)) { | |
529 | /* Initialize WR in one shot */ | |
530 | csio_scsi_init_write_wr(req, wrp.addr1, size); | |
531 | } else { | |
532 | uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx); | |
533 | /* | |
534 | * Make a temporary copy of the WR and write back | |
535 | * the copy into the WR pair. | |
536 | */ | |
537 | csio_scsi_init_write_wr(req, (void *)tmpwr, size); | |
538 | memcpy(wrp.addr1, tmpwr, wrp.size1); | |
539 | memcpy(wrp.addr2, tmpwr + wrp.size1, size - wrp.size1); | |
540 | } | |
541 | } | |
542 | } | |
543 | ||
544 | /* | |
545 | * csio_setup_ddp - Setup DDP buffers for Read request. | |
546 | * @req: IO req structure. | |
547 | * | |
548 | * Checks SGLs/Data buffers are virtually contiguous required for DDP. | |
549 | * If contiguous,driver posts SGLs in the WR otherwise post internal | |
550 | * buffers for such request for DDP. | |
551 | */ | |
552 | static inline void | |
553 | csio_setup_ddp(struct csio_scsim *scsim, struct csio_ioreq *req) | |
554 | { | |
555 | #ifdef __CSIO_DEBUG__ | |
556 | struct csio_hw *hw = req->lnode->hwp; | |
557 | #endif | |
558 | struct scatterlist *sgel = NULL; | |
559 | struct scsi_cmnd *scmnd = csio_scsi_cmnd(req); | |
560 | uint64_t sg_addr = 0; | |
561 | uint32_t ddp_pagesz = 4096; | |
562 | uint32_t buf_off; | |
563 | struct csio_dma_buf *dma_buf = NULL; | |
564 | uint32_t alloc_len = 0; | |
565 | uint32_t xfer_len = 0; | |
566 | uint32_t sg_len = 0; | |
567 | uint32_t i; | |
568 | ||
569 | scsi_for_each_sg(scmnd, sgel, req->nsge, i) { | |
570 | sg_addr = sg_dma_address(sgel); | |
571 | sg_len = sg_dma_len(sgel); | |
572 | ||
573 | buf_off = sg_addr & (ddp_pagesz - 1); | |
574 | ||
575 | /* Except 1st buffer,all buffer addr have to be Page aligned */ | |
576 | if (i != 0 && buf_off) { | |
577 | csio_dbg(hw, "SGL addr not DDP aligned (%llx:%d)\n", | |
578 | sg_addr, sg_len); | |
579 | goto unaligned; | |
580 | } | |
581 | ||
582 | /* Except last buffer,all buffer must end on page boundary */ | |
583 | if ((i != (req->nsge - 1)) && | |
584 | ((buf_off + sg_len) & (ddp_pagesz - 1))) { | |
585 | csio_dbg(hw, | |
586 | "SGL addr not ending on page boundary" | |
587 | "(%llx:%d)\n", sg_addr, sg_len); | |
588 | goto unaligned; | |
589 | } | |
590 | } | |
591 | ||
592 | /* SGL's are virtually contiguous. HW will DDP to SGLs */ | |
593 | req->dcopy = 0; | |
594 | csio_scsi_read(req); | |
595 | ||
596 | return; | |
597 | ||
598 | unaligned: | |
599 | CSIO_INC_STATS(scsim, n_unaligned); | |
600 | /* | |
601 | * For unaligned SGLs, driver will allocate internal DDP buffer. | |
602 | * Once command is completed data from DDP buffer copied to SGLs | |
603 | */ | |
604 | req->dcopy = 1; | |
605 | ||
606 | /* Use gen_list to store the DDP buffers */ | |
607 | INIT_LIST_HEAD(&req->gen_list); | |
608 | xfer_len = scsi_bufflen(scmnd); | |
609 | ||
610 | i = 0; | |
611 | /* Allocate ddp buffers for this request */ | |
612 | while (alloc_len < xfer_len) { | |
613 | dma_buf = csio_get_scsi_ddp(scsim); | |
614 | if (dma_buf == NULL || i > scsim->max_sge) { | |
615 | req->drv_status = -EBUSY; | |
616 | break; | |
617 | } | |
618 | alloc_len += dma_buf->len; | |
619 | /* Added to IO req */ | |
620 | list_add_tail(&dma_buf->list, &req->gen_list); | |
621 | i++; | |
622 | } | |
623 | ||
624 | if (!req->drv_status) { | |
625 | /* set number of ddp bufs used */ | |
626 | req->nsge = i; | |
627 | csio_scsi_read(req); | |
628 | return; | |
629 | } | |
630 | ||
631 | /* release dma descs */ | |
632 | if (i > 0) | |
633 | csio_put_scsi_ddp_list(scsim, &req->gen_list, i); | |
634 | } | |
635 | ||
636 | /* | |
637 | * csio_scsi_init_abrt_cls_wr - Initialize an ABORT/CLOSE WR. | |
638 | * @req: IO req structure. | |
639 | * @addr: DMA location to place the payload. | |
640 | * @size: Size of WR | |
641 | * @abort: abort OR close | |
642 | * | |
643 | * Wrapper for populating fw_scsi_cmd_wr. | |
644 | */ | |
645 | static inline void | |
646 | csio_scsi_init_abrt_cls_wr(struct csio_ioreq *req, void *addr, uint32_t size, | |
647 | bool abort) | |
648 | { | |
649 | struct csio_hw *hw = req->lnode->hwp; | |
650 | struct csio_rnode *rn = req->rnode; | |
651 | struct fw_scsi_abrt_cls_wr *wr = (struct fw_scsi_abrt_cls_wr *)addr; | |
652 | ||
e2ac9628 HS |
653 | wr->op_immdlen = cpu_to_be32(FW_WR_OP_V(FW_SCSI_ABRT_CLS_WR)); |
654 | wr->flowid_len16 = cpu_to_be32(FW_WR_FLOWID_V(rn->flowid) | | |
655 | FW_WR_LEN16_V( | |
a3667aae NKI |
656 | DIV_ROUND_UP(size, 16))); |
657 | ||
658 | wr->cookie = (uintptr_t) req; | |
5036f0a0 | 659 | wr->iqid = cpu_to_be16(csio_q_physiqid(hw, req->iq_idx)); |
a3667aae NKI |
660 | wr->tmo_val = (uint8_t) req->tmo; |
661 | /* 0 for CHK_ALL_IO tells FW to look up t_cookie */ | |
662 | wr->sub_opcode_to_chk_all_io = | |
663 | (FW_SCSI_ABRT_CLS_WR_SUB_OPCODE(abort) | | |
664 | FW_SCSI_ABRT_CLS_WR_CHK_ALL_IO(0)); | |
665 | wr->r3[0] = 0; | |
666 | wr->r3[1] = 0; | |
667 | wr->r3[2] = 0; | |
668 | wr->r3[3] = 0; | |
669 | /* Since we re-use the same ioreq for abort as well */ | |
670 | wr->t_cookie = (uintptr_t) req; | |
671 | } | |
672 | ||
673 | static inline void | |
674 | csio_scsi_abrt_cls(struct csio_ioreq *req, bool abort) | |
675 | { | |
676 | struct csio_wr_pair wrp; | |
677 | struct csio_hw *hw = req->lnode->hwp; | |
678 | uint32_t size = ALIGN(sizeof(struct fw_scsi_abrt_cls_wr), 16); | |
679 | ||
680 | req->drv_status = csio_wr_get(hw, req->eq_idx, size, &wrp); | |
681 | if (req->drv_status != 0) | |
682 | return; | |
683 | ||
684 | if (wrp.size1 >= size) { | |
685 | /* Initialize WR in one shot */ | |
686 | csio_scsi_init_abrt_cls_wr(req, wrp.addr1, size, abort); | |
687 | } else { | |
688 | uint8_t *tmpwr = csio_q_eq_wrap(hw, req->eq_idx); | |
689 | /* | |
690 | * Make a temporary copy of the WR and write back | |
691 | * the copy into the WR pair. | |
692 | */ | |
693 | csio_scsi_init_abrt_cls_wr(req, (void *)tmpwr, size, abort); | |
694 | memcpy(wrp.addr1, tmpwr, wrp.size1); | |
695 | memcpy(wrp.addr2, tmpwr + wrp.size1, size - wrp.size1); | |
696 | } | |
697 | } | |
698 | ||
699 | /*****************************************************************************/ | |
700 | /* START: SCSI SM */ | |
701 | /*****************************************************************************/ | |
702 | static void | |
703 | csio_scsis_uninit(struct csio_ioreq *req, enum csio_scsi_ev evt) | |
704 | { | |
705 | struct csio_hw *hw = req->lnode->hwp; | |
706 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
707 | ||
708 | switch (evt) { | |
709 | case CSIO_SCSIE_START_IO: | |
710 | ||
711 | if (req->nsge) { | |
712 | if (req->datadir == DMA_TO_DEVICE) { | |
713 | req->dcopy = 0; | |
714 | csio_scsi_write(req); | |
715 | } else | |
716 | csio_setup_ddp(scsim, req); | |
717 | } else { | |
718 | csio_scsi_cmd(req); | |
719 | } | |
720 | ||
721 | if (likely(req->drv_status == 0)) { | |
722 | /* change state and enqueue on active_q */ | |
723 | csio_set_state(&req->sm, csio_scsis_io_active); | |
724 | list_add_tail(&req->sm.sm_list, &scsim->active_q); | |
725 | csio_wr_issue(hw, req->eq_idx, false); | |
726 | CSIO_INC_STATS(scsim, n_active); | |
727 | ||
728 | return; | |
729 | } | |
730 | break; | |
731 | ||
732 | case CSIO_SCSIE_START_TM: | |
733 | csio_scsi_cmd(req); | |
734 | if (req->drv_status == 0) { | |
735 | /* | |
736 | * NOTE: We collect the affected I/Os prior to issuing | |
737 | * LUN reset, and not after it. This is to prevent | |
738 | * aborting I/Os that get issued after the LUN reset, | |
739 | * but prior to LUN reset completion (in the event that | |
740 | * the host stack has not blocked I/Os to a LUN that is | |
741 | * being reset. | |
742 | */ | |
743 | csio_set_state(&req->sm, csio_scsis_tm_active); | |
744 | list_add_tail(&req->sm.sm_list, &scsim->active_q); | |
745 | csio_wr_issue(hw, req->eq_idx, false); | |
746 | CSIO_INC_STATS(scsim, n_tm_active); | |
747 | } | |
748 | return; | |
749 | ||
750 | case CSIO_SCSIE_ABORT: | |
751 | case CSIO_SCSIE_CLOSE: | |
752 | /* | |
753 | * NOTE: | |
754 | * We could get here due to : | |
755 | * - a window in the cleanup path of the SCSI module | |
756 | * (csio_scsi_abort_io()). Please see NOTE in this function. | |
757 | * - a window in the time we tried to issue an abort/close | |
758 | * of a request to FW, and the FW completed the request | |
759 | * itself. | |
760 | * Print a message for now, and return INVAL either way. | |
761 | */ | |
762 | req->drv_status = -EINVAL; | |
763 | csio_warn(hw, "Trying to abort/close completed IO:%p!\n", req); | |
764 | break; | |
765 | ||
766 | default: | |
767 | csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req); | |
768 | CSIO_DB_ASSERT(0); | |
769 | } | |
770 | } | |
771 | ||
772 | static void | |
773 | csio_scsis_io_active(struct csio_ioreq *req, enum csio_scsi_ev evt) | |
774 | { | |
775 | struct csio_hw *hw = req->lnode->hwp; | |
776 | struct csio_scsim *scm = csio_hw_to_scsim(hw); | |
777 | struct csio_rnode *rn; | |
778 | ||
779 | switch (evt) { | |
780 | case CSIO_SCSIE_COMPLETED: | |
781 | CSIO_DEC_STATS(scm, n_active); | |
782 | list_del_init(&req->sm.sm_list); | |
783 | csio_set_state(&req->sm, csio_scsis_uninit); | |
784 | /* | |
785 | * In MSIX mode, with multiple queues, the SCSI compeltions | |
786 | * could reach us sooner than the FW events sent to indicate | |
787 | * I-T nexus loss (link down, remote device logo etc). We | |
788 | * dont want to be returning such I/Os to the upper layer | |
789 | * immediately, since we wouldnt have reported the I-T nexus | |
790 | * loss itself. This forces us to serialize such completions | |
791 | * with the reporting of the I-T nexus loss. Therefore, we | |
792 | * internally queue up such up such completions in the rnode. | |
793 | * The reporting of I-T nexus loss to the upper layer is then | |
794 | * followed by the returning of I/Os in this internal queue. | |
795 | * Having another state alongwith another queue helps us take | |
796 | * actions for events such as ABORT received while we are | |
797 | * in this rnode queue. | |
798 | */ | |
799 | if (unlikely(req->wr_status != FW_SUCCESS)) { | |
800 | rn = req->rnode; | |
801 | /* | |
802 | * FW says remote device is lost, but rnode | |
803 | * doesnt reflect it. | |
804 | */ | |
805 | if (csio_scsi_itnexus_loss_error(req->wr_status) && | |
806 | csio_is_rnode_ready(rn)) { | |
807 | csio_set_state(&req->sm, | |
808 | csio_scsis_shost_cmpl_await); | |
809 | list_add_tail(&req->sm.sm_list, | |
810 | &rn->host_cmpl_q); | |
811 | } | |
812 | } | |
813 | ||
814 | break; | |
815 | ||
816 | case CSIO_SCSIE_ABORT: | |
817 | csio_scsi_abrt_cls(req, SCSI_ABORT); | |
818 | if (req->drv_status == 0) { | |
819 | csio_wr_issue(hw, req->eq_idx, false); | |
820 | csio_set_state(&req->sm, csio_scsis_aborting); | |
821 | } | |
822 | break; | |
823 | ||
824 | case CSIO_SCSIE_CLOSE: | |
825 | csio_scsi_abrt_cls(req, SCSI_CLOSE); | |
826 | if (req->drv_status == 0) { | |
827 | csio_wr_issue(hw, req->eq_idx, false); | |
828 | csio_set_state(&req->sm, csio_scsis_closing); | |
829 | } | |
830 | break; | |
831 | ||
832 | case CSIO_SCSIE_DRVCLEANUP: | |
833 | req->wr_status = FW_HOSTERROR; | |
834 | CSIO_DEC_STATS(scm, n_active); | |
835 | csio_set_state(&req->sm, csio_scsis_uninit); | |
836 | break; | |
837 | ||
838 | default: | |
839 | csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req); | |
840 | CSIO_DB_ASSERT(0); | |
841 | } | |
842 | } | |
843 | ||
844 | static void | |
845 | csio_scsis_tm_active(struct csio_ioreq *req, enum csio_scsi_ev evt) | |
846 | { | |
847 | struct csio_hw *hw = req->lnode->hwp; | |
848 | struct csio_scsim *scm = csio_hw_to_scsim(hw); | |
849 | ||
850 | switch (evt) { | |
851 | case CSIO_SCSIE_COMPLETED: | |
852 | CSIO_DEC_STATS(scm, n_tm_active); | |
853 | list_del_init(&req->sm.sm_list); | |
854 | csio_set_state(&req->sm, csio_scsis_uninit); | |
855 | ||
856 | break; | |
857 | ||
858 | case CSIO_SCSIE_ABORT: | |
859 | csio_scsi_abrt_cls(req, SCSI_ABORT); | |
860 | if (req->drv_status == 0) { | |
861 | csio_wr_issue(hw, req->eq_idx, false); | |
862 | csio_set_state(&req->sm, csio_scsis_aborting); | |
863 | } | |
864 | break; | |
865 | ||
866 | ||
867 | case CSIO_SCSIE_CLOSE: | |
868 | csio_scsi_abrt_cls(req, SCSI_CLOSE); | |
869 | if (req->drv_status == 0) { | |
870 | csio_wr_issue(hw, req->eq_idx, false); | |
871 | csio_set_state(&req->sm, csio_scsis_closing); | |
872 | } | |
873 | break; | |
874 | ||
875 | case CSIO_SCSIE_DRVCLEANUP: | |
876 | req->wr_status = FW_HOSTERROR; | |
877 | CSIO_DEC_STATS(scm, n_tm_active); | |
878 | csio_set_state(&req->sm, csio_scsis_uninit); | |
879 | break; | |
880 | ||
881 | default: | |
882 | csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req); | |
883 | CSIO_DB_ASSERT(0); | |
884 | } | |
885 | } | |
886 | ||
887 | static void | |
888 | csio_scsis_aborting(struct csio_ioreq *req, enum csio_scsi_ev evt) | |
889 | { | |
890 | struct csio_hw *hw = req->lnode->hwp; | |
891 | struct csio_scsim *scm = csio_hw_to_scsim(hw); | |
892 | ||
893 | switch (evt) { | |
894 | case CSIO_SCSIE_COMPLETED: | |
895 | csio_dbg(hw, | |
896 | "ioreq %p recvd cmpltd (wr_status:%d) " | |
897 | "in aborting st\n", req, req->wr_status); | |
898 | /* | |
899 | * Use -ECANCELED to explicitly tell the ABORTED event that | |
900 | * the original I/O was returned to driver by FW. | |
901 | * We dont really care if the I/O was returned with success by | |
902 | * FW (because the ABORT and completion of the I/O crossed each | |
903 | * other), or any other return value. Once we are in aborting | |
904 | * state, the success or failure of the I/O is unimportant to | |
905 | * us. | |
906 | */ | |
907 | req->drv_status = -ECANCELED; | |
908 | break; | |
909 | ||
910 | case CSIO_SCSIE_ABORT: | |
911 | CSIO_INC_STATS(scm, n_abrt_dups); | |
912 | break; | |
913 | ||
914 | case CSIO_SCSIE_ABORTED: | |
915 | ||
916 | csio_dbg(hw, "abort of %p return status:0x%x drv_status:%x\n", | |
917 | req, req->wr_status, req->drv_status); | |
918 | /* | |
919 | * Check if original I/O WR completed before the Abort | |
920 | * completion. | |
921 | */ | |
922 | if (req->drv_status != -ECANCELED) { | |
923 | csio_warn(hw, | |
924 | "Abort completed before original I/O," | |
925 | " req:%p\n", req); | |
926 | CSIO_DB_ASSERT(0); | |
927 | } | |
928 | ||
929 | /* | |
930 | * There are the following possible scenarios: | |
931 | * 1. The abort completed successfully, FW returned FW_SUCCESS. | |
932 | * 2. The completion of an I/O and the receipt of | |
933 | * abort for that I/O by the FW crossed each other. | |
934 | * The FW returned FW_EINVAL. The original I/O would have | |
935 | * returned with FW_SUCCESS or any other SCSI error. | |
936 | * 3. The FW couldnt sent the abort out on the wire, as there | |
937 | * was an I-T nexus loss (link down, remote device logged | |
938 | * out etc). FW sent back an appropriate IT nexus loss status | |
939 | * for the abort. | |
940 | * 4. FW sent an abort, but abort timed out (remote device | |
941 | * didnt respond). FW replied back with | |
942 | * FW_SCSI_ABORT_TIMEDOUT. | |
943 | * 5. FW couldnt genuinely abort the request for some reason, | |
944 | * and sent us an error. | |
945 | * | |
946 | * The first 3 scenarios are treated as succesful abort | |
947 | * operations by the host, while the last 2 are failed attempts | |
948 | * to abort. Manipulate the return value of the request | |
949 | * appropriately, so that host can convey these results | |
950 | * back to the upper layer. | |
951 | */ | |
952 | if ((req->wr_status == FW_SUCCESS) || | |
953 | (req->wr_status == FW_EINVAL) || | |
954 | csio_scsi_itnexus_loss_error(req->wr_status)) | |
955 | req->wr_status = FW_SCSI_ABORT_REQUESTED; | |
956 | ||
957 | CSIO_DEC_STATS(scm, n_active); | |
958 | list_del_init(&req->sm.sm_list); | |
959 | csio_set_state(&req->sm, csio_scsis_uninit); | |
960 | break; | |
961 | ||
962 | case CSIO_SCSIE_DRVCLEANUP: | |
963 | req->wr_status = FW_HOSTERROR; | |
964 | CSIO_DEC_STATS(scm, n_active); | |
965 | csio_set_state(&req->sm, csio_scsis_uninit); | |
966 | break; | |
967 | ||
968 | case CSIO_SCSIE_CLOSE: | |
969 | /* | |
970 | * We can receive this event from the module | |
971 | * cleanup paths, if the FW forgot to reply to the ABORT WR | |
972 | * and left this ioreq in this state. For now, just ignore | |
973 | * the event. The CLOSE event is sent to this state, as | |
974 | * the LINK may have already gone down. | |
975 | */ | |
976 | break; | |
977 | ||
978 | default: | |
979 | csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req); | |
980 | CSIO_DB_ASSERT(0); | |
981 | } | |
982 | } | |
983 | ||
984 | static void | |
985 | csio_scsis_closing(struct csio_ioreq *req, enum csio_scsi_ev evt) | |
986 | { | |
987 | struct csio_hw *hw = req->lnode->hwp; | |
988 | struct csio_scsim *scm = csio_hw_to_scsim(hw); | |
989 | ||
990 | switch (evt) { | |
991 | case CSIO_SCSIE_COMPLETED: | |
992 | csio_dbg(hw, | |
993 | "ioreq %p recvd cmpltd (wr_status:%d) " | |
994 | "in closing st\n", req, req->wr_status); | |
995 | /* | |
996 | * Use -ECANCELED to explicitly tell the CLOSED event that | |
997 | * the original I/O was returned to driver by FW. | |
998 | * We dont really care if the I/O was returned with success by | |
999 | * FW (because the CLOSE and completion of the I/O crossed each | |
1000 | * other), or any other return value. Once we are in aborting | |
1001 | * state, the success or failure of the I/O is unimportant to | |
1002 | * us. | |
1003 | */ | |
1004 | req->drv_status = -ECANCELED; | |
1005 | break; | |
1006 | ||
1007 | case CSIO_SCSIE_CLOSED: | |
1008 | /* | |
1009 | * Check if original I/O WR completed before the Close | |
1010 | * completion. | |
1011 | */ | |
1012 | if (req->drv_status != -ECANCELED) { | |
1013 | csio_fatal(hw, | |
1014 | "Close completed before original I/O," | |
1015 | " req:%p\n", req); | |
1016 | CSIO_DB_ASSERT(0); | |
1017 | } | |
1018 | ||
1019 | /* | |
1020 | * Either close succeeded, or we issued close to FW at the | |
1021 | * same time FW compelted it to us. Either way, the I/O | |
1022 | * is closed. | |
1023 | */ | |
1024 | CSIO_DB_ASSERT((req->wr_status == FW_SUCCESS) || | |
1025 | (req->wr_status == FW_EINVAL)); | |
1026 | req->wr_status = FW_SCSI_CLOSE_REQUESTED; | |
1027 | ||
1028 | CSIO_DEC_STATS(scm, n_active); | |
1029 | list_del_init(&req->sm.sm_list); | |
1030 | csio_set_state(&req->sm, csio_scsis_uninit); | |
1031 | break; | |
1032 | ||
1033 | case CSIO_SCSIE_CLOSE: | |
1034 | break; | |
1035 | ||
1036 | case CSIO_SCSIE_DRVCLEANUP: | |
1037 | req->wr_status = FW_HOSTERROR; | |
1038 | CSIO_DEC_STATS(scm, n_active); | |
1039 | csio_set_state(&req->sm, csio_scsis_uninit); | |
1040 | break; | |
1041 | ||
1042 | default: | |
1043 | csio_dbg(hw, "Unhandled event:%d sent to req:%p\n", evt, req); | |
1044 | CSIO_DB_ASSERT(0); | |
1045 | } | |
1046 | } | |
1047 | ||
1048 | static void | |
1049 | csio_scsis_shost_cmpl_await(struct csio_ioreq *req, enum csio_scsi_ev evt) | |
1050 | { | |
1051 | switch (evt) { | |
1052 | case CSIO_SCSIE_ABORT: | |
1053 | case CSIO_SCSIE_CLOSE: | |
1054 | /* | |
1055 | * Just succeed the abort request, and hope that | |
1056 | * the remote device unregister path will cleanup | |
1057 | * this I/O to the upper layer within a sane | |
1058 | * amount of time. | |
1059 | */ | |
1060 | /* | |
1061 | * A close can come in during a LINK DOWN. The FW would have | |
1062 | * returned us the I/O back, but not the remote device lost | |
1063 | * FW event. In this interval, if the I/O times out at the upper | |
1064 | * layer, a close can come in. Take the same action as abort: | |
1065 | * return success, and hope that the remote device unregister | |
1066 | * path will cleanup this I/O. If the FW still doesnt send | |
1067 | * the msg, the close times out, and the upper layer resorts | |
1068 | * to the next level of error recovery. | |
1069 | */ | |
1070 | req->drv_status = 0; | |
1071 | break; | |
1072 | case CSIO_SCSIE_DRVCLEANUP: | |
1073 | csio_set_state(&req->sm, csio_scsis_uninit); | |
1074 | break; | |
1075 | default: | |
1076 | csio_dbg(req->lnode->hwp, "Unhandled event:%d sent to req:%p\n", | |
1077 | evt, req); | |
1078 | CSIO_DB_ASSERT(0); | |
1079 | } | |
1080 | } | |
1081 | ||
1082 | /* | |
1083 | * csio_scsi_cmpl_handler - WR completion handler for SCSI. | |
1084 | * @hw: HW module. | |
1085 | * @wr: The completed WR from the ingress queue. | |
1086 | * @len: Length of the WR. | |
1087 | * @flb: Freelist buffer array. | |
1088 | * @priv: Private object | |
1089 | * @scsiwr: Pointer to SCSI WR. | |
1090 | * | |
1091 | * This is the WR completion handler called per completion from the | |
1092 | * ISR. It is called with lock held. It walks past the RSS and CPL message | |
1093 | * header where the actual WR is present. | |
1094 | * It then gets the status, WR handle (ioreq pointer) and the len of | |
1095 | * the WR, based on WR opcode. Only on a non-good status is the entire | |
1096 | * WR copied into the WR cache (ioreq->fw_wr). | |
1097 | * The ioreq corresponding to the WR is returned to the caller. | |
1098 | * NOTE: The SCSI queue doesnt allocate a freelist today, hence | |
1099 | * no freelist buffer is expected. | |
1100 | */ | |
1101 | struct csio_ioreq * | |
1102 | csio_scsi_cmpl_handler(struct csio_hw *hw, void *wr, uint32_t len, | |
1103 | struct csio_fl_dma_buf *flb, void *priv, uint8_t **scsiwr) | |
1104 | { | |
1105 | struct csio_ioreq *ioreq = NULL; | |
1106 | struct cpl_fw6_msg *cpl; | |
1107 | uint8_t *tempwr; | |
1108 | uint8_t status; | |
1109 | struct csio_scsim *scm = csio_hw_to_scsim(hw); | |
1110 | ||
1111 | /* skip RSS header */ | |
1112 | cpl = (struct cpl_fw6_msg *)((uintptr_t)wr + sizeof(__be64)); | |
1113 | ||
1114 | if (unlikely(cpl->opcode != CPL_FW6_MSG)) { | |
1115 | csio_warn(hw, "Error: Invalid CPL msg %x recvd on SCSI q\n", | |
1116 | cpl->opcode); | |
1117 | CSIO_INC_STATS(scm, n_inval_cplop); | |
1118 | return NULL; | |
1119 | } | |
1120 | ||
1121 | tempwr = (uint8_t *)(cpl->data); | |
1122 | status = csio_wr_status(tempwr); | |
1123 | *scsiwr = tempwr; | |
1124 | ||
1125 | if (likely((*tempwr == FW_SCSI_READ_WR) || | |
1126 | (*tempwr == FW_SCSI_WRITE_WR) || | |
1127 | (*tempwr == FW_SCSI_CMD_WR))) { | |
1128 | ioreq = (struct csio_ioreq *)((uintptr_t) | |
1129 | (((struct fw_scsi_read_wr *)tempwr)->cookie)); | |
1130 | CSIO_DB_ASSERT(virt_addr_valid(ioreq)); | |
1131 | ||
1132 | ioreq->wr_status = status; | |
1133 | ||
1134 | return ioreq; | |
1135 | } | |
1136 | ||
1137 | if (*tempwr == FW_SCSI_ABRT_CLS_WR) { | |
1138 | ioreq = (struct csio_ioreq *)((uintptr_t) | |
1139 | (((struct fw_scsi_abrt_cls_wr *)tempwr)->cookie)); | |
1140 | CSIO_DB_ASSERT(virt_addr_valid(ioreq)); | |
1141 | ||
1142 | ioreq->wr_status = status; | |
1143 | return ioreq; | |
1144 | } | |
1145 | ||
1146 | csio_warn(hw, "WR with invalid opcode in SCSI IQ: %x\n", *tempwr); | |
1147 | CSIO_INC_STATS(scm, n_inval_scsiop); | |
1148 | return NULL; | |
1149 | } | |
1150 | ||
1151 | /* | |
1152 | * csio_scsi_cleanup_io_q - Cleanup the given queue. | |
1153 | * @scm: SCSI module. | |
1154 | * @q: Queue to be cleaned up. | |
1155 | * | |
1156 | * Called with lock held. Has to exit with lock held. | |
1157 | */ | |
1158 | void | |
1159 | csio_scsi_cleanup_io_q(struct csio_scsim *scm, struct list_head *q) | |
1160 | { | |
1161 | struct csio_hw *hw = scm->hw; | |
1162 | struct csio_ioreq *ioreq; | |
1163 | struct list_head *tmp, *next; | |
1164 | struct scsi_cmnd *scmnd; | |
1165 | ||
1166 | /* Call back the completion routines of the active_q */ | |
1167 | list_for_each_safe(tmp, next, q) { | |
1168 | ioreq = (struct csio_ioreq *)tmp; | |
1169 | csio_scsi_drvcleanup(ioreq); | |
1170 | list_del_init(&ioreq->sm.sm_list); | |
1171 | scmnd = csio_scsi_cmnd(ioreq); | |
1172 | spin_unlock_irq(&hw->lock); | |
1173 | ||
1174 | /* | |
1175 | * Upper layers may have cleared this command, hence this | |
1176 | * check to avoid accessing stale references. | |
1177 | */ | |
1178 | if (scmnd != NULL) | |
1179 | ioreq->io_cbfn(hw, ioreq); | |
1180 | ||
1181 | spin_lock_irq(&scm->freelist_lock); | |
1182 | csio_put_scsi_ioreq(scm, ioreq); | |
1183 | spin_unlock_irq(&scm->freelist_lock); | |
1184 | ||
1185 | spin_lock_irq(&hw->lock); | |
1186 | } | |
1187 | } | |
1188 | ||
1189 | #define CSIO_SCSI_ABORT_Q_POLL_MS 2000 | |
1190 | ||
1191 | static void | |
1192 | csio_abrt_cls(struct csio_ioreq *ioreq, struct scsi_cmnd *scmnd) | |
1193 | { | |
1194 | struct csio_lnode *ln = ioreq->lnode; | |
1195 | struct csio_hw *hw = ln->hwp; | |
1196 | int ready = 0; | |
1197 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
1198 | int rv; | |
1199 | ||
1200 | if (csio_scsi_cmnd(ioreq) != scmnd) { | |
1201 | CSIO_INC_STATS(scsim, n_abrt_race_comp); | |
1202 | return; | |
1203 | } | |
1204 | ||
1205 | ready = csio_is_lnode_ready(ln); | |
1206 | ||
1207 | rv = csio_do_abrt_cls(hw, ioreq, (ready ? SCSI_ABORT : SCSI_CLOSE)); | |
1208 | if (rv != 0) { | |
1209 | if (ready) | |
1210 | CSIO_INC_STATS(scsim, n_abrt_busy_error); | |
1211 | else | |
1212 | CSIO_INC_STATS(scsim, n_cls_busy_error); | |
1213 | } | |
1214 | } | |
1215 | ||
1216 | /* | |
1217 | * csio_scsi_abort_io_q - Abort all I/Os on given queue | |
1218 | * @scm: SCSI module. | |
1219 | * @q: Queue to abort. | |
1220 | * @tmo: Timeout in ms | |
1221 | * | |
1222 | * Attempt to abort all I/Os on given queue, and wait for a max | |
1223 | * of tmo milliseconds for them to complete. Returns success | |
1224 | * if all I/Os are aborted. Else returns -ETIMEDOUT. | |
1225 | * Should be entered with lock held. Exits with lock held. | |
1226 | * NOTE: | |
1227 | * Lock has to be held across the loop that aborts I/Os, since dropping the lock | |
1228 | * in between can cause the list to be corrupted. As a result, the caller | |
1229 | * of this function has to ensure that the number of I/os to be aborted | |
1230 | * is finite enough to not cause lock-held-for-too-long issues. | |
1231 | */ | |
1232 | static int | |
1233 | csio_scsi_abort_io_q(struct csio_scsim *scm, struct list_head *q, uint32_t tmo) | |
1234 | { | |
1235 | struct csio_hw *hw = scm->hw; | |
1236 | struct list_head *tmp, *next; | |
1237 | int count = DIV_ROUND_UP(tmo, CSIO_SCSI_ABORT_Q_POLL_MS); | |
1238 | struct scsi_cmnd *scmnd; | |
1239 | ||
1240 | if (list_empty(q)) | |
1241 | return 0; | |
1242 | ||
1243 | csio_dbg(hw, "Aborting SCSI I/Os\n"); | |
1244 | ||
1245 | /* Now abort/close I/Os in the queue passed */ | |
1246 | list_for_each_safe(tmp, next, q) { | |
1247 | scmnd = csio_scsi_cmnd((struct csio_ioreq *)tmp); | |
1248 | csio_abrt_cls((struct csio_ioreq *)tmp, scmnd); | |
1249 | } | |
1250 | ||
1251 | /* Wait till all active I/Os are completed/aborted/closed */ | |
1252 | while (!list_empty(q) && count--) { | |
1253 | spin_unlock_irq(&hw->lock); | |
1254 | msleep(CSIO_SCSI_ABORT_Q_POLL_MS); | |
1255 | spin_lock_irq(&hw->lock); | |
1256 | } | |
1257 | ||
1258 | /* all aborts completed */ | |
1259 | if (list_empty(q)) | |
1260 | return 0; | |
1261 | ||
1262 | return -ETIMEDOUT; | |
1263 | } | |
1264 | ||
1265 | /* | |
1266 | * csio_scsim_cleanup_io - Cleanup all I/Os in SCSI module. | |
1267 | * @scm: SCSI module. | |
1268 | * @abort: abort required. | |
1269 | * Called with lock held, should exit with lock held. | |
1270 | * Can sleep when waiting for I/Os to complete. | |
1271 | */ | |
1272 | int | |
1273 | csio_scsim_cleanup_io(struct csio_scsim *scm, bool abort) | |
1274 | { | |
1275 | struct csio_hw *hw = scm->hw; | |
1276 | int rv = 0; | |
1277 | int count = DIV_ROUND_UP(60 * 1000, CSIO_SCSI_ABORT_Q_POLL_MS); | |
1278 | ||
1279 | /* No I/Os pending */ | |
1280 | if (list_empty(&scm->active_q)) | |
1281 | return 0; | |
1282 | ||
1283 | /* Wait until all active I/Os are completed */ | |
1284 | while (!list_empty(&scm->active_q) && count--) { | |
1285 | spin_unlock_irq(&hw->lock); | |
1286 | msleep(CSIO_SCSI_ABORT_Q_POLL_MS); | |
1287 | spin_lock_irq(&hw->lock); | |
1288 | } | |
1289 | ||
1290 | /* all I/Os completed */ | |
1291 | if (list_empty(&scm->active_q)) | |
1292 | return 0; | |
1293 | ||
1294 | /* Else abort */ | |
1295 | if (abort) { | |
1296 | rv = csio_scsi_abort_io_q(scm, &scm->active_q, 30000); | |
1297 | if (rv == 0) | |
1298 | return rv; | |
1299 | csio_dbg(hw, "Some I/O aborts timed out, cleaning up..\n"); | |
1300 | } | |
1301 | ||
1302 | csio_scsi_cleanup_io_q(scm, &scm->active_q); | |
1303 | ||
1304 | CSIO_DB_ASSERT(list_empty(&scm->active_q)); | |
1305 | ||
1306 | return rv; | |
1307 | } | |
1308 | ||
1309 | /* | |
1310 | * csio_scsim_cleanup_io_lnode - Cleanup all I/Os of given lnode. | |
1311 | * @scm: SCSI module. | |
1312 | * @lnode: lnode | |
1313 | * | |
1314 | * Called with lock held, should exit with lock held. | |
1315 | * Can sleep (with dropped lock) when waiting for I/Os to complete. | |
1316 | */ | |
1317 | int | |
1318 | csio_scsim_cleanup_io_lnode(struct csio_scsim *scm, struct csio_lnode *ln) | |
1319 | { | |
1320 | struct csio_hw *hw = scm->hw; | |
1321 | struct csio_scsi_level_data sld; | |
1322 | int rv; | |
1323 | int count = DIV_ROUND_UP(60 * 1000, CSIO_SCSI_ABORT_Q_POLL_MS); | |
1324 | ||
1325 | csio_dbg(hw, "Gathering all SCSI I/Os on lnode %p\n", ln); | |
1326 | ||
1327 | sld.level = CSIO_LEV_LNODE; | |
1328 | sld.lnode = ln; | |
1329 | INIT_LIST_HEAD(&ln->cmpl_q); | |
1330 | csio_scsi_gather_active_ios(scm, &sld, &ln->cmpl_q); | |
1331 | ||
1332 | /* No I/Os pending on this lnode */ | |
1333 | if (list_empty(&ln->cmpl_q)) | |
1334 | return 0; | |
1335 | ||
1336 | /* Wait until all active I/Os on this lnode are completed */ | |
1337 | while (!list_empty(&ln->cmpl_q) && count--) { | |
1338 | spin_unlock_irq(&hw->lock); | |
1339 | msleep(CSIO_SCSI_ABORT_Q_POLL_MS); | |
1340 | spin_lock_irq(&hw->lock); | |
1341 | } | |
1342 | ||
1343 | /* all I/Os completed */ | |
1344 | if (list_empty(&ln->cmpl_q)) | |
1345 | return 0; | |
1346 | ||
1347 | csio_dbg(hw, "Some I/Os pending on ln:%p, aborting them..\n", ln); | |
1348 | ||
1349 | /* I/Os are pending, abort them */ | |
1350 | rv = csio_scsi_abort_io_q(scm, &ln->cmpl_q, 30000); | |
1351 | if (rv != 0) { | |
1352 | csio_dbg(hw, "Some I/O aborts timed out, cleaning up..\n"); | |
1353 | csio_scsi_cleanup_io_q(scm, &ln->cmpl_q); | |
1354 | } | |
1355 | ||
1356 | CSIO_DB_ASSERT(list_empty(&ln->cmpl_q)); | |
1357 | ||
1358 | return rv; | |
1359 | } | |
1360 | ||
1361 | static ssize_t | |
1362 | csio_show_hw_state(struct device *dev, | |
1363 | struct device_attribute *attr, char *buf) | |
1364 | { | |
1365 | struct csio_lnode *ln = shost_priv(class_to_shost(dev)); | |
1366 | struct csio_hw *hw = csio_lnode_to_hw(ln); | |
1367 | ||
1368 | if (csio_is_hw_ready(hw)) | |
1369 | return snprintf(buf, PAGE_SIZE, "ready\n"); | |
1370 | else | |
1371 | return snprintf(buf, PAGE_SIZE, "not ready\n"); | |
1372 | } | |
1373 | ||
1374 | /* Device reset */ | |
1375 | static ssize_t | |
1376 | csio_device_reset(struct device *dev, | |
1377 | struct device_attribute *attr, const char *buf, size_t count) | |
1378 | { | |
1379 | struct csio_lnode *ln = shost_priv(class_to_shost(dev)); | |
1380 | struct csio_hw *hw = csio_lnode_to_hw(ln); | |
1381 | ||
1382 | if (*buf != '1') | |
1383 | return -EINVAL; | |
1384 | ||
1385 | /* Delete NPIV lnodes */ | |
1386 | csio_lnodes_exit(hw, 1); | |
1387 | ||
1388 | /* Block upper IOs */ | |
1389 | csio_lnodes_block_request(hw); | |
1390 | ||
1391 | spin_lock_irq(&hw->lock); | |
1392 | csio_hw_reset(hw); | |
1393 | spin_unlock_irq(&hw->lock); | |
1394 | ||
1395 | /* Unblock upper IOs */ | |
1396 | csio_lnodes_unblock_request(hw); | |
1397 | return count; | |
1398 | } | |
1399 | ||
1400 | /* disable port */ | |
1401 | static ssize_t | |
1402 | csio_disable_port(struct device *dev, | |
1403 | struct device_attribute *attr, const char *buf, size_t count) | |
1404 | { | |
1405 | struct csio_lnode *ln = shost_priv(class_to_shost(dev)); | |
1406 | struct csio_hw *hw = csio_lnode_to_hw(ln); | |
1407 | bool disable; | |
1408 | ||
1409 | if (*buf == '1' || *buf == '0') | |
1410 | disable = (*buf == '1') ? true : false; | |
1411 | else | |
1412 | return -EINVAL; | |
1413 | ||
1414 | /* Block upper IOs */ | |
1415 | csio_lnodes_block_by_port(hw, ln->portid); | |
1416 | ||
1417 | spin_lock_irq(&hw->lock); | |
1418 | csio_disable_lnodes(hw, ln->portid, disable); | |
1419 | spin_unlock_irq(&hw->lock); | |
1420 | ||
1421 | /* Unblock upper IOs */ | |
1422 | csio_lnodes_unblock_by_port(hw, ln->portid); | |
1423 | return count; | |
1424 | } | |
1425 | ||
1426 | /* Show debug level */ | |
1427 | static ssize_t | |
1428 | csio_show_dbg_level(struct device *dev, | |
1429 | struct device_attribute *attr, char *buf) | |
1430 | { | |
1431 | struct csio_lnode *ln = shost_priv(class_to_shost(dev)); | |
1432 | ||
1433 | return snprintf(buf, PAGE_SIZE, "%x\n", ln->params.log_level); | |
1434 | } | |
1435 | ||
1436 | /* Store debug level */ | |
1437 | static ssize_t | |
1438 | csio_store_dbg_level(struct device *dev, | |
1439 | struct device_attribute *attr, const char *buf, size_t count) | |
1440 | { | |
1441 | struct csio_lnode *ln = shost_priv(class_to_shost(dev)); | |
1442 | struct csio_hw *hw = csio_lnode_to_hw(ln); | |
1443 | uint32_t dbg_level = 0; | |
1444 | ||
1445 | if (!isdigit(buf[0])) | |
1446 | return -EINVAL; | |
1447 | ||
1448 | if (sscanf(buf, "%i", &dbg_level)) | |
1449 | return -EINVAL; | |
1450 | ||
1451 | ln->params.log_level = dbg_level; | |
1452 | hw->params.log_level = dbg_level; | |
1453 | ||
1454 | return 0; | |
1455 | } | |
1456 | ||
1457 | static DEVICE_ATTR(hw_state, S_IRUGO, csio_show_hw_state, NULL); | |
49c12413 NKI |
1458 | static DEVICE_ATTR(device_reset, S_IWUSR, NULL, csio_device_reset); |
1459 | static DEVICE_ATTR(disable_port, S_IWUSR, NULL, csio_disable_port); | |
a3667aae NKI |
1460 | static DEVICE_ATTR(dbg_level, S_IRUGO | S_IWUSR, csio_show_dbg_level, |
1461 | csio_store_dbg_level); | |
1462 | ||
1463 | static struct device_attribute *csio_fcoe_lport_attrs[] = { | |
1464 | &dev_attr_hw_state, | |
1465 | &dev_attr_device_reset, | |
1466 | &dev_attr_disable_port, | |
1467 | &dev_attr_dbg_level, | |
1468 | NULL, | |
1469 | }; | |
1470 | ||
1471 | static ssize_t | |
1472 | csio_show_num_reg_rnodes(struct device *dev, | |
1473 | struct device_attribute *attr, char *buf) | |
1474 | { | |
1475 | struct csio_lnode *ln = shost_priv(class_to_shost(dev)); | |
1476 | ||
1477 | return snprintf(buf, PAGE_SIZE, "%d\n", ln->num_reg_rnodes); | |
1478 | } | |
1479 | ||
1480 | static DEVICE_ATTR(num_reg_rnodes, S_IRUGO, csio_show_num_reg_rnodes, NULL); | |
1481 | ||
1482 | static struct device_attribute *csio_fcoe_vport_attrs[] = { | |
1483 | &dev_attr_num_reg_rnodes, | |
1484 | &dev_attr_dbg_level, | |
1485 | NULL, | |
1486 | }; | |
1487 | ||
1488 | static inline uint32_t | |
1489 | csio_scsi_copy_to_sgl(struct csio_hw *hw, struct csio_ioreq *req) | |
1490 | { | |
1491 | struct scsi_cmnd *scmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req); | |
1492 | struct scatterlist *sg; | |
1493 | uint32_t bytes_left; | |
1494 | uint32_t bytes_copy; | |
1495 | uint32_t buf_off = 0; | |
1496 | uint32_t start_off = 0; | |
1497 | uint32_t sg_off = 0; | |
1498 | void *sg_addr; | |
1499 | void *buf_addr; | |
1500 | struct csio_dma_buf *dma_buf; | |
1501 | ||
1502 | bytes_left = scsi_bufflen(scmnd); | |
1503 | sg = scsi_sglist(scmnd); | |
1504 | dma_buf = (struct csio_dma_buf *)csio_list_next(&req->gen_list); | |
1505 | ||
1506 | /* Copy data from driver buffer to SGs of SCSI CMD */ | |
1507 | while (bytes_left > 0 && sg && dma_buf) { | |
1508 | if (buf_off >= dma_buf->len) { | |
1509 | buf_off = 0; | |
1510 | dma_buf = (struct csio_dma_buf *) | |
1511 | csio_list_next(dma_buf); | |
1512 | continue; | |
1513 | } | |
1514 | ||
1515 | if (start_off >= sg->length) { | |
1516 | start_off -= sg->length; | |
1517 | sg = sg_next(sg); | |
1518 | continue; | |
1519 | } | |
1520 | ||
1521 | buf_addr = dma_buf->vaddr + buf_off; | |
1522 | sg_off = sg->offset + start_off; | |
1523 | bytes_copy = min((dma_buf->len - buf_off), | |
1524 | sg->length - start_off); | |
1525 | bytes_copy = min((uint32_t)(PAGE_SIZE - (sg_off & ~PAGE_MASK)), | |
1526 | bytes_copy); | |
1527 | ||
1528 | sg_addr = kmap_atomic(sg_page(sg) + (sg_off >> PAGE_SHIFT)); | |
1529 | if (!sg_addr) { | |
1530 | csio_err(hw, "failed to kmap sg:%p of ioreq:%p\n", | |
1531 | sg, req); | |
1532 | break; | |
1533 | } | |
1534 | ||
1535 | csio_dbg(hw, "copy_to_sgl:sg_addr %p sg_off %d buf %p len %d\n", | |
1536 | sg_addr, sg_off, buf_addr, bytes_copy); | |
1537 | memcpy(sg_addr + (sg_off & ~PAGE_MASK), buf_addr, bytes_copy); | |
1538 | kunmap_atomic(sg_addr); | |
1539 | ||
1540 | start_off += bytes_copy; | |
1541 | buf_off += bytes_copy; | |
1542 | bytes_left -= bytes_copy; | |
1543 | } | |
1544 | ||
1545 | if (bytes_left > 0) | |
1546 | return DID_ERROR; | |
1547 | else | |
1548 | return DID_OK; | |
1549 | } | |
1550 | ||
1551 | /* | |
1552 | * csio_scsi_err_handler - SCSI error handler. | |
1553 | * @hw: HW module. | |
1554 | * @req: IO request. | |
1555 | * | |
1556 | */ | |
1557 | static inline void | |
1558 | csio_scsi_err_handler(struct csio_hw *hw, struct csio_ioreq *req) | |
1559 | { | |
1560 | struct scsi_cmnd *cmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req); | |
1561 | struct csio_scsim *scm = csio_hw_to_scsim(hw); | |
1562 | struct fcp_resp_with_ext *fcp_resp; | |
1563 | struct fcp_resp_rsp_info *rsp_info; | |
1564 | struct csio_dma_buf *dma_buf; | |
1565 | uint8_t flags, scsi_status = 0; | |
1566 | uint32_t host_status = DID_OK; | |
1567 | uint32_t rsp_len = 0, sns_len = 0; | |
1568 | struct csio_rnode *rn = (struct csio_rnode *)(cmnd->device->hostdata); | |
1569 | ||
1570 | ||
1571 | switch (req->wr_status) { | |
1572 | case FW_HOSTERROR: | |
1573 | if (unlikely(!csio_is_hw_ready(hw))) | |
1574 | return; | |
1575 | ||
1576 | host_status = DID_ERROR; | |
1577 | CSIO_INC_STATS(scm, n_hosterror); | |
1578 | ||
1579 | break; | |
1580 | case FW_SCSI_RSP_ERR: | |
1581 | dma_buf = &req->dma_buf; | |
1582 | fcp_resp = (struct fcp_resp_with_ext *)dma_buf->vaddr; | |
1583 | rsp_info = (struct fcp_resp_rsp_info *)(fcp_resp + 1); | |
1584 | flags = fcp_resp->resp.fr_flags; | |
1585 | scsi_status = fcp_resp->resp.fr_status; | |
1586 | ||
1587 | if (flags & FCP_RSP_LEN_VAL) { | |
1588 | rsp_len = be32_to_cpu(fcp_resp->ext.fr_rsp_len); | |
1589 | if ((rsp_len != 0 && rsp_len != 4 && rsp_len != 8) || | |
1590 | (rsp_info->rsp_code != FCP_TMF_CMPL)) { | |
1591 | host_status = DID_ERROR; | |
1592 | goto out; | |
1593 | } | |
1594 | } | |
1595 | ||
1596 | if ((flags & FCP_SNS_LEN_VAL) && fcp_resp->ext.fr_sns_len) { | |
1597 | sns_len = be32_to_cpu(fcp_resp->ext.fr_sns_len); | |
1598 | if (sns_len > SCSI_SENSE_BUFFERSIZE) | |
1599 | sns_len = SCSI_SENSE_BUFFERSIZE; | |
1600 | ||
1601 | memcpy(cmnd->sense_buffer, | |
1602 | &rsp_info->_fr_resvd[0] + rsp_len, sns_len); | |
1603 | CSIO_INC_STATS(scm, n_autosense); | |
1604 | } | |
1605 | ||
1606 | scsi_set_resid(cmnd, 0); | |
1607 | ||
1608 | /* Under run */ | |
1609 | if (flags & FCP_RESID_UNDER) { | |
1610 | scsi_set_resid(cmnd, | |
1611 | be32_to_cpu(fcp_resp->ext.fr_resid)); | |
1612 | ||
1613 | if (!(flags & FCP_SNS_LEN_VAL) && | |
1614 | (scsi_status == SAM_STAT_GOOD) && | |
1615 | ((scsi_bufflen(cmnd) - scsi_get_resid(cmnd)) | |
1616 | < cmnd->underflow)) | |
1617 | host_status = DID_ERROR; | |
1618 | } else if (flags & FCP_RESID_OVER) | |
1619 | host_status = DID_ERROR; | |
1620 | ||
1621 | CSIO_INC_STATS(scm, n_rsperror); | |
1622 | break; | |
1623 | ||
1624 | case FW_SCSI_OVER_FLOW_ERR: | |
1625 | csio_warn(hw, | |
1626 | "Over-flow error,cmnd:0x%x expected len:0x%x" | |
1627 | " resid:0x%x\n", cmnd->cmnd[0], | |
1628 | scsi_bufflen(cmnd), scsi_get_resid(cmnd)); | |
1629 | host_status = DID_ERROR; | |
1630 | CSIO_INC_STATS(scm, n_ovflerror); | |
1631 | break; | |
1632 | ||
1633 | case FW_SCSI_UNDER_FLOW_ERR: | |
1634 | csio_warn(hw, | |
1635 | "Under-flow error,cmnd:0x%x expected" | |
9cb78c16 | 1636 | " len:0x%x resid:0x%x lun:0x%llx ssn:0x%x\n", |
a3667aae NKI |
1637 | cmnd->cmnd[0], scsi_bufflen(cmnd), |
1638 | scsi_get_resid(cmnd), cmnd->device->lun, | |
1639 | rn->flowid); | |
1640 | host_status = DID_ERROR; | |
1641 | CSIO_INC_STATS(scm, n_unflerror); | |
1642 | break; | |
1643 | ||
1644 | case FW_SCSI_ABORT_REQUESTED: | |
1645 | case FW_SCSI_ABORTED: | |
1646 | case FW_SCSI_CLOSE_REQUESTED: | |
1647 | csio_dbg(hw, "Req %p cmd:%p op:%x %s\n", req, cmnd, | |
1648 | cmnd->cmnd[0], | |
1649 | (req->wr_status == FW_SCSI_CLOSE_REQUESTED) ? | |
1650 | "closed" : "aborted"); | |
1651 | /* | |
1652 | * csio_eh_abort_handler checks this value to | |
1653 | * succeed or fail the abort request. | |
1654 | */ | |
1655 | host_status = DID_REQUEUE; | |
1656 | if (req->wr_status == FW_SCSI_CLOSE_REQUESTED) | |
1657 | CSIO_INC_STATS(scm, n_closed); | |
1658 | else | |
1659 | CSIO_INC_STATS(scm, n_aborted); | |
1660 | break; | |
1661 | ||
1662 | case FW_SCSI_ABORT_TIMEDOUT: | |
1663 | /* FW timed out the abort itself */ | |
1664 | csio_dbg(hw, "FW timed out abort req:%p cmnd:%p status:%x\n", | |
1665 | req, cmnd, req->wr_status); | |
1666 | host_status = DID_ERROR; | |
1667 | CSIO_INC_STATS(scm, n_abrt_timedout); | |
1668 | break; | |
1669 | ||
1670 | case FW_RDEV_NOT_READY: | |
1671 | /* | |
1672 | * In firmware, a RDEV can get into this state | |
1673 | * temporarily, before moving into dissapeared/lost | |
1674 | * state. So, the driver should complete the request equivalent | |
1675 | * to device-disappeared! | |
1676 | */ | |
1677 | CSIO_INC_STATS(scm, n_rdev_nr_error); | |
1678 | host_status = DID_ERROR; | |
1679 | break; | |
1680 | ||
1681 | case FW_ERR_RDEV_LOST: | |
1682 | CSIO_INC_STATS(scm, n_rdev_lost_error); | |
1683 | host_status = DID_ERROR; | |
1684 | break; | |
1685 | ||
1686 | case FW_ERR_RDEV_LOGO: | |
1687 | CSIO_INC_STATS(scm, n_rdev_logo_error); | |
1688 | host_status = DID_ERROR; | |
1689 | break; | |
1690 | ||
1691 | case FW_ERR_RDEV_IMPL_LOGO: | |
1692 | host_status = DID_ERROR; | |
1693 | break; | |
1694 | ||
1695 | case FW_ERR_LINK_DOWN: | |
1696 | CSIO_INC_STATS(scm, n_link_down_error); | |
1697 | host_status = DID_ERROR; | |
1698 | break; | |
1699 | ||
1700 | case FW_FCOE_NO_XCHG: | |
1701 | CSIO_INC_STATS(scm, n_no_xchg_error); | |
1702 | host_status = DID_ERROR; | |
1703 | break; | |
1704 | ||
1705 | default: | |
1706 | csio_err(hw, "Unknown SCSI FW WR status:%d req:%p cmnd:%p\n", | |
1707 | req->wr_status, req, cmnd); | |
1708 | CSIO_DB_ASSERT(0); | |
1709 | ||
1710 | CSIO_INC_STATS(scm, n_unknown_error); | |
1711 | host_status = DID_ERROR; | |
1712 | break; | |
1713 | } | |
1714 | ||
1715 | out: | |
5c2442fd | 1716 | if (req->nsge > 0) { |
a3667aae | 1717 | scsi_dma_unmap(cmnd); |
5c2442fd VP |
1718 | if (req->dcopy && (host_status == DID_OK)) |
1719 | host_status = csio_scsi_copy_to_sgl(hw, req); | |
1720 | } | |
a3667aae NKI |
1721 | |
1722 | cmnd->result = (((host_status) << 16) | scsi_status); | |
1723 | cmnd->scsi_done(cmnd); | |
1724 | ||
1725 | /* Wake up waiting threads */ | |
1726 | csio_scsi_cmnd(req) = NULL; | |
3e3f5a8a | 1727 | complete(&req->cmplobj); |
a3667aae NKI |
1728 | } |
1729 | ||
1730 | /* | |
1731 | * csio_scsi_cbfn - SCSI callback function. | |
1732 | * @hw: HW module. | |
1733 | * @req: IO request. | |
1734 | * | |
1735 | */ | |
1736 | static void | |
1737 | csio_scsi_cbfn(struct csio_hw *hw, struct csio_ioreq *req) | |
1738 | { | |
1739 | struct scsi_cmnd *cmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req); | |
1740 | uint8_t scsi_status = SAM_STAT_GOOD; | |
1741 | uint32_t host_status = DID_OK; | |
1742 | ||
1743 | if (likely(req->wr_status == FW_SUCCESS)) { | |
1744 | if (req->nsge > 0) { | |
1745 | scsi_dma_unmap(cmnd); | |
1746 | if (req->dcopy) | |
1747 | host_status = csio_scsi_copy_to_sgl(hw, req); | |
1748 | } | |
1749 | ||
1750 | cmnd->result = (((host_status) << 16) | scsi_status); | |
1751 | cmnd->scsi_done(cmnd); | |
1752 | csio_scsi_cmnd(req) = NULL; | |
1753 | CSIO_INC_STATS(csio_hw_to_scsim(hw), n_tot_success); | |
1754 | } else { | |
1755 | /* Error handling */ | |
1756 | csio_scsi_err_handler(hw, req); | |
1757 | } | |
1758 | } | |
1759 | ||
1760 | /** | |
1761 | * csio_queuecommand - Entry point to kickstart an I/O request. | |
1762 | * @host: The scsi_host pointer. | |
1763 | * @cmnd: The I/O request from ML. | |
1764 | * | |
1765 | * This routine does the following: | |
1766 | * - Checks for HW and Rnode module readiness. | |
1767 | * - Gets a free ioreq structure (which is already initialized | |
1768 | * to uninit during its allocation). | |
1769 | * - Maps SG elements. | |
1770 | * - Initializes ioreq members. | |
1771 | * - Kicks off the SCSI state machine for this IO. | |
1772 | * - Returns busy status on error. | |
1773 | */ | |
1774 | static int | |
1775 | csio_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmnd) | |
1776 | { | |
1777 | struct csio_lnode *ln = shost_priv(host); | |
1778 | struct csio_hw *hw = csio_lnode_to_hw(ln); | |
1779 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
1780 | struct csio_rnode *rn = (struct csio_rnode *)(cmnd->device->hostdata); | |
1781 | struct csio_ioreq *ioreq = NULL; | |
1782 | unsigned long flags; | |
1783 | int nsge = 0; | |
1784 | int rv = SCSI_MLQUEUE_HOST_BUSY, nr; | |
1785 | int retval; | |
a3667aae NKI |
1786 | struct csio_scsi_qset *sqset; |
1787 | struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device)); | |
1788 | ||
9cf2bab6 | 1789 | sqset = &hw->sqset[ln->portid][blk_mq_rq_cpu(cmnd->request)]; |
a3667aae NKI |
1790 | |
1791 | nr = fc_remote_port_chkready(rport); | |
1792 | if (nr) { | |
1793 | cmnd->result = nr; | |
1794 | CSIO_INC_STATS(scsim, n_rn_nr_error); | |
1795 | goto err_done; | |
1796 | } | |
1797 | ||
1798 | if (unlikely(!csio_is_hw_ready(hw))) { | |
1799 | cmnd->result = (DID_REQUEUE << 16); | |
1800 | CSIO_INC_STATS(scsim, n_hw_nr_error); | |
1801 | goto err_done; | |
1802 | } | |
1803 | ||
1804 | /* Get req->nsge, if there are SG elements to be mapped */ | |
1805 | nsge = scsi_dma_map(cmnd); | |
1806 | if (unlikely(nsge < 0)) { | |
1807 | CSIO_INC_STATS(scsim, n_dmamap_error); | |
1808 | goto err; | |
1809 | } | |
1810 | ||
1811 | /* Do we support so many mappings? */ | |
1812 | if (unlikely(nsge > scsim->max_sge)) { | |
1813 | csio_warn(hw, | |
1814 | "More SGEs than can be supported." | |
1815 | " SGEs: %d, Max SGEs: %d\n", nsge, scsim->max_sge); | |
1816 | CSIO_INC_STATS(scsim, n_unsupp_sge_error); | |
1817 | goto err_dma_unmap; | |
1818 | } | |
1819 | ||
1820 | /* Get a free ioreq structure - SM is already set to uninit */ | |
1821 | ioreq = csio_get_scsi_ioreq_lock(hw, scsim); | |
1822 | if (!ioreq) { | |
1823 | csio_err(hw, "Out of I/O request elements. Active #:%d\n", | |
1824 | scsim->stats.n_active); | |
1825 | CSIO_INC_STATS(scsim, n_no_req_error); | |
1826 | goto err_dma_unmap; | |
1827 | } | |
1828 | ||
1829 | ioreq->nsge = nsge; | |
1830 | ioreq->lnode = ln; | |
1831 | ioreq->rnode = rn; | |
1832 | ioreq->iq_idx = sqset->iq_idx; | |
1833 | ioreq->eq_idx = sqset->eq_idx; | |
1834 | ioreq->wr_status = 0; | |
1835 | ioreq->drv_status = 0; | |
1836 | csio_scsi_cmnd(ioreq) = (void *)cmnd; | |
1837 | ioreq->tmo = 0; | |
1838 | ioreq->datadir = cmnd->sc_data_direction; | |
1839 | ||
1840 | if (cmnd->sc_data_direction == DMA_TO_DEVICE) { | |
1841 | CSIO_INC_STATS(ln, n_output_requests); | |
1842 | ln->stats.n_output_bytes += scsi_bufflen(cmnd); | |
1843 | } else if (cmnd->sc_data_direction == DMA_FROM_DEVICE) { | |
1844 | CSIO_INC_STATS(ln, n_input_requests); | |
1845 | ln->stats.n_input_bytes += scsi_bufflen(cmnd); | |
1846 | } else | |
1847 | CSIO_INC_STATS(ln, n_control_requests); | |
1848 | ||
1849 | /* Set cbfn */ | |
1850 | ioreq->io_cbfn = csio_scsi_cbfn; | |
1851 | ||
1852 | /* Needed during abort */ | |
1853 | cmnd->host_scribble = (unsigned char *)ioreq; | |
1854 | cmnd->SCp.Message = 0; | |
1855 | ||
1856 | /* Kick off SCSI IO SM on the ioreq */ | |
1857 | spin_lock_irqsave(&hw->lock, flags); | |
1858 | retval = csio_scsi_start_io(ioreq); | |
1859 | spin_unlock_irqrestore(&hw->lock, flags); | |
1860 | ||
1861 | if (retval != 0) { | |
1862 | csio_err(hw, "ioreq: %p couldnt be started, status:%d\n", | |
1863 | ioreq, retval); | |
1864 | CSIO_INC_STATS(scsim, n_busy_error); | |
1865 | goto err_put_req; | |
1866 | } | |
1867 | ||
1868 | return 0; | |
1869 | ||
1870 | err_put_req: | |
1871 | csio_put_scsi_ioreq_lock(hw, scsim, ioreq); | |
1872 | err_dma_unmap: | |
1873 | if (nsge > 0) | |
1874 | scsi_dma_unmap(cmnd); | |
1875 | err: | |
1876 | return rv; | |
1877 | ||
1878 | err_done: | |
1879 | cmnd->scsi_done(cmnd); | |
1880 | return 0; | |
1881 | } | |
1882 | ||
1883 | static int | |
1884 | csio_do_abrt_cls(struct csio_hw *hw, struct csio_ioreq *ioreq, bool abort) | |
1885 | { | |
1886 | int rv; | |
1887 | int cpu = smp_processor_id(); | |
1888 | struct csio_lnode *ln = ioreq->lnode; | |
1889 | struct csio_scsi_qset *sqset = &hw->sqset[ln->portid][cpu]; | |
1890 | ||
1891 | ioreq->tmo = CSIO_SCSI_ABRT_TMO_MS; | |
1892 | /* | |
1893 | * Use current processor queue for posting the abort/close, but retain | |
1894 | * the ingress queue ID of the original I/O being aborted/closed - we | |
1895 | * need the abort/close completion to be received on the same queue | |
1896 | * as the original I/O. | |
1897 | */ | |
1898 | ioreq->eq_idx = sqset->eq_idx; | |
1899 | ||
1900 | if (abort == SCSI_ABORT) | |
1901 | rv = csio_scsi_abort(ioreq); | |
1902 | else | |
1903 | rv = csio_scsi_close(ioreq); | |
1904 | ||
1905 | return rv; | |
1906 | } | |
1907 | ||
1908 | static int | |
1909 | csio_eh_abort_handler(struct scsi_cmnd *cmnd) | |
1910 | { | |
1911 | struct csio_ioreq *ioreq; | |
1912 | struct csio_lnode *ln = shost_priv(cmnd->device->host); | |
1913 | struct csio_hw *hw = csio_lnode_to_hw(ln); | |
1914 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
1915 | int ready = 0, ret; | |
1916 | unsigned long tmo = 0; | |
1917 | int rv; | |
1918 | struct csio_rnode *rn = (struct csio_rnode *)(cmnd->device->hostdata); | |
1919 | ||
1920 | ret = fc_block_scsi_eh(cmnd); | |
1921 | if (ret) | |
1922 | return ret; | |
1923 | ||
1924 | ioreq = (struct csio_ioreq *)cmnd->host_scribble; | |
1925 | if (!ioreq) | |
1926 | return SUCCESS; | |
1927 | ||
1928 | if (!rn) | |
1929 | return FAILED; | |
1930 | ||
1931 | csio_dbg(hw, | |
1932 | "Request to abort ioreq:%p cmd:%p cdb:%08llx" | |
9cb78c16 | 1933 | " ssni:0x%x lun:%llu iq:0x%x\n", |
a3667aae NKI |
1934 | ioreq, cmnd, *((uint64_t *)cmnd->cmnd), rn->flowid, |
1935 | cmnd->device->lun, csio_q_physiqid(hw, ioreq->iq_idx)); | |
1936 | ||
1937 | if (((struct scsi_cmnd *)csio_scsi_cmnd(ioreq)) != cmnd) { | |
1938 | CSIO_INC_STATS(scsim, n_abrt_race_comp); | |
1939 | return SUCCESS; | |
1940 | } | |
1941 | ||
1942 | ready = csio_is_lnode_ready(ln); | |
1943 | tmo = CSIO_SCSI_ABRT_TMO_MS; | |
1944 | ||
3e3f5a8a | 1945 | reinit_completion(&ioreq->cmplobj); |
a3667aae NKI |
1946 | spin_lock_irq(&hw->lock); |
1947 | rv = csio_do_abrt_cls(hw, ioreq, (ready ? SCSI_ABORT : SCSI_CLOSE)); | |
1948 | spin_unlock_irq(&hw->lock); | |
1949 | ||
1950 | if (rv != 0) { | |
1951 | if (rv == -EINVAL) { | |
1952 | /* Return success, if abort/close request issued on | |
1953 | * already completed IO | |
1954 | */ | |
1955 | return SUCCESS; | |
1956 | } | |
1957 | if (ready) | |
1958 | CSIO_INC_STATS(scsim, n_abrt_busy_error); | |
1959 | else | |
1960 | CSIO_INC_STATS(scsim, n_cls_busy_error); | |
1961 | ||
1962 | goto inval_scmnd; | |
1963 | } | |
1964 | ||
a3667aae NKI |
1965 | wait_for_completion_timeout(&ioreq->cmplobj, msecs_to_jiffies(tmo)); |
1966 | ||
1967 | /* FW didnt respond to abort within our timeout */ | |
1968 | if (((struct scsi_cmnd *)csio_scsi_cmnd(ioreq)) == cmnd) { | |
1969 | ||
1970 | csio_err(hw, "Abort timed out -- req: %p\n", ioreq); | |
1971 | CSIO_INC_STATS(scsim, n_abrt_timedout); | |
1972 | ||
1973 | inval_scmnd: | |
1974 | if (ioreq->nsge > 0) | |
1975 | scsi_dma_unmap(cmnd); | |
1976 | ||
1977 | spin_lock_irq(&hw->lock); | |
1978 | csio_scsi_cmnd(ioreq) = NULL; | |
1979 | spin_unlock_irq(&hw->lock); | |
1980 | ||
1981 | cmnd->result = (DID_ERROR << 16); | |
1982 | cmnd->scsi_done(cmnd); | |
1983 | ||
1984 | return FAILED; | |
1985 | } | |
1986 | ||
1987 | /* FW successfully aborted the request */ | |
1988 | if (host_byte(cmnd->result) == DID_REQUEUE) { | |
1989 | csio_info(hw, | |
f50e7605 | 1990 | "Aborted SCSI command to (%d:%llu) tag %u\n", |
a3667aae | 1991 | cmnd->device->id, cmnd->device->lun, |
f50e7605 | 1992 | cmnd->request->tag); |
a3667aae NKI |
1993 | return SUCCESS; |
1994 | } else { | |
1995 | csio_info(hw, | |
f50e7605 | 1996 | "Failed to abort SCSI command, (%d:%llu) tag %u\n", |
a3667aae | 1997 | cmnd->device->id, cmnd->device->lun, |
f50e7605 | 1998 | cmnd->request->tag); |
a3667aae NKI |
1999 | return FAILED; |
2000 | } | |
2001 | } | |
2002 | ||
2003 | /* | |
2004 | * csio_tm_cbfn - TM callback function. | |
2005 | * @hw: HW module. | |
2006 | * @req: IO request. | |
2007 | * | |
2008 | * Cache the result in 'cmnd', since ioreq will be freed soon | |
2009 | * after we return from here, and the waiting thread shouldnt trust | |
2010 | * the ioreq contents. | |
2011 | */ | |
2012 | static void | |
2013 | csio_tm_cbfn(struct csio_hw *hw, struct csio_ioreq *req) | |
2014 | { | |
2015 | struct scsi_cmnd *cmnd = (struct scsi_cmnd *)csio_scsi_cmnd(req); | |
2016 | struct csio_dma_buf *dma_buf; | |
2017 | uint8_t flags = 0; | |
2018 | struct fcp_resp_with_ext *fcp_resp; | |
2019 | struct fcp_resp_rsp_info *rsp_info; | |
2020 | ||
2021 | csio_dbg(hw, "req: %p in csio_tm_cbfn status: %d\n", | |
2022 | req, req->wr_status); | |
2023 | ||
2024 | /* Cache FW return status */ | |
2025 | cmnd->SCp.Status = req->wr_status; | |
2026 | ||
2027 | /* Special handling based on FCP response */ | |
2028 | ||
2029 | /* | |
2030 | * FW returns us this error, if flags were set. FCP4 says | |
2031 | * FCP_RSP_LEN_VAL in flags shall be set for TM completions. | |
2032 | * So if a target were to set this bit, we expect that the | |
2033 | * rsp_code is set to FCP_TMF_CMPL for a successful TM | |
2034 | * completion. Any other rsp_code means TM operation failed. | |
2035 | * If a target were to just ignore setting flags, we treat | |
2036 | * the TM operation as success, and FW returns FW_SUCCESS. | |
2037 | */ | |
2038 | if (req->wr_status == FW_SCSI_RSP_ERR) { | |
2039 | dma_buf = &req->dma_buf; | |
2040 | fcp_resp = (struct fcp_resp_with_ext *)dma_buf->vaddr; | |
2041 | rsp_info = (struct fcp_resp_rsp_info *)(fcp_resp + 1); | |
2042 | ||
2043 | flags = fcp_resp->resp.fr_flags; | |
2044 | ||
2045 | /* Modify return status if flags indicate success */ | |
2046 | if (flags & FCP_RSP_LEN_VAL) | |
2047 | if (rsp_info->rsp_code == FCP_TMF_CMPL) | |
2048 | cmnd->SCp.Status = FW_SUCCESS; | |
2049 | ||
2050 | csio_dbg(hw, "TM FCP rsp code: %d\n", rsp_info->rsp_code); | |
2051 | } | |
2052 | ||
2053 | /* Wake up the TM handler thread */ | |
2054 | csio_scsi_cmnd(req) = NULL; | |
2055 | } | |
2056 | ||
2057 | static int | |
2058 | csio_eh_lun_reset_handler(struct scsi_cmnd *cmnd) | |
2059 | { | |
2060 | struct csio_lnode *ln = shost_priv(cmnd->device->host); | |
2061 | struct csio_hw *hw = csio_lnode_to_hw(ln); | |
2062 | struct csio_scsim *scsim = csio_hw_to_scsim(hw); | |
2063 | struct csio_rnode *rn = (struct csio_rnode *)(cmnd->device->hostdata); | |
2064 | struct csio_ioreq *ioreq = NULL; | |
2065 | struct csio_scsi_qset *sqset; | |
2066 | unsigned long flags; | |
2067 | int retval; | |
2068 | int count, ret; | |
2069 | LIST_HEAD(local_q); | |
2070 | struct csio_scsi_level_data sld; | |
2071 | ||
2072 | if (!rn) | |
2073 | goto fail; | |
2074 | ||
9cb78c16 | 2075 | csio_dbg(hw, "Request to reset LUN:%llu (ssni:0x%x tgtid:%d)\n", |
a3667aae NKI |
2076 | cmnd->device->lun, rn->flowid, rn->scsi_id); |
2077 | ||
2078 | if (!csio_is_lnode_ready(ln)) { | |
2079 | csio_err(hw, | |
2080 | "LUN reset cannot be issued on non-ready" | |
9cb78c16 | 2081 | " local node vnpi:0x%x (LUN:%llu)\n", |
a3667aae NKI |
2082 | ln->vnp_flowid, cmnd->device->lun); |
2083 | goto fail; | |
2084 | } | |
2085 | ||
2086 | /* Lnode is ready, now wait on rport node readiness */ | |
2087 | ret = fc_block_scsi_eh(cmnd); | |
2088 | if (ret) | |
2089 | return ret; | |
2090 | ||
2091 | /* | |
2092 | * If we have blocked in the previous call, at this point, either the | |
2093 | * remote node has come back online, or device loss timer has fired | |
2094 | * and the remote node is destroyed. Allow the LUN reset only for | |
2095 | * the former case, since LUN reset is a TMF I/O on the wire, and we | |
2096 | * need a valid session to issue it. | |
2097 | */ | |
2098 | if (fc_remote_port_chkready(rn->rport)) { | |
2099 | csio_err(hw, | |
2100 | "LUN reset cannot be issued on non-ready" | |
9cb78c16 | 2101 | " remote node ssni:0x%x (LUN:%llu)\n", |
a3667aae NKI |
2102 | rn->flowid, cmnd->device->lun); |
2103 | goto fail; | |
2104 | } | |
2105 | ||
2106 | /* Get a free ioreq structure - SM is already set to uninit */ | |
2107 | ioreq = csio_get_scsi_ioreq_lock(hw, scsim); | |
2108 | ||
2109 | if (!ioreq) { | |
2110 | csio_err(hw, "Out of IO request elements. Active # :%d\n", | |
2111 | scsim->stats.n_active); | |
2112 | goto fail; | |
2113 | } | |
2114 | ||
2115 | sqset = &hw->sqset[ln->portid][smp_processor_id()]; | |
2116 | ioreq->nsge = 0; | |
2117 | ioreq->lnode = ln; | |
2118 | ioreq->rnode = rn; | |
2119 | ioreq->iq_idx = sqset->iq_idx; | |
2120 | ioreq->eq_idx = sqset->eq_idx; | |
2121 | ||
2122 | csio_scsi_cmnd(ioreq) = cmnd; | |
2123 | cmnd->host_scribble = (unsigned char *)ioreq; | |
2124 | cmnd->SCp.Status = 0; | |
2125 | ||
2126 | cmnd->SCp.Message = FCP_TMF_LUN_RESET; | |
2127 | ioreq->tmo = CSIO_SCSI_LUNRST_TMO_MS / 1000; | |
2128 | ||
2129 | /* | |
2130 | * FW times the LUN reset for ioreq->tmo, so we got to wait a little | |
2131 | * longer (10s for now) than that to allow FW to return the timed | |
2132 | * out command. | |
2133 | */ | |
2134 | count = DIV_ROUND_UP((ioreq->tmo + 10) * 1000, CSIO_SCSI_TM_POLL_MS); | |
2135 | ||
2136 | /* Set cbfn */ | |
2137 | ioreq->io_cbfn = csio_tm_cbfn; | |
2138 | ||
2139 | /* Save of the ioreq info for later use */ | |
2140 | sld.level = CSIO_LEV_LUN; | |
2141 | sld.lnode = ioreq->lnode; | |
2142 | sld.rnode = ioreq->rnode; | |
9cb78c16 | 2143 | sld.oslun = cmnd->device->lun; |
a3667aae NKI |
2144 | |
2145 | spin_lock_irqsave(&hw->lock, flags); | |
2146 | /* Kick off TM SM on the ioreq */ | |
2147 | retval = csio_scsi_start_tm(ioreq); | |
2148 | spin_unlock_irqrestore(&hw->lock, flags); | |
2149 | ||
2150 | if (retval != 0) { | |
2151 | csio_err(hw, "Failed to issue LUN reset, req:%p, status:%d\n", | |
2152 | ioreq, retval); | |
2153 | goto fail_ret_ioreq; | |
2154 | } | |
2155 | ||
2156 | csio_dbg(hw, "Waiting max %d secs for LUN reset completion\n", | |
2157 | count * (CSIO_SCSI_TM_POLL_MS / 1000)); | |
2158 | /* Wait for completion */ | |
2159 | while ((((struct scsi_cmnd *)csio_scsi_cmnd(ioreq)) == cmnd) | |
2160 | && count--) | |
2161 | msleep(CSIO_SCSI_TM_POLL_MS); | |
2162 | ||
2163 | /* LUN reset timed-out */ | |
2164 | if (((struct scsi_cmnd *)csio_scsi_cmnd(ioreq)) == cmnd) { | |
9cb78c16 | 2165 | csio_err(hw, "LUN reset (%d:%llu) timed out\n", |
a3667aae NKI |
2166 | cmnd->device->id, cmnd->device->lun); |
2167 | ||
2168 | spin_lock_irq(&hw->lock); | |
2169 | csio_scsi_drvcleanup(ioreq); | |
2170 | list_del_init(&ioreq->sm.sm_list); | |
2171 | spin_unlock_irq(&hw->lock); | |
2172 | ||
2173 | goto fail_ret_ioreq; | |
2174 | } | |
2175 | ||
2176 | /* LUN reset returned, check cached status */ | |
2177 | if (cmnd->SCp.Status != FW_SUCCESS) { | |
9cb78c16 | 2178 | csio_err(hw, "LUN reset failed (%d:%llu), status: %d\n", |
a3667aae NKI |
2179 | cmnd->device->id, cmnd->device->lun, cmnd->SCp.Status); |
2180 | goto fail; | |
2181 | } | |
2182 | ||
2183 | /* LUN reset succeeded, Start aborting affected I/Os */ | |
2184 | /* | |
2185 | * Since the host guarantees during LUN reset that there | |
2186 | * will not be any more I/Os to that LUN, until the LUN reset | |
2187 | * completes, we gather pending I/Os after the LUN reset. | |
2188 | */ | |
2189 | spin_lock_irq(&hw->lock); | |
2190 | csio_scsi_gather_active_ios(scsim, &sld, &local_q); | |
2191 | ||
2192 | retval = csio_scsi_abort_io_q(scsim, &local_q, 30000); | |
2193 | spin_unlock_irq(&hw->lock); | |
2194 | ||
2195 | /* Aborts may have timed out */ | |
2196 | if (retval != 0) { | |
2197 | csio_err(hw, | |
9cb78c16 | 2198 | "Attempt to abort I/Os during LUN reset of %llu" |
a3667aae NKI |
2199 | " returned %d\n", cmnd->device->lun, retval); |
2200 | /* Return I/Os back to active_q */ | |
2201 | spin_lock_irq(&hw->lock); | |
2202 | list_splice_tail_init(&local_q, &scsim->active_q); | |
2203 | spin_unlock_irq(&hw->lock); | |
2204 | goto fail; | |
2205 | } | |
2206 | ||
2207 | CSIO_INC_STATS(rn, n_lun_rst); | |
2208 | ||
9cb78c16 | 2209 | csio_info(hw, "LUN reset occurred (%d:%llu)\n", |
a3667aae NKI |
2210 | cmnd->device->id, cmnd->device->lun); |
2211 | ||
2212 | return SUCCESS; | |
2213 | ||
2214 | fail_ret_ioreq: | |
2215 | csio_put_scsi_ioreq_lock(hw, scsim, ioreq); | |
2216 | fail: | |
2217 | CSIO_INC_STATS(rn, n_lun_rst_fail); | |
2218 | return FAILED; | |
2219 | } | |
2220 | ||
2221 | static int | |
2222 | csio_slave_alloc(struct scsi_device *sdev) | |
2223 | { | |
2224 | struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); | |
2225 | ||
2226 | if (!rport || fc_remote_port_chkready(rport)) | |
2227 | return -ENXIO; | |
2228 | ||
2229 | sdev->hostdata = *((struct csio_lnode **)(rport->dd_data)); | |
2230 | ||
2231 | return 0; | |
2232 | } | |
2233 | ||
2234 | static int | |
2235 | csio_slave_configure(struct scsi_device *sdev) | |
2236 | { | |
db5ed4df | 2237 | scsi_change_queue_depth(sdev, csio_lun_qdepth); |
a3667aae NKI |
2238 | return 0; |
2239 | } | |
2240 | ||
2241 | static void | |
2242 | csio_slave_destroy(struct scsi_device *sdev) | |
2243 | { | |
2244 | sdev->hostdata = NULL; | |
2245 | } | |
2246 | ||
2247 | static int | |
2248 | csio_scan_finished(struct Scsi_Host *shost, unsigned long time) | |
2249 | { | |
2250 | struct csio_lnode *ln = shost_priv(shost); | |
2251 | int rv = 1; | |
2252 | ||
2253 | spin_lock_irq(shost->host_lock); | |
2254 | if (!ln->hwp || csio_list_deleted(&ln->sm.sm_list)) | |
2255 | goto out; | |
2256 | ||
2257 | rv = csio_scan_done(ln, jiffies, time, csio_max_scan_tmo * HZ, | |
2258 | csio_delta_scan_tmo * HZ); | |
2259 | out: | |
2260 | spin_unlock_irq(shost->host_lock); | |
2261 | ||
2262 | return rv; | |
2263 | } | |
2264 | ||
2265 | struct scsi_host_template csio_fcoe_shost_template = { | |
2266 | .module = THIS_MODULE, | |
2267 | .name = CSIO_DRV_DESC, | |
2268 | .proc_name = KBUILD_MODNAME, | |
2269 | .queuecommand = csio_queuecommand, | |
b6a05c82 | 2270 | .eh_timed_out = fc_eh_timed_out, |
a3667aae NKI |
2271 | .eh_abort_handler = csio_eh_abort_handler, |
2272 | .eh_device_reset_handler = csio_eh_lun_reset_handler, | |
2273 | .slave_alloc = csio_slave_alloc, | |
2274 | .slave_configure = csio_slave_configure, | |
2275 | .slave_destroy = csio_slave_destroy, | |
2276 | .scan_finished = csio_scan_finished, | |
2277 | .this_id = -1, | |
2278 | .sg_tablesize = CSIO_SCSI_MAX_SGE, | |
2279 | .cmd_per_lun = CSIO_MAX_CMD_PER_LUN, | |
a3667aae NKI |
2280 | .shost_attrs = csio_fcoe_lport_attrs, |
2281 | .max_sectors = CSIO_MAX_SECTOR_SIZE, | |
2282 | }; | |
2283 | ||
2284 | struct scsi_host_template csio_fcoe_shost_vport_template = { | |
2285 | .module = THIS_MODULE, | |
2286 | .name = CSIO_DRV_DESC, | |
2287 | .proc_name = KBUILD_MODNAME, | |
2288 | .queuecommand = csio_queuecommand, | |
b6a05c82 | 2289 | .eh_timed_out = fc_eh_timed_out, |
a3667aae NKI |
2290 | .eh_abort_handler = csio_eh_abort_handler, |
2291 | .eh_device_reset_handler = csio_eh_lun_reset_handler, | |
2292 | .slave_alloc = csio_slave_alloc, | |
2293 | .slave_configure = csio_slave_configure, | |
2294 | .slave_destroy = csio_slave_destroy, | |
2295 | .scan_finished = csio_scan_finished, | |
2296 | .this_id = -1, | |
2297 | .sg_tablesize = CSIO_SCSI_MAX_SGE, | |
2298 | .cmd_per_lun = CSIO_MAX_CMD_PER_LUN, | |
a3667aae NKI |
2299 | .shost_attrs = csio_fcoe_vport_attrs, |
2300 | .max_sectors = CSIO_MAX_SECTOR_SIZE, | |
2301 | }; | |
2302 | ||
2303 | /* | |
2304 | * csio_scsi_alloc_ddp_bufs - Allocate buffers for DDP of unaligned SGLs. | |
2305 | * @scm: SCSI Module | |
2306 | * @hw: HW device. | |
2307 | * @buf_size: buffer size | |
2308 | * @num_buf : Number of buffers. | |
2309 | * | |
2310 | * This routine allocates DMA buffers required for SCSI Data xfer, if | |
2311 | * each SGL buffer for a SCSI Read request posted by SCSI midlayer are | |
2312 | * not virtually contiguous. | |
2313 | */ | |
2314 | static int | |
2315 | csio_scsi_alloc_ddp_bufs(struct csio_scsim *scm, struct csio_hw *hw, | |
2316 | int buf_size, int num_buf) | |
2317 | { | |
2318 | int n = 0; | |
2319 | struct list_head *tmp; | |
2320 | struct csio_dma_buf *ddp_desc = NULL; | |
2321 | uint32_t unit_size = 0; | |
2322 | ||
2323 | if (!num_buf) | |
2324 | return 0; | |
2325 | ||
2326 | if (!buf_size) | |
2327 | return -EINVAL; | |
2328 | ||
2329 | INIT_LIST_HEAD(&scm->ddp_freelist); | |
2330 | ||
2331 | /* Align buf size to page size */ | |
2332 | buf_size = (buf_size + PAGE_SIZE - 1) & PAGE_MASK; | |
2333 | /* Initialize dma descriptors */ | |
2334 | for (n = 0; n < num_buf; n++) { | |
2335 | /* Set unit size to request size */ | |
2336 | unit_size = buf_size; | |
2337 | ddp_desc = kzalloc(sizeof(struct csio_dma_buf), GFP_KERNEL); | |
2338 | if (!ddp_desc) { | |
2339 | csio_err(hw, | |
2340 | "Failed to allocate ddp descriptors," | |
2341 | " Num allocated = %d.\n", | |
2342 | scm->stats.n_free_ddp); | |
2343 | goto no_mem; | |
2344 | } | |
2345 | ||
2346 | /* Allocate Dma buffers for DDP */ | |
c22b332d CH |
2347 | ddp_desc->vaddr = dma_alloc_coherent(&hw->pdev->dev, unit_size, |
2348 | &ddp_desc->paddr, GFP_KERNEL); | |
a3667aae NKI |
2349 | if (!ddp_desc->vaddr) { |
2350 | csio_err(hw, | |
2351 | "SCSI response DMA buffer (ddp) allocation" | |
2352 | " failed!\n"); | |
2353 | kfree(ddp_desc); | |
2354 | goto no_mem; | |
2355 | } | |
2356 | ||
2357 | ddp_desc->len = unit_size; | |
2358 | ||
2359 | /* Added it to scsi ddp freelist */ | |
2360 | list_add_tail(&ddp_desc->list, &scm->ddp_freelist); | |
2361 | CSIO_INC_STATS(scm, n_free_ddp); | |
2362 | } | |
2363 | ||
2364 | return 0; | |
2365 | no_mem: | |
2366 | /* release dma descs back to freelist and free dma memory */ | |
2367 | list_for_each(tmp, &scm->ddp_freelist) { | |
2368 | ddp_desc = (struct csio_dma_buf *) tmp; | |
2369 | tmp = csio_list_prev(tmp); | |
c22b332d CH |
2370 | dma_free_coherent(&hw->pdev->dev, ddp_desc->len, |
2371 | ddp_desc->vaddr, ddp_desc->paddr); | |
a3667aae NKI |
2372 | list_del_init(&ddp_desc->list); |
2373 | kfree(ddp_desc); | |
2374 | } | |
2375 | scm->stats.n_free_ddp = 0; | |
2376 | ||
2377 | return -ENOMEM; | |
2378 | } | |
2379 | ||
2380 | /* | |
2381 | * csio_scsi_free_ddp_bufs - free DDP buffers of unaligned SGLs. | |
2382 | * @scm: SCSI Module | |
2383 | * @hw: HW device. | |
2384 | * | |
2385 | * This routine frees ddp buffers. | |
2386 | */ | |
2387 | static void | |
2388 | csio_scsi_free_ddp_bufs(struct csio_scsim *scm, struct csio_hw *hw) | |
2389 | { | |
2390 | struct list_head *tmp; | |
2391 | struct csio_dma_buf *ddp_desc; | |
2392 | ||
2393 | /* release dma descs back to freelist and free dma memory */ | |
2394 | list_for_each(tmp, &scm->ddp_freelist) { | |
2395 | ddp_desc = (struct csio_dma_buf *) tmp; | |
2396 | tmp = csio_list_prev(tmp); | |
c22b332d CH |
2397 | dma_free_coherent(&hw->pdev->dev, ddp_desc->len, |
2398 | ddp_desc->vaddr, ddp_desc->paddr); | |
a3667aae NKI |
2399 | list_del_init(&ddp_desc->list); |
2400 | kfree(ddp_desc); | |
2401 | } | |
2402 | scm->stats.n_free_ddp = 0; | |
2403 | } | |
2404 | ||
2405 | /** | |
2406 | * csio_scsim_init - Initialize SCSI Module | |
2407 | * @scm: SCSI Module | |
2408 | * @hw: HW module | |
2409 | * | |
2410 | */ | |
2411 | int | |
2412 | csio_scsim_init(struct csio_scsim *scm, struct csio_hw *hw) | |
2413 | { | |
2414 | int i; | |
2415 | struct csio_ioreq *ioreq; | |
2416 | struct csio_dma_buf *dma_buf; | |
2417 | ||
2418 | INIT_LIST_HEAD(&scm->active_q); | |
2419 | scm->hw = hw; | |
2420 | ||
2421 | scm->proto_cmd_len = sizeof(struct fcp_cmnd); | |
2422 | scm->proto_rsp_len = CSIO_SCSI_RSP_LEN; | |
2423 | scm->max_sge = CSIO_SCSI_MAX_SGE; | |
2424 | ||
2425 | spin_lock_init(&scm->freelist_lock); | |
2426 | ||
2427 | /* Pre-allocate ioreqs and initialize them */ | |
2428 | INIT_LIST_HEAD(&scm->ioreq_freelist); | |
2429 | for (i = 0; i < csio_scsi_ioreqs; i++) { | |
2430 | ||
2431 | ioreq = kzalloc(sizeof(struct csio_ioreq), GFP_KERNEL); | |
2432 | if (!ioreq) { | |
2433 | csio_err(hw, | |
2434 | "I/O request element allocation failed, " | |
2435 | " Num allocated = %d.\n", | |
2436 | scm->stats.n_free_ioreq); | |
2437 | ||
2438 | goto free_ioreq; | |
2439 | } | |
2440 | ||
2441 | /* Allocate Dma buffers for Response Payload */ | |
2442 | dma_buf = &ioreq->dma_buf; | |
decab9a6 | 2443 | dma_buf->vaddr = dma_pool_alloc(hw->scsi_dma_pool, GFP_KERNEL, |
a3667aae NKI |
2444 | &dma_buf->paddr); |
2445 | if (!dma_buf->vaddr) { | |
2446 | csio_err(hw, | |
2447 | "SCSI response DMA buffer allocation" | |
2448 | " failed!\n"); | |
2449 | kfree(ioreq); | |
2450 | goto free_ioreq; | |
2451 | } | |
2452 | ||
2453 | dma_buf->len = scm->proto_rsp_len; | |
2454 | ||
2455 | /* Set state to uninit */ | |
2456 | csio_init_state(&ioreq->sm, csio_scsis_uninit); | |
2457 | INIT_LIST_HEAD(&ioreq->gen_list); | |
2458 | init_completion(&ioreq->cmplobj); | |
2459 | ||
2460 | list_add_tail(&ioreq->sm.sm_list, &scm->ioreq_freelist); | |
2461 | CSIO_INC_STATS(scm, n_free_ioreq); | |
2462 | } | |
2463 | ||
2464 | if (csio_scsi_alloc_ddp_bufs(scm, hw, PAGE_SIZE, csio_ddp_descs)) | |
2465 | goto free_ioreq; | |
2466 | ||
2467 | return 0; | |
2468 | ||
2469 | free_ioreq: | |
2470 | /* | |
2471 | * Free up existing allocations, since an error | |
2472 | * from here means we are returning for good | |
2473 | */ | |
2474 | while (!list_empty(&scm->ioreq_freelist)) { | |
2475 | struct csio_sm *tmp; | |
2476 | ||
2477 | tmp = list_first_entry(&scm->ioreq_freelist, | |
2478 | struct csio_sm, sm_list); | |
2479 | list_del_init(&tmp->sm_list); | |
2480 | ioreq = (struct csio_ioreq *)tmp; | |
2481 | ||
2482 | dma_buf = &ioreq->dma_buf; | |
decab9a6 | 2483 | dma_pool_free(hw->scsi_dma_pool, dma_buf->vaddr, |
a3667aae NKI |
2484 | dma_buf->paddr); |
2485 | ||
2486 | kfree(ioreq); | |
2487 | } | |
2488 | ||
2489 | scm->stats.n_free_ioreq = 0; | |
2490 | ||
2491 | return -ENOMEM; | |
2492 | } | |
2493 | ||
2494 | /** | |
2495 | * csio_scsim_exit: Uninitialize SCSI Module | |
2496 | * @scm: SCSI Module | |
2497 | * | |
2498 | */ | |
2499 | void | |
2500 | csio_scsim_exit(struct csio_scsim *scm) | |
2501 | { | |
2502 | struct csio_ioreq *ioreq; | |
2503 | struct csio_dma_buf *dma_buf; | |
2504 | ||
2505 | while (!list_empty(&scm->ioreq_freelist)) { | |
2506 | struct csio_sm *tmp; | |
2507 | ||
2508 | tmp = list_first_entry(&scm->ioreq_freelist, | |
2509 | struct csio_sm, sm_list); | |
2510 | list_del_init(&tmp->sm_list); | |
2511 | ioreq = (struct csio_ioreq *)tmp; | |
2512 | ||
2513 | dma_buf = &ioreq->dma_buf; | |
decab9a6 | 2514 | dma_pool_free(scm->hw->scsi_dma_pool, dma_buf->vaddr, |
a3667aae NKI |
2515 | dma_buf->paddr); |
2516 | ||
2517 | kfree(ioreq); | |
2518 | } | |
2519 | ||
2520 | scm->stats.n_free_ioreq = 0; | |
2521 | ||
2522 | csio_scsi_free_ddp_bufs(scm, scm->hw); | |
2523 | } |