aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/lpfc/lpfc_scsi.c
diff options
context:
space:
mode:
author <jejb@titanic.il.steeleye.com>2005-04-17 17:05:31 -0400
committerJames Bottomley <jejb@titanic>2005-04-18 14:50:53 -0400
commitdea3101e0a5c897d2c9351a7444e139db9f40247 (patch)
tree61de19e98eed08bb760703b362eab2038c34f261 /drivers/scsi/lpfc/lpfc_scsi.c
parent8e8790415e91964096f862a58cacb55d2bc9a817 (diff)
lpfc: add Emulex FC driver version 8.0.28
From: James.Smart@Emulex.Com Modified for kernel import and Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
Diffstat (limited to 'drivers/scsi/lpfc/lpfc_scsi.c')
-rw-r--r--drivers/scsi/lpfc/lpfc_scsi.c1246
1 files changed, 1246 insertions, 0 deletions
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
new file mode 100644
index 000000000000..42fab03ad2ba
--- /dev/null
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -0,0 +1,1246 @@
1/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Enterprise Fibre Channel Host Bus Adapters. *
4 * Refer to the README file included with this package for *
5 * driver version and adapter support. *
6 * Copyright (C) 2004 Emulex Corporation. *
7 * www.emulex.com *
8 * *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of the GNU General Public License *
11 * as published by the Free Software Foundation; either version 2 *
12 * of the License, or (at your option) any later version. *
13 * *
14 * This program is distributed in the hope that it will be useful, *
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17 * GNU General Public License for more details, a copy of which *
18 * can be found in the file COPYING included with this package. *
19 *******************************************************************/
20
21/*
22 * $Id: lpfc_scsi.c 1.37 2005/04/13 14:27:09EDT sf_support Exp $
23 */
24
25#include <linux/pci.h>
26#include <linux/interrupt.h>
27
28#include <scsi/scsi.h>
29#include <scsi/scsi_device.h>
30#include <scsi/scsi_host.h>
31#include <scsi/scsi_tcq.h>
32#include <scsi/scsi_transport_fc.h>
33
34#include "lpfc_version.h"
35#include "lpfc_hw.h"
36#include "lpfc_sli.h"
37#include "lpfc_disc.h"
38#include "lpfc_scsi.h"
39#include "lpfc.h"
40#include "lpfc_logmsg.h"
41#include "lpfc_crtn.h"
42
43#define LPFC_RESET_WAIT 2
44#define LPFC_ABORT_WAIT 2
45
46static inline void lpfc_put_lun(struct fcp_cmnd *fcmd, unsigned int lun)
47{
48 fcmd->fcpLunLsl = 0;
49 fcmd->fcpLunMsl = swab16((uint16_t)lun);
50}
51
52/*
53 * This routine allocates a scsi buffer, which contains all the necessary
54 * information needed to initiate a SCSI I/O. The non-DMAable buffer region
55 * contains information to build the IOCB. The DMAable region contains
56 * memory for the FCP CMND, FCP RSP, and the inital BPL. In addition to
57 * allocating memeory, the FCP CMND and FCP RSP BDEs are setup in the BPL
58 * and the BPL BDE is setup in the IOCB.
59 */
60static struct lpfc_scsi_buf *
61lpfc_get_scsi_buf(struct lpfc_hba * phba)
62{
63 struct lpfc_scsi_buf *psb;
64 struct ulp_bde64 *bpl;
65 IOCB_t *iocb;
66 dma_addr_t pdma_phys;
67
68 psb = kmalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
69 if (!psb)
70 return NULL;
71 memset(psb, 0, sizeof (struct lpfc_scsi_buf));
72 psb->scsi_hba = phba;
73
74 /*
75 * Get memory from the pci pool to map the virt space to pci bus space
76 * for an I/O. The DMA buffer includes space for the struct fcp_cmnd,
77 * struct fcp_rsp and the number of bde's necessary to support the
78 * sg_tablesize.
79 */
80 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool, GFP_KERNEL,
81 &psb->dma_handle);
82 if (!psb->data) {
83 kfree(psb);
84 return NULL;
85 }
86
87 /* Initialize virtual ptrs to dma_buf region. */
88 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
89
90 psb->fcp_cmnd = psb->data;
91 psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd);
92 psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) +
93 sizeof(struct fcp_rsp);
94
95 /* Initialize local short-hand pointers. */
96 bpl = psb->fcp_bpl;
97 pdma_phys = psb->dma_handle;
98
99 /*
100 * The first two bdes are the FCP_CMD and FCP_RSP. The balance are sg
101 * list bdes. Initialize the first two and leave the rest for
102 * queuecommand.
103 */
104 bpl->addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys));
105 bpl->addrLow = le32_to_cpu(putPaddrLow(pdma_phys));
106 bpl->tus.f.bdeSize = sizeof (struct fcp_cmnd);
107 bpl->tus.f.bdeFlags = BUFF_USE_CMND;
108 bpl->tus.w = le32_to_cpu(bpl->tus.w);
109 bpl++;
110
111 /* Setup the physical region for the FCP RSP */
112 pdma_phys += sizeof (struct fcp_cmnd);
113 bpl->addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys));
114 bpl->addrLow = le32_to_cpu(putPaddrLow(pdma_phys));
115 bpl->tus.f.bdeSize = sizeof (struct fcp_rsp);
116 bpl->tus.f.bdeFlags = (BUFF_USE_CMND | BUFF_USE_RCV);
117 bpl->tus.w = le32_to_cpu(bpl->tus.w);
118
119 /*
120 * Since the IOCB for the FCP I/O is built into this lpfc_scsi_buf,
121 * initialize it with all known data now.
122 */
123 pdma_phys += (sizeof (struct fcp_rsp));
124 iocb = &psb->cur_iocbq.iocb;
125 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
126 iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys);
127 iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys);
128 iocb->un.fcpi64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
129 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDL;
130 iocb->ulpBdeCount = 1;
131 iocb->ulpClass = CLASS3;
132
133 return psb;
134}
135
136static void
137lpfc_free_scsi_buf(struct lpfc_scsi_buf * psb)
138{
139 struct lpfc_hba *phba = psb->scsi_hba;
140
141 /*
142 * There are only two special cases to consider. (1) the scsi command
143 * requested scatter-gather usage or (2) the scsi command allocated
144 * a request buffer, but did not request use_sg. There is a third
145 * case, but it does not require resource deallocation.
146 */
147 if ((psb->seg_cnt > 0) && (psb->pCmd->use_sg)) {
148 dma_unmap_sg(&phba->pcidev->dev, psb->pCmd->request_buffer,
149 psb->seg_cnt, psb->pCmd->sc_data_direction);
150 } else {
151 if ((psb->nonsg_phys) && (psb->pCmd->request_bufflen)) {
152 dma_unmap_single(&phba->pcidev->dev, psb->nonsg_phys,
153 psb->pCmd->request_bufflen,
154 psb->pCmd->sc_data_direction);
155 }
156 }
157
158 list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list);
159}
160
161static int
162lpfc_scsi_prep_dma_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * lpfc_cmd)
163{
164 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
165 struct scatterlist *sgel = NULL;
166 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
167 struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
168 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
169 dma_addr_t physaddr;
170 uint32_t i, num_bde = 0;
171 int datadir = scsi_cmnd->sc_data_direction;
172 int dma_error;
173
174 /*
175 * There are three possibilities here - use scatter-gather segment, use
176 * the single mapping, or neither. Start the lpfc command prep by
177 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
178 * data bde entry.
179 */
180 bpl += 2;
181 if (scsi_cmnd->use_sg) {
182 /*
183 * The driver stores the segment count returned from pci_map_sg
184 * because this a count of dma-mappings used to map the use_sg
185 * pages. They are not guaranteed to be the same for those
186 * architectures that implement an IOMMU.
187 */
188 sgel = (struct scatterlist *)scsi_cmnd->request_buffer;
189 lpfc_cmd->seg_cnt = dma_map_sg(&phba->pcidev->dev, sgel,
190 scsi_cmnd->use_sg, datadir);
191 if (lpfc_cmd->seg_cnt == 0)
192 return 1;
193
194 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
195 printk(KERN_ERR "%s: Too many sg segments from "
196 "dma_map_sg. Config %d, seg_cnt %d",
197 __FUNCTION__, phba->cfg_sg_seg_cnt,
198 lpfc_cmd->seg_cnt);
199 dma_unmap_sg(&phba->pcidev->dev, sgel,
200 lpfc_cmd->seg_cnt, datadir);
201 return 1;
202 }
203
204 /*
205 * The driver established a maximum scatter-gather segment count
206 * during probe that limits the number of sg elements in any
207 * single scsi command. Just run through the seg_cnt and format
208 * the bde's.
209 */
210 for (i = 0; i < lpfc_cmd->seg_cnt; i++) {
211 physaddr = sg_dma_address(sgel);
212 bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr));
213 bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
214 bpl->tus.f.bdeSize = sg_dma_len(sgel);
215 if (datadir == DMA_TO_DEVICE)
216 bpl->tus.f.bdeFlags = 0;
217 else
218 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
219 bpl->tus.w = le32_to_cpu(bpl->tus.w);
220 bpl++;
221 sgel++;
222 num_bde++;
223 }
224 } else if (scsi_cmnd->request_buffer && scsi_cmnd->request_bufflen) {
225 physaddr = dma_map_single(&phba->pcidev->dev,
226 scsi_cmnd->request_buffer,
227 scsi_cmnd->request_bufflen,
228 datadir);
229 dma_error = dma_mapping_error(physaddr);
230 if (dma_error) {
231 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
232 "%d:0718 Unable to dma_map_single "
233 "request_buffer: x%x\n",
234 phba->brd_no, dma_error);
235 return 1;
236 }
237
238 lpfc_cmd->nonsg_phys = physaddr;
239 bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr));
240 bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
241 bpl->tus.f.bdeSize = scsi_cmnd->request_bufflen;
242 if (datadir == DMA_TO_DEVICE)
243 bpl->tus.f.bdeFlags = 0;
244 bpl->tus.w = le32_to_cpu(bpl->tus.w);
245 num_bde = 1;
246 bpl++;
247 }
248
249 /*
250 * Finish initializing those IOCB fields that are dependent on the
251 * scsi_cmnd request_buffer
252 */
253 iocb_cmd->un.fcpi64.bdl.bdeSize +=
254 (num_bde * sizeof (struct ulp_bde64));
255 iocb_cmd->ulpBdeCount = 1;
256 iocb_cmd->ulpLe = 1;
257 fcp_cmnd->fcpDl = be32_to_cpu(scsi_cmnd->request_bufflen);
258 return 0;
259}
260
261static void
262lpfc_handle_fcp_err(struct lpfc_scsi_buf *lpfc_cmd)
263{
264 struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
265 struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
266 struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
267 struct lpfc_hba *phba = lpfc_cmd->scsi_hba;
268 uint32_t fcpi_parm = lpfc_cmd->cur_iocbq.iocb.un.fcpi.fcpi_parm;
269 uint32_t resp_info = fcprsp->rspStatus2;
270 uint32_t scsi_status = fcprsp->rspStatus3;
271 uint32_t host_status = DID_OK;
272 uint32_t rsplen = 0;
273
274 /*
275 * If this is a task management command, there is no
276 * scsi packet associated with this lpfc_cmd. The driver
277 * consumes it.
278 */
279 if (fcpcmd->fcpCntl2) {
280 scsi_status = 0;
281 goto out;
282 }
283
284 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
285 "%d:0730 FCP command failed: RSP "
286 "Data: x%x x%x x%x x%x x%x x%x\n",
287 phba->brd_no, resp_info, scsi_status,
288 be32_to_cpu(fcprsp->rspResId),
289 be32_to_cpu(fcprsp->rspSnsLen),
290 be32_to_cpu(fcprsp->rspRspLen),
291 fcprsp->rspInfo3);
292
293 if (resp_info & RSP_LEN_VALID) {
294 rsplen = be32_to_cpu(fcprsp->rspRspLen);
295 if ((rsplen != 0 && rsplen != 4 && rsplen != 8) ||
296 (fcprsp->rspInfo3 != RSP_NO_FAILURE)) {
297 host_status = DID_ERROR;
298 goto out;
299 }
300 }
301
302 if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) {
303 uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen);
304 if (snslen > SCSI_SENSE_BUFFERSIZE)
305 snslen = SCSI_SENSE_BUFFERSIZE;
306
307 memcpy(cmnd->sense_buffer, &fcprsp->rspInfo0 + rsplen, snslen);
308 }
309
310 cmnd->resid = 0;
311 if (resp_info & RESID_UNDER) {
312 cmnd->resid = be32_to_cpu(fcprsp->rspResId);
313
314 lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
315 "%d:0716 FCP Read Underrun, expected %d, "
316 "residual %d Data: x%x x%x x%x\n", phba->brd_no,
317 be32_to_cpu(fcpcmd->fcpDl), cmnd->resid,
318 fcpi_parm, cmnd->cmnd[0], cmnd->underflow);
319
320 /*
321 * The cmnd->underflow is the minimum number of bytes that must
322 * be transfered for this command. Provided a sense condition
323 * is not present, make sure the actual amount transferred is at
324 * least the underflow value or fail.
325 */
326 if (!(resp_info & SNS_LEN_VALID) &&
327 (scsi_status == SAM_STAT_GOOD) &&
328 (cmnd->request_bufflen - cmnd->resid) < cmnd->underflow) {
329 lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
330 "%d:0717 FCP command x%x residual "
331 "underrun converted to error "
332 "Data: x%x x%x x%x\n", phba->brd_no,
333 cmnd->cmnd[0], cmnd->request_bufflen,
334 cmnd->resid, cmnd->underflow);
335
336 host_status = DID_ERROR;
337 }
338 } else if (resp_info & RESID_OVER) {
339 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
340 "%d:0720 FCP command x%x residual "
341 "overrun error. Data: x%x x%x \n",
342 phba->brd_no, cmnd->cmnd[0],
343 cmnd->request_bufflen, cmnd->resid);
344 host_status = DID_ERROR;
345
346 /*
347 * Check SLI validation that all the transfer was actually done
348 * (fcpi_parm should be zero). Apply check only to reads.
349 */
350 } else if ((scsi_status == SAM_STAT_GOOD) && fcpi_parm &&
351 (cmnd->sc_data_direction == DMA_FROM_DEVICE)) {
352 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
353 "%d:0734 FCP Read Check Error Data: "
354 "x%x x%x x%x x%x\n", phba->brd_no,
355 be32_to_cpu(fcpcmd->fcpDl),
356 be32_to_cpu(fcprsp->rspResId),
357 fcpi_parm, cmnd->cmnd[0]);
358 host_status = DID_ERROR;
359 cmnd->resid = cmnd->request_bufflen;
360 }
361
362 out:
363 cmnd->result = ScsiResult(host_status, scsi_status);
364}
365
366static void
367lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
368 struct lpfc_iocbq *pIocbOut)
369{
370 struct lpfc_scsi_buf *lpfc_cmd =
371 (struct lpfc_scsi_buf *) pIocbIn->context1;
372 struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
373 struct lpfc_nodelist *pnode = rdata->pnode;
374 struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
375 unsigned long iflag;
376
377 lpfc_cmd->result = pIocbOut->iocb.un.ulpWord[4];
378 lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
379
380 if (lpfc_cmd->status) {
381 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
382 (lpfc_cmd->result & IOERR_DRVR_MASK))
383 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
384 else if (lpfc_cmd->status >= IOSTAT_CNT)
385 lpfc_cmd->status = IOSTAT_DEFAULT;
386
387 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
388 "%d:0729 FCP cmd x%x failed <%d/%d> status: "
389 "x%x result: x%x Data: x%x x%x\n",
390 phba->brd_no, cmd->cmnd[0], cmd->device->id,
391 cmd->device->lun, lpfc_cmd->status,
392 lpfc_cmd->result, pIocbOut->iocb.ulpContext,
393 lpfc_cmd->cur_iocbq.iocb.ulpIoTag);
394
395 switch (lpfc_cmd->status) {
396 case IOSTAT_FCP_RSP_ERROR:
397 /* Call FCP RSP handler to determine result */
398 lpfc_handle_fcp_err(lpfc_cmd);
399 break;
400 case IOSTAT_NPORT_BSY:
401 case IOSTAT_FABRIC_BSY:
402 cmd->result = ScsiResult(DID_BUS_BUSY, 0);
403 break;
404 default:
405 cmd->result = ScsiResult(DID_ERROR, 0);
406 break;
407 }
408
409 if (pnode) {
410 if (pnode->nlp_state != NLP_STE_MAPPED_NODE)
411 cmd->result = ScsiResult(DID_BUS_BUSY,
412 SAM_STAT_BUSY);
413 }
414 else {
415 cmd->result = ScsiResult(DID_NO_CONNECT, 0);
416 }
417 } else {
418 cmd->result = ScsiResult(DID_OK, 0);
419 }
420
421 if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) {
422 uint32_t *lp = (uint32_t *)cmd->sense_buffer;
423
424 lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
425 "%d:0710 Iodone <%d/%d> cmd %p, error x%x "
426 "SNS x%x x%x Data: x%x x%x\n",
427 phba->brd_no, cmd->device->id,
428 cmd->device->lun, cmd, cmd->result,
429 *lp, *(lp + 3), cmd->retries, cmd->resid);
430 }
431
432 spin_lock_irqsave(phba->host->host_lock, iflag);
433 lpfc_free_scsi_buf(lpfc_cmd);
434 cmd->host_scribble = NULL;
435 spin_unlock_irqrestore(phba->host->host_lock, iflag);
436
437 cmd->scsi_done(cmd);
438}
439
440static void
441lpfc_scsi_prep_cmnd(struct lpfc_hba * phba, struct lpfc_scsi_buf * lpfc_cmd,
442 struct lpfc_nodelist *pnode)
443{
444 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
445 struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
446 IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
447 struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
448 int datadir = scsi_cmnd->sc_data_direction;
449
450 lpfc_cmd->fcp_rsp->rspSnsLen = 0;
451
452 lpfc_put_lun(lpfc_cmd->fcp_cmnd, lpfc_cmd->pCmd->device->lun);
453
454 memcpy(&fcp_cmnd->fcpCdb[0], scsi_cmnd->cmnd, 16);
455
456 if (scsi_cmnd->device->tagged_supported) {
457 switch (scsi_cmnd->tag) {
458 case HEAD_OF_QUEUE_TAG:
459 fcp_cmnd->fcpCntl1 = HEAD_OF_Q;
460 break;
461 case ORDERED_QUEUE_TAG:
462 fcp_cmnd->fcpCntl1 = ORDERED_Q;
463 break;
464 default:
465 fcp_cmnd->fcpCntl1 = SIMPLE_Q;
466 break;
467 }
468 } else
469 fcp_cmnd->fcpCntl1 = 0;
470
471 /*
472 * There are three possibilities here - use scatter-gather segment, use
473 * the single mapping, or neither. Start the lpfc command prep by
474 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
475 * data bde entry.
476 */
477 if (scsi_cmnd->use_sg) {
478 if (datadir == DMA_TO_DEVICE) {
479 iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
480 iocb_cmd->un.fcpi.fcpi_parm = 0;
481 iocb_cmd->ulpPU = 0;
482 fcp_cmnd->fcpCntl3 = WRITE_DATA;
483 phba->fc4OutputRequests++;
484 } else {
485 iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR;
486 iocb_cmd->ulpPU = PARM_READ_CHECK;
487 iocb_cmd->un.fcpi.fcpi_parm =
488 scsi_cmnd->request_bufflen;
489 fcp_cmnd->fcpCntl3 = READ_DATA;
490 phba->fc4InputRequests++;
491 }
492 } else if (scsi_cmnd->request_buffer && scsi_cmnd->request_bufflen) {
493 if (datadir == DMA_TO_DEVICE) {
494 iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
495 iocb_cmd->un.fcpi.fcpi_parm = 0;
496 iocb_cmd->ulpPU = 0;
497 fcp_cmnd->fcpCntl3 = WRITE_DATA;
498 phba->fc4OutputRequests++;
499 } else {
500 iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR;
501 iocb_cmd->ulpPU = PARM_READ_CHECK;
502 iocb_cmd->un.fcpi.fcpi_parm =
503 scsi_cmnd->request_bufflen;
504 fcp_cmnd->fcpCntl3 = READ_DATA;
505 phba->fc4InputRequests++;
506 }
507 } else {
508 iocb_cmd->ulpCommand = CMD_FCP_ICMND64_CR;
509 iocb_cmd->un.fcpi.fcpi_parm = 0;
510 iocb_cmd->ulpPU = 0;
511 fcp_cmnd->fcpCntl3 = 0;
512 phba->fc4ControlRequests++;
513 }
514
515 /*
516 * Finish initializing those IOCB fields that are independent
517 * of the scsi_cmnd request_buffer
518 */
519 piocbq->iocb.ulpContext = pnode->nlp_rpi;
520 if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE)
521 piocbq->iocb.ulpFCP2Rcvy = 1;
522
523 piocbq->iocb.ulpClass = (pnode->nlp_fcp_info & 0x0f);
524 piocbq->context1 = lpfc_cmd;
525 piocbq->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
526 piocbq->iocb.ulpTimeout = lpfc_cmd->timeout;
527}
528
529static int
530lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_hba *phba,
531 struct lpfc_scsi_buf *lpfc_cmd,
532 uint8_t task_mgmt_cmd)
533{
534 struct lpfc_sli *psli;
535 struct lpfc_iocbq *piocbq;
536 IOCB_t *piocb;
537 struct fcp_cmnd *fcp_cmnd;
538 struct scsi_device *scsi_dev = lpfc_cmd->pCmd->device;
539 struct lpfc_rport_data *rdata = scsi_dev->hostdata;
540 struct lpfc_nodelist *ndlp = rdata->pnode;
541
542 if ((ndlp == 0) || (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
543 return 0;
544 }
545
546 psli = &phba->sli;
547 piocbq = &(lpfc_cmd->cur_iocbq);
548 piocb = &piocbq->iocb;
549
550 fcp_cmnd = lpfc_cmd->fcp_cmnd;
551 lpfc_put_lun(lpfc_cmd->fcp_cmnd, lpfc_cmd->pCmd->device->lun);
552 fcp_cmnd->fcpCntl2 = task_mgmt_cmd;
553
554 piocb->ulpCommand = CMD_FCP_ICMND64_CR;
555
556 piocb->ulpContext = ndlp->nlp_rpi;
557 if (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) {
558 piocb->ulpFCP2Rcvy = 1;
559 }
560 piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f);
561
562 /* ulpTimeout is only one byte */
563 if (lpfc_cmd->timeout > 0xff) {
564 /*
565 * Do not timeout the command at the firmware level.
566 * The driver will provide the timeout mechanism.
567 */
568 piocb->ulpTimeout = 0;
569 } else {
570 piocb->ulpTimeout = lpfc_cmd->timeout;
571 }
572
573 lpfc_cmd->rdata = rdata;
574
575 switch (task_mgmt_cmd) {
576 case FCP_LUN_RESET:
577 /* Issue LUN Reset to TGT <num> LUN <num> */
578 lpfc_printf_log(phba,
579 KERN_INFO,
580 LOG_FCP,
581 "%d:0703 Issue LUN Reset to TGT %d LUN %d "
582 "Data: x%x x%x\n",
583 phba->brd_no,
584 scsi_dev->id, scsi_dev->lun,
585 ndlp->nlp_rpi, ndlp->nlp_flag);
586
587 break;
588 case FCP_ABORT_TASK_SET:
589 /* Issue Abort Task Set to TGT <num> LUN <num> */
590 lpfc_printf_log(phba,
591 KERN_INFO,
592 LOG_FCP,
593 "%d:0701 Issue Abort Task Set to TGT %d LUN %d "
594 "Data: x%x x%x\n",
595 phba->brd_no,
596 scsi_dev->id, scsi_dev->lun,
597 ndlp->nlp_rpi, ndlp->nlp_flag);
598
599 break;
600 case FCP_TARGET_RESET:
601 /* Issue Target Reset to TGT <num> */
602 lpfc_printf_log(phba,
603 KERN_INFO,
604 LOG_FCP,
605 "%d:0702 Issue Target Reset to TGT %d "
606 "Data: x%x x%x\n",
607 phba->brd_no,
608 scsi_dev->id, ndlp->nlp_rpi,
609 ndlp->nlp_flag);
610 break;
611 }
612
613 return (1);
614}
615
616static int
617lpfc_scsi_tgt_reset(struct lpfc_scsi_buf * lpfc_cmd, struct lpfc_hba * phba)
618{
619 struct lpfc_iocbq *iocbq;
620 struct lpfc_iocbq *iocbqrsp = NULL;
621 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
622 int ret;
623
624 ret = lpfc_scsi_prep_task_mgmt_cmd(phba, lpfc_cmd, FCP_TARGET_RESET);
625 if (!ret)
626 return FAILED;
627
628 lpfc_cmd->scsi_hba = phba;
629 iocbq = &lpfc_cmd->cur_iocbq;
630 list_remove_head(lpfc_iocb_list, iocbqrsp, struct lpfc_iocbq, list);
631 if (!iocbqrsp)
632 return FAILED;
633 memset(iocbqrsp, 0, sizeof (struct lpfc_iocbq));
634
635 iocbq->iocb_flag |= LPFC_IO_POLL;
636 ret = lpfc_sli_issue_iocb_wait_high_priority(phba,
637 &phba->sli.ring[phba->sli.fcp_ring],
638 iocbq, SLI_IOCB_HIGH_PRIORITY,
639 iocbqrsp,
640 lpfc_cmd->timeout);
641 if (ret != IOCB_SUCCESS) {
642 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
643 ret = FAILED;
644 } else {
645 ret = SUCCESS;
646 lpfc_cmd->result = iocbqrsp->iocb.un.ulpWord[4];
647 lpfc_cmd->status = iocbqrsp->iocb.ulpStatus;
648 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
649 (lpfc_cmd->result & IOERR_DRVR_MASK))
650 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
651 }
652
653 /*
654 * All outstanding txcmplq I/Os should have been aborted by the target.
655 * Unfortunately, some targets do not abide by this forcing the driver
656 * to double check.
657 */
658 lpfc_sli_abort_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring],
659 lpfc_cmd->pCmd->device->id,
660 lpfc_cmd->pCmd->device->lun, 0, LPFC_CTX_TGT);
661
662 /* Return response IOCB to free list. */
663 list_add_tail(&iocbqrsp->list, lpfc_iocb_list);
664 return ret;
665}
666
667static void
668lpfc_scsi_cmd_iocb_cleanup (struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
669 struct lpfc_iocbq *pIocbOut)
670{
671 unsigned long iflag;
672 struct lpfc_scsi_buf *lpfc_cmd =
673 (struct lpfc_scsi_buf *) pIocbIn->context1;
674
675 spin_lock_irqsave(phba->host->host_lock, iflag);
676 lpfc_free_scsi_buf(lpfc_cmd);
677 spin_unlock_irqrestore(phba->host->host_lock, iflag);
678}
679
680static void
681lpfc_scsi_cmd_iocb_cmpl_aborted(struct lpfc_hba *phba,
682 struct lpfc_iocbq *pIocbIn,
683 struct lpfc_iocbq *pIocbOut)
684{
685 struct scsi_cmnd *ml_cmd =
686 ((struct lpfc_scsi_buf *) pIocbIn->context1)->pCmd;
687
688 lpfc_scsi_cmd_iocb_cleanup (phba, pIocbIn, pIocbOut);
689 ml_cmd->host_scribble = NULL;
690}
691
692const char *
693lpfc_info(struct Scsi_Host *host)
694{
695 struct lpfc_hba *phba = (struct lpfc_hba *) host->hostdata[0];
696 int len;
697 static char lpfcinfobuf[384];
698
699 memset(lpfcinfobuf,0,384);
700 if (phba && phba->pcidev){
701 strncpy(lpfcinfobuf, phba->ModelDesc, 256);
702 len = strlen(lpfcinfobuf);
703 snprintf(lpfcinfobuf + len,
704 384-len,
705 " on PCI bus %02x device %02x irq %d",
706 phba->pcidev->bus->number,
707 phba->pcidev->devfn,
708 phba->pcidev->irq);
709 len = strlen(lpfcinfobuf);
710 if (phba->Port[0]) {
711 snprintf(lpfcinfobuf + len,
712 384-len,
713 " port %s",
714 phba->Port);
715 }
716 }
717 return lpfcinfobuf;
718}
719
720static int
721lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
722{
723 struct lpfc_hba *phba =
724 (struct lpfc_hba *) cmnd->device->host->hostdata[0];
725 struct lpfc_sli *psli = &phba->sli;
726 struct lpfc_rport_data *rdata = cmnd->device->hostdata;
727 struct lpfc_nodelist *ndlp = rdata->pnode;
728 struct lpfc_scsi_buf *lpfc_cmd = NULL;
729 struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
730 int err = 0;
731
732 /*
733 * The target pointer is guaranteed not to be NULL because the driver
734 * only clears the device->hostdata field in lpfc_slave_destroy. This
735 * approach guarantees no further IO calls on this target.
736 */
737 if (!ndlp) {
738 cmnd->result = ScsiResult(DID_NO_CONNECT, 0);
739 goto out_fail_command;
740 }
741
742 /*
743 * A Fibre Channel target is present and functioning only when the node
744 * state is MAPPED. Any other state is a failure.
745 */
746 if (ndlp->nlp_state != NLP_STE_MAPPED_NODE) {
747 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
748 (ndlp->nlp_state == NLP_STE_UNUSED_NODE)) {
749 cmnd->result = ScsiResult(DID_NO_CONNECT, 0);
750 goto out_fail_command;
751 }
752 /*
753 * The device is most likely recovered and the driver
754 * needs a bit more time to finish. Ask the midlayer
755 * to retry.
756 */
757 goto out_host_busy;
758 }
759
760 list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
761 if (lpfc_cmd == NULL) {
762 printk(KERN_WARNING "%s: No buffer available - list empty, "
763 "total count %d\n", __FUNCTION__, phba->total_scsi_bufs);
764 goto out_host_busy;
765 }
766
767 /*
768 * Store the midlayer's command structure for the completion phase
769 * and complete the command initialization.
770 */
771 lpfc_cmd->pCmd = cmnd;
772 lpfc_cmd->rdata = rdata;
773 lpfc_cmd->timeout = 0;
774 cmnd->host_scribble = (unsigned char *)lpfc_cmd;
775 cmnd->scsi_done = done;
776
777 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
778 if (err)
779 goto out_host_busy_free_buf;
780
781 lpfc_scsi_prep_cmnd(phba, lpfc_cmd, ndlp);
782
783 err = lpfc_sli_issue_iocb(phba, &phba->sli.ring[psli->fcp_ring],
784 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
785 if (err)
786 goto out_host_busy_free_buf;
787 return 0;
788
789 out_host_busy_free_buf:
790 lpfc_free_scsi_buf(lpfc_cmd);
791 cmnd->host_scribble = NULL;
792 out_host_busy:
793 return SCSI_MLQUEUE_HOST_BUSY;
794
795 out_fail_command:
796 done(cmnd);
797 return 0;
798}
799
800static int
801lpfc_abort_handler(struct scsi_cmnd *cmnd)
802{
803 struct lpfc_hba *phba =
804 (struct lpfc_hba *)cmnd->device->host->hostdata[0];
805 struct lpfc_sli_ring *pring = &phba->sli.ring[phba->sli.fcp_ring];
806 struct lpfc_iocbq *iocb, *next_iocb;
807 struct lpfc_iocbq *abtsiocb = NULL;
808 struct lpfc_scsi_buf *lpfc_cmd;
809 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
810 IOCB_t *cmd, *icmd;
811 unsigned long snum;
812 unsigned int id, lun;
813 unsigned int loop_count = 0;
814 int ret = IOCB_SUCCESS;
815
816 /*
817 * If the host_scribble data area is NULL, then the driver has already
818 * completed this command, but the midlayer did not see the completion
819 * before the eh fired. Just return SUCCESS.
820 */
821 lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble;
822 if (!lpfc_cmd)
823 return SUCCESS;
824
825 /* save these now since lpfc_cmd can be freed */
826 id = lpfc_cmd->pCmd->device->id;
827 lun = lpfc_cmd->pCmd->device->lun;
828 snum = lpfc_cmd->pCmd->serial_number;
829
830 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
831 cmd = &iocb->iocb;
832 if (iocb->context1 != lpfc_cmd)
833 continue;
834
835 list_del_init(&iocb->list);
836 pring->txq_cnt--;
837 if (!iocb->iocb_cmpl) {
838 list_add_tail(&iocb->list, lpfc_iocb_list);
839 }
840 else {
841 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
842 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
843 lpfc_scsi_cmd_iocb_cmpl_aborted(phba, iocb, iocb);
844 }
845
846 goto out;
847 }
848
849 list_remove_head(lpfc_iocb_list, abtsiocb, struct lpfc_iocbq, list);
850 if (abtsiocb == NULL)
851 return FAILED;
852
853 memset(abtsiocb, 0, sizeof (struct lpfc_iocbq));
854
855 /*
856 * The scsi command was not in the txq. Check the txcmplq and if it is
857 * found, send an abort to the FW.
858 */
859 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
860 if (iocb->context1 != lpfc_cmd)
861 continue;
862
863 iocb->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl_aborted;
864 cmd = &iocb->iocb;
865 icmd = &abtsiocb->iocb;
866 icmd->un.acxri.abortType = ABORT_TYPE_ABTS;
867 icmd->un.acxri.abortContextTag = cmd->ulpContext;
868 icmd->un.acxri.abortIoTag = cmd->ulpIoTag;
869
870 icmd->ulpLe = 1;
871 icmd->ulpClass = cmd->ulpClass;
872 if (phba->hba_state >= LPFC_LINK_UP)
873 icmd->ulpCommand = CMD_ABORT_XRI_CN;
874 else
875 icmd->ulpCommand = CMD_CLOSE_XRI_CN;
876
877 if (lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0) ==
878 IOCB_ERROR) {
879 list_add_tail(&abtsiocb->list, lpfc_iocb_list);
880 ret = IOCB_ERROR;
881 break;
882 }
883
884 /* Wait for abort to complete */
885 while (cmnd->host_scribble)
886 {
887 spin_unlock_irq(phba->host->host_lock);
888 set_current_state(TASK_UNINTERRUPTIBLE);
889 schedule_timeout(LPFC_ABORT_WAIT*HZ);
890 spin_lock_irq(phba->host->host_lock);
891 if (++loop_count
892 > (2 * phba->cfg_nodev_tmo)/LPFC_ABORT_WAIT)
893 break;
894 }
895
896 if(cmnd->host_scribble) {
897 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
898 "%d:0748 abort handler timed "
899 "out waiting for abort to "
900 "complete. Data: "
901 "x%x x%x x%x x%lx\n",
902 phba->brd_no, ret, id, lun, snum);
903 cmnd->host_scribble = NULL;
904 iocb->iocb_cmpl = lpfc_scsi_cmd_iocb_cleanup;
905 ret = IOCB_ERROR;
906 }
907
908 break;
909 }
910
911 out:
912 lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
913 "%d:0749 SCSI layer issued abort device "
914 "Data: x%x x%x x%x x%lx\n",
915 phba->brd_no, ret, id, lun, snum);
916
917 return ret == IOCB_SUCCESS ? SUCCESS : FAILED;
918}
919
920static int
921lpfc_reset_lun_handler(struct scsi_cmnd *cmnd)
922{
923 struct Scsi_Host *shost = cmnd->device->host;
924 struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata[0];
925 struct lpfc_sli *psli = &phba->sli;
926 struct lpfc_scsi_buf *lpfc_cmd = NULL;
927 struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
928 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
929 struct lpfc_iocbq *iocbq, *iocbqrsp = NULL;
930 struct lpfc_rport_data *rdata = cmnd->device->hostdata;
931 struct lpfc_nodelist *pnode = rdata->pnode;
932 int ret = FAILED;
933 int cnt, loopcnt;
934
935 /*
936 * If target is not in a MAPPED state, delay the reset until
937 * target is rediscovered or nodev timeout expires.
938 */
939 while ( 1 ) {
940 if (!pnode)
941 break;
942
943 if (pnode->nlp_state != NLP_STE_MAPPED_NODE) {
944 spin_unlock_irq(phba->host->host_lock);
945 set_current_state(TASK_UNINTERRUPTIBLE);
946 schedule_timeout( HZ/2);
947 spin_lock_irq(phba->host->host_lock);
948 }
949 if ((pnode) && (pnode->nlp_state == NLP_STE_MAPPED_NODE))
950 break;
951 }
952
953 list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
954 if (lpfc_cmd == NULL)
955 goto out;
956
957 lpfc_cmd->pCmd = cmnd;
958 lpfc_cmd->timeout = 60;
959 lpfc_cmd->scsi_hba = phba;
960
961 ret = lpfc_scsi_prep_task_mgmt_cmd(phba, lpfc_cmd, FCP_LUN_RESET);
962 if (!ret)
963 goto out_free_scsi_buf;
964
965 iocbq = &lpfc_cmd->cur_iocbq;
966
967 /* get a buffer for this IOCB command response */
968 list_remove_head(lpfc_iocb_list, iocbqrsp, struct lpfc_iocbq, list);
969 if (iocbqrsp == NULL)
970 goto out_free_scsi_buf;
971
972 memset(iocbqrsp, 0, sizeof (struct lpfc_iocbq));
973
974 iocbq->iocb_flag |= LPFC_IO_POLL;
975 iocbq->iocb_cmpl = lpfc_sli_wake_iocb_high_priority;
976
977 ret = lpfc_sli_issue_iocb_wait_high_priority(phba,
978 &phba->sli.ring[psli->fcp_ring],
979 iocbq, 0, iocbqrsp, 60);
980 if (ret == IOCB_SUCCESS)
981 ret = SUCCESS;
982
983 lpfc_cmd->result = iocbqrsp->iocb.un.ulpWord[4];
984 lpfc_cmd->status = iocbqrsp->iocb.ulpStatus;
985 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT)
986 if (lpfc_cmd->result & IOERR_DRVR_MASK)
987 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
988
989 /*
990 * All outstanding txcmplq I/Os should have been aborted by the target.
991 * Unfortunately, some targets do not abide by this forcing the driver
992 * to double check.
993 */
994 lpfc_sli_abort_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring],
995 cmnd->device->id, cmnd->device->lun, 0,
996 LPFC_CTX_LUN);
997
998 loopcnt = 0;
999 while((cnt = lpfc_sli_sum_iocb(phba,
1000 &phba->sli.ring[phba->sli.fcp_ring],
1001 cmnd->device->id, cmnd->device->lun,
1002 LPFC_CTX_LUN))) {
1003 spin_unlock_irq(phba->host->host_lock);
1004 set_current_state(TASK_UNINTERRUPTIBLE);
1005 schedule_timeout(LPFC_RESET_WAIT*HZ);
1006 spin_lock_irq(phba->host->host_lock);
1007
1008 if (++loopcnt
1009 > (2 * phba->cfg_nodev_tmo)/LPFC_RESET_WAIT)
1010 break;
1011 }
1012
1013 if (cnt) {
1014 lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
1015 "%d:0719 LUN Reset I/O flush failure: cnt x%x\n",
1016 phba->brd_no, cnt);
1017 }
1018
1019 list_add_tail(&iocbqrsp->list, lpfc_iocb_list);
1020
1021out_free_scsi_buf:
1022 lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1023 "%d:0713 SCSI layer issued LUN reset (%d, %d) "
1024 "Data: x%x x%x x%x\n",
1025 phba->brd_no, lpfc_cmd->pCmd->device->id,
1026 lpfc_cmd->pCmd->device->lun, ret, lpfc_cmd->status,
1027 lpfc_cmd->result);
1028 lpfc_free_scsi_buf(lpfc_cmd);
1029out:
1030 return ret;
1031}
1032
1033/*
1034 * Note: midlayer calls this function with the host_lock held
1035 */
1036static int
1037lpfc_reset_bus_handler(struct scsi_cmnd *cmnd)
1038{
1039 struct Scsi_Host *shost = cmnd->device->host;
1040 struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata[0];
1041 struct lpfc_nodelist *ndlp = NULL;
1042 int match;
1043 int ret = FAILED, i, err_count = 0;
1044 int cnt, loopcnt;
1045 unsigned int midlayer_id = 0;
1046 struct lpfc_scsi_buf * lpfc_cmd = NULL;
1047 struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
1048
1049 list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
1050 if (lpfc_cmd == NULL)
1051 goto out;
1052
1053 /* The lpfc_cmd storage is reused. Set all loop invariants. */
1054 lpfc_cmd->timeout = 60;
1055 lpfc_cmd->pCmd = cmnd;
1056 lpfc_cmd->scsi_hba = phba;
1057
1058 /*
1059 * Since the driver manages a single bus device, reset all
1060 * targets known to the driver. Should any target reset
1061 * fail, this routine returns failure to the midlayer.
1062 */
1063 midlayer_id = cmnd->device->id;
1064 for (i = 0; i < MAX_FCP_TARGET; i++) {
1065 /* Search the mapped list for this target ID */
1066 match = 0;
1067 list_for_each_entry(ndlp, &phba->fc_nlpmap_list, nlp_listp) {
1068 if ((i == ndlp->nlp_sid) && ndlp->rport) {
1069 match = 1;
1070 break;
1071 }
1072 }
1073 if (!match)
1074 continue;
1075
1076 lpfc_cmd->pCmd->device->id = i;
1077 lpfc_cmd->pCmd->device->hostdata = ndlp->rport->dd_data;
1078 ret = lpfc_scsi_tgt_reset(lpfc_cmd, phba);
1079 if (ret != SUCCESS) {
1080 lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
1081 "%d:0713 Bus Reset on target %d failed\n",
1082 phba->brd_no, i);
1083 err_count++;
1084 }
1085 }
1086
1087 cmnd->device->id = midlayer_id;
1088 loopcnt = 0;
1089 while((cnt = lpfc_sli_sum_iocb(phba,
1090 &phba->sli.ring[phba->sli.fcp_ring],
1091 0, 0, LPFC_CTX_HOST))) {
1092 spin_unlock_irq(phba->host->host_lock);
1093 set_current_state(TASK_UNINTERRUPTIBLE);
1094 schedule_timeout(LPFC_RESET_WAIT*HZ);
1095 spin_lock_irq(phba->host->host_lock);
1096
1097 if (++loopcnt
1098 > (2 * phba->cfg_nodev_tmo)/LPFC_RESET_WAIT)
1099 break;
1100 }
1101
1102 if (cnt) {
1103 /* flush all outstanding commands on the host */
1104 i = lpfc_sli_abort_iocb(phba,
1105 &phba->sli.ring[phba->sli.fcp_ring], 0, 0, 0,
1106 LPFC_CTX_HOST);
1107
1108 lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
1109 "%d:0715 Bus Reset I/O flush failure: cnt x%x left x%x\n",
1110 phba->brd_no, cnt, i);
1111 }
1112
1113 if (!err_count)
1114 ret = SUCCESS;
1115
1116 lpfc_free_scsi_buf(lpfc_cmd);
1117 lpfc_printf_log(phba,
1118 KERN_ERR,
1119 LOG_FCP,
1120 "%d:0714 SCSI layer issued Bus Reset Data: x%x\n",
1121 phba->brd_no, ret);
1122out:
1123 return ret;
1124}
1125
1126static int
1127lpfc_slave_alloc(struct scsi_device *sdev)
1128{
1129 struct lpfc_hba *phba = (struct lpfc_hba *)sdev->host->hostdata[0];
1130 struct lpfc_nodelist *ndlp = NULL;
1131 int match = 0;
1132 struct lpfc_scsi_buf *scsi_buf = NULL;
1133 uint32_t total = 0, i;
1134 uint32_t num_to_alloc = 0;
1135 unsigned long flags;
1136 struct list_head *listp;
1137 struct list_head *node_list[6];
1138
1139 /*
1140 * Store the target pointer in the scsi_device hostdata pointer provided
1141 * the driver has already discovered the target id.
1142 */
1143
1144 /* Search the nlp lists other than unmap_list for this target ID */
1145 node_list[0] = &phba->fc_npr_list;
1146 node_list[1] = &phba->fc_nlpmap_list;
1147 node_list[2] = &phba->fc_prli_list;
1148 node_list[3] = &phba->fc_reglogin_list;
1149 node_list[4] = &phba->fc_adisc_list;
1150 node_list[5] = &phba->fc_plogi_list;
1151
1152 for (i = 0; i < 6 && !match; i++) {
1153 listp = node_list[i];
1154 if (list_empty(listp))
1155 continue;
1156 list_for_each_entry(ndlp, listp, nlp_listp) {
1157 if ((sdev->id == ndlp->nlp_sid) && ndlp->rport) {
1158 match = 1;
1159 break;
1160 }
1161 }
1162 }
1163
1164 if (!match)
1165 return -ENXIO;
1166
1167 sdev->hostdata = ndlp->rport->dd_data;
1168
1169 /*
1170 * Populate the cmds_per_lun count scsi_bufs into this host's globally
1171 * available list of scsi buffers. Don't allocate more than the
1172 * HBA limit conveyed to the midlayer via the host structure. Note
1173 * that this list of scsi bufs exists for the lifetime of the driver.
1174 */
1175 total = phba->total_scsi_bufs;
1176 num_to_alloc = LPFC_CMD_PER_LUN;
1177 if (total >= phba->cfg_hba_queue_depth) {
1178 printk(KERN_WARNING "%s, At config limitation of "
1179 "%d allocated scsi_bufs\n", __FUNCTION__, total);
1180 return 0;
1181 } else if (total + num_to_alloc > phba->cfg_hba_queue_depth) {
1182 num_to_alloc = phba->cfg_hba_queue_depth - total;
1183 }
1184
1185 for (i = 0; i < num_to_alloc; i++) {
1186 scsi_buf = lpfc_get_scsi_buf(phba);
1187 if (!scsi_buf) {
1188 printk(KERN_ERR "%s, failed to allocate "
1189 "scsi_buf\n", __FUNCTION__);
1190 break;
1191 }
1192
1193 spin_lock_irqsave(phba->host->host_lock, flags);
1194 phba->total_scsi_bufs++;
1195 list_add_tail(&scsi_buf->list, &phba->lpfc_scsi_buf_list);
1196 spin_unlock_irqrestore(phba->host->host_lock, flags);
1197 }
1198 return 0;
1199}
1200
1201static int
1202lpfc_slave_configure(struct scsi_device *sdev)
1203{
1204 struct lpfc_hba *phba = (struct lpfc_hba *) sdev->host->hostdata[0];
1205 struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
1206
1207 if (sdev->tagged_supported)
1208 scsi_activate_tcq(sdev, phba->cfg_lun_queue_depth);
1209 else
1210 scsi_deactivate_tcq(sdev, phba->cfg_lun_queue_depth);
1211
1212 /*
1213 * Initialize the fc transport attributes for the target
1214 * containing this scsi device. Also note that the driver's
1215 * target pointer is stored in the starget_data for the
1216 * driver's sysfs entry point functions.
1217 */
1218 rport->dev_loss_tmo = phba->cfg_nodev_tmo + 5;
1219
1220 return 0;
1221}
1222
1223static void
1224lpfc_slave_destroy(struct scsi_device *sdev)
1225{
1226 sdev->hostdata = NULL;
1227 return;
1228}
1229
1230struct scsi_host_template lpfc_template = {
1231 .module = THIS_MODULE,
1232 .name = LPFC_DRIVER_NAME,
1233 .info = lpfc_info,
1234 .queuecommand = lpfc_queuecommand,
1235 .eh_abort_handler = lpfc_abort_handler,
1236 .eh_device_reset_handler= lpfc_reset_lun_handler,
1237 .eh_bus_reset_handler = lpfc_reset_bus_handler,
1238 .slave_alloc = lpfc_slave_alloc,
1239 .slave_configure = lpfc_slave_configure,
1240 .slave_destroy = lpfc_slave_destroy,
1241 .this_id = -1,
1242 .sg_tablesize = LPFC_SG_SEG_CNT,
1243 .cmd_per_lun = LPFC_CMD_PER_LUN,
1244 .use_clustering = ENABLE_CLUSTERING,
1245 .shost_attrs = lpfc_host_attrs,
1246};
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-14 12:04:51 -0500