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