lpfc_scsi.c 41.7 KB
Newer Older
已提交
1 2
/*******************************************************************
 * This file is part of the Emulex Linux Device Driver for         *
3
 * Fibre Channel Host Bus Adapters.                                *
4
 * Copyright (C) 2004-2007 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 11 12 13 14 15 16 17 18 19
 * modify it under the terms of version 2 of the GNU General       *
 * Public License as published by the Free Software Foundation.    *
 * This program is distributed in the hope that it will be useful. *
 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
 * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
 * more details, a copy of which can be found in the file COPYING  *
 * included with this package.                                     *
已提交
20 21 22 23
 *******************************************************************/

#include <linux/pci.h>
#include <linux/interrupt.h>
24
#include <linux/delay.h>
已提交
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_transport_fc.h>

#include "lpfc_version.h"
#include "lpfc_hw.h"
#include "lpfc_sli.h"
#include "lpfc_disc.h"
#include "lpfc_scsi.h"
#include "lpfc.h"
#include "lpfc_logmsg.h"
#include "lpfc_crtn.h"
40
#include "lpfc_vport.h"
已提交
41 42 43 44

#define LPFC_RESET_WAIT  2
#define LPFC_ABORT_WAIT  2

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
/*
 * This function is called with no lock held when there is a resource
 * error in driver or in firmware.
 */
void
lpfc_adjust_queue_depth(struct lpfc_hba *phba)
{
	unsigned long flags;

	spin_lock_irqsave(&phba->hbalock, flags);
	atomic_inc(&phba->num_rsrc_err);
	phba->last_rsrc_error_time = jiffies;

	if ((phba->last_ramp_down_time + QUEUE_RAMP_DOWN_INTERVAL) > jiffies) {
		spin_unlock_irqrestore(&phba->hbalock, flags);
		return;
	}

	phba->last_ramp_down_time = jiffies;

	spin_unlock_irqrestore(&phba->hbalock, flags);

	spin_lock_irqsave(&phba->pport->work_port_lock, flags);
	if ((phba->pport->work_port_events &
		WORKER_RAMP_DOWN_QUEUE) == 0) {
		phba->pport->work_port_events |= WORKER_RAMP_DOWN_QUEUE;
	}
	spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);

	spin_lock_irqsave(&phba->hbalock, flags);
	if (phba->work_wait)
		wake_up(phba->work_wait);
	spin_unlock_irqrestore(&phba->hbalock, flags);

	return;
}

/*
 * This function is called with no lock held when there is a successful
 * SCSI command completion.
 */
static inline void
lpfc_rampup_queue_depth(struct lpfc_hba *phba,
			struct scsi_device *sdev)
{
	unsigned long flags;
	atomic_inc(&phba->num_cmd_success);

	if (phba->cfg_lun_queue_depth <= sdev->queue_depth)
		return;

	spin_lock_irqsave(&phba->hbalock, flags);
	if (((phba->last_ramp_up_time + QUEUE_RAMP_UP_INTERVAL) > jiffies) ||
	 ((phba->last_rsrc_error_time + QUEUE_RAMP_UP_INTERVAL ) > jiffies)) {
		spin_unlock_irqrestore(&phba->hbalock, flags);
		return;
	}

	phba->last_ramp_up_time = jiffies;
	spin_unlock_irqrestore(&phba->hbalock, flags);

	spin_lock_irqsave(&phba->pport->work_port_lock, flags);
	if ((phba->pport->work_port_events &
		WORKER_RAMP_UP_QUEUE) == 0) {
		phba->pport->work_port_events |= WORKER_RAMP_UP_QUEUE;
	}
	spin_unlock_irqrestore(&phba->pport->work_port_lock, flags);

	spin_lock_irqsave(&phba->hbalock, flags);
	if (phba->work_wait)
		wake_up(phba->work_wait);
	spin_unlock_irqrestore(&phba->hbalock, flags);
}

void
lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
{
122 123
	struct lpfc_vport **vports;
	struct Scsi_Host  *shost;
124 125 126
	struct scsi_device *sdev;
	unsigned long new_queue_depth;
	unsigned long num_rsrc_err, num_cmd_success;
127
	int i;
128 129 130 131

	num_rsrc_err = atomic_read(&phba->num_rsrc_err);
	num_cmd_success = atomic_read(&phba->num_cmd_success);

132 133 134 135 136
	vports = lpfc_create_vport_work_array(phba);
	if (vports != NULL)
		for(i = 0; i < LPFC_MAX_VPORTS && vports[i] != NULL; i++) {
			shost = lpfc_shost_from_vport(vports[i]);
			shost_for_each_device(sdev, shost) {
137
				new_queue_depth =
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
					sdev->queue_depth * num_rsrc_err /
					(num_rsrc_err + num_cmd_success);
				if (!new_queue_depth)
					new_queue_depth = sdev->queue_depth - 1;
				else
					new_queue_depth = sdev->queue_depth -
								new_queue_depth;
				if (sdev->ordered_tags)
					scsi_adjust_queue_depth(sdev,
							MSG_ORDERED_TAG,
							new_queue_depth);
				else
					scsi_adjust_queue_depth(sdev,
							MSG_SIMPLE_TAG,
							new_queue_depth);
			}
154
		}
155
	lpfc_destroy_vport_work_array(vports);
156 157 158 159 160 161 162 163
	spin_unlock_irq(&phba->hbalock);
	atomic_set(&phba->num_rsrc_err, 0);
	atomic_set(&phba->num_cmd_success, 0);
}

void
lpfc_ramp_up_queue_handler(struct lpfc_hba *phba)
{
164 165
	struct lpfc_vport **vports;
	struct Scsi_Host  *shost;
166
	struct scsi_device *sdev;
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
	int i;

	vports = lpfc_create_vport_work_array(phba);
	if (vports != NULL)
		for(i = 0; i < LPFC_MAX_VPORTS && vports[i] != NULL; i++) {
			shost = lpfc_shost_from_vport(vports[i]);
			shost_for_each_device(sdev, shost) {
				if (sdev->ordered_tags)
					scsi_adjust_queue_depth(sdev,
							MSG_ORDERED_TAG,
							sdev->queue_depth+1);
				else
					scsi_adjust_queue_depth(sdev,
							MSG_SIMPLE_TAG,
							sdev->queue_depth+1);
			}
183
		}
184
	lpfc_destroy_vport_work_array(vports);
185 186 187 188
	atomic_set(&phba->num_rsrc_err, 0);
	atomic_set(&phba->num_cmd_success, 0);
}

已提交
189 190 191 192 193 194 195 196 197
/*
 * This routine allocates a scsi buffer, which contains all the necessary
 * information needed to initiate a SCSI I/O.  The non-DMAable buffer region
 * contains information to build the IOCB.  The DMAable region contains
 * memory for the FCP CMND, FCP RSP, and the inital BPL.  In addition to
 * allocating memeory, the FCP CMND and FCP RSP BDEs are setup in the BPL
 * and the BPL BDE is setup in the IOCB.
 */
static struct lpfc_scsi_buf *
J
James Smart 已提交
198
lpfc_new_scsi_buf(struct lpfc_vport *vport)
已提交
199
{
J
James Smart 已提交
200
	struct lpfc_hba *phba = vport->phba;
已提交
201 202 203 204
	struct lpfc_scsi_buf *psb;
	struct ulp_bde64 *bpl;
	IOCB_t *iocb;
	dma_addr_t pdma_phys;
205
	uint16_t iotag;
已提交
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227

	psb = kmalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
	if (!psb)
		return NULL;
	memset(psb, 0, sizeof (struct lpfc_scsi_buf));

	/*
	 * Get memory from the pci pool to map the virt space to pci bus space
	 * for an I/O.  The DMA buffer includes space for the struct fcp_cmnd,
	 * struct fcp_rsp and the number of bde's necessary to support the
	 * sg_tablesize.
	 */
	psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool, GFP_KERNEL,
							&psb->dma_handle);
	if (!psb->data) {
		kfree(psb);
		return NULL;
	}

	/* Initialize virtual ptrs to dma_buf region. */
	memset(psb->data, 0, phba->cfg_sg_dma_buf_size);

228 229 230 231 232 233 234 235
	/* Allocate iotag for psb->cur_iocbq. */
	iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
	if (iotag == 0) {
		pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
			      psb->data, psb->dma_handle);
		kfree (psb);
		return NULL;
	}
236
	psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
237

已提交
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
	psb->fcp_cmnd = psb->data;
	psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd);
	psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) +
							sizeof(struct fcp_rsp);

	/* Initialize local short-hand pointers. */
	bpl = psb->fcp_bpl;
	pdma_phys = psb->dma_handle;

	/*
	 * The first two bdes are the FCP_CMD and FCP_RSP.  The balance are sg
	 * list bdes.  Initialize the first two and leave the rest for
	 * queuecommand.
	 */
	bpl->addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys));
	bpl->addrLow = le32_to_cpu(putPaddrLow(pdma_phys));
	bpl->tus.f.bdeSize = sizeof (struct fcp_cmnd);
	bpl->tus.f.bdeFlags = BUFF_USE_CMND;
	bpl->tus.w = le32_to_cpu(bpl->tus.w);
	bpl++;

	/* Setup the physical region for the FCP RSP */
	pdma_phys += sizeof (struct fcp_cmnd);
	bpl->addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys));
	bpl->addrLow = le32_to_cpu(putPaddrLow(pdma_phys));
	bpl->tus.f.bdeSize = sizeof (struct fcp_rsp);
	bpl->tus.f.bdeFlags = (BUFF_USE_CMND | BUFF_USE_RCV);
	bpl->tus.w = le32_to_cpu(bpl->tus.w);

	/*
	 * Since the IOCB for the FCP I/O is built into this lpfc_scsi_buf,
	 * initialize it with all known data now.
	 */
	pdma_phys += (sizeof (struct fcp_rsp));
	iocb = &psb->cur_iocbq.iocb;
	iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
	iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys);
	iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys);
	iocb->un.fcpi64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
	iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDL;
	iocb->ulpBdeCount = 1;
	iocb->ulpClass = CLASS3;

	return psb;
}

284
static struct lpfc_scsi_buf*
285
lpfc_get_scsi_buf(struct lpfc_hba * phba)
已提交
286
{
287 288
	struct  lpfc_scsi_buf * lpfc_cmd = NULL;
	struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
289
	unsigned long iflag = 0;
290

291
	spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
292
	list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
293 294 295 296
	if (lpfc_cmd) {
		lpfc_cmd->seg_cnt = 0;
		lpfc_cmd->nonsg_phys = 0;
	}
297
	spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
298 299
	return  lpfc_cmd;
}
已提交
300

301
static void
302
lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
303
{
304
	unsigned long iflag = 0;
已提交
305

306
	spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
307
	psb->pCmd = NULL;
已提交
308
	list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list);
309
	spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
已提交
310 311 312
}

static int
313
lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
已提交
314 315 316 317 318 319 320 321
{
	struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
	struct scatterlist *sgel = NULL;
	struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
	struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
	IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
	dma_addr_t physaddr;
	uint32_t i, num_bde = 0;
322
	int nseg, datadir = scsi_cmnd->sc_data_direction;
已提交
323 324 325 326 327 328 329 330

	/*
	 * There are three possibilities here - use scatter-gather segment, use
	 * the single mapping, or neither.  Start the lpfc command prep by
	 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
	 * data bde entry.
	 */
	bpl += 2;
331
	if (scsi_sg_count(scsi_cmnd)) {
已提交
332 333 334 335 336 337 338
		/*
		 * The driver stores the segment count returned from pci_map_sg
		 * because this a count of dma-mappings used to map the use_sg
		 * pages.  They are not guaranteed to be the same for those
		 * architectures that implement an IOMMU.
		 */

339 340 341 342 343
		nseg = dma_map_sg(&phba->pcidev->dev, scsi_sglist(scsi_cmnd),
				  scsi_sg_count(scsi_cmnd), datadir);
		if (unlikely(!nseg))
			return 1;

344
		lpfc_cmd->seg_cnt = nseg;
已提交
345 346 347 348 349
		if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
			printk(KERN_ERR "%s: Too many sg segments from "
			       "dma_map_sg.  Config %d, seg_cnt %d",
			       __FUNCTION__, phba->cfg_sg_seg_cnt,
			       lpfc_cmd->seg_cnt);
350
			scsi_dma_unmap(scsi_cmnd);
已提交
351 352 353 354 355 356 357 358 359
			return 1;
		}

		/*
		 * The driver established a maximum scatter-gather segment count
		 * during probe that limits the number of sg elements in any
		 * single scsi command.  Just run through the seg_cnt and format
		 * the bde's.
		 */
360
		scsi_for_each_sg(scsi_cmnd, sgel, nseg, i) {
已提交
361 362 363 364 365 366 367 368 369 370 371 372
			physaddr = sg_dma_address(sgel);
			bpl->addrLow = le32_to_cpu(putPaddrLow(physaddr));
			bpl->addrHigh = le32_to_cpu(putPaddrHigh(physaddr));
			bpl->tus.f.bdeSize = sg_dma_len(sgel);
			if (datadir == DMA_TO_DEVICE)
				bpl->tus.f.bdeFlags = 0;
			else
				bpl->tus.f.bdeFlags = BUFF_USE_RCV;
			bpl->tus.w = le32_to_cpu(bpl->tus.w);
			bpl++;
			num_bde++;
		}
373
	}
已提交
374 375 376

	/*
	 * Finish initializing those IOCB fields that are dependent on the
377 378 379
	 * scsi_cmnd request_buffer.  Note that the bdeSize is explicitly
	 * reinitialized since all iocb memory resources are used many times
	 * for transmit, receive, and continuation bpl's.
已提交
380
	 */
381
	iocb_cmd->un.fcpi64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
已提交
382 383 384 385
	iocb_cmd->un.fcpi64.bdl.bdeSize +=
		(num_bde * sizeof (struct ulp_bde64));
	iocb_cmd->ulpBdeCount = 1;
	iocb_cmd->ulpLe = 1;
386
	fcp_cmnd->fcpDl = be32_to_cpu(scsi_bufflen(scsi_cmnd));
已提交
387 388 389
	return 0;
}

390 391 392 393 394 395 396 397 398
static void
lpfc_scsi_unprep_dma_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * psb)
{
	/*
	 * There are only two special cases to consider.  (1) the scsi command
	 * requested scatter-gather usage or (2) the scsi command allocated
	 * a request buffer, but did not request use_sg.  There is a third
	 * case, but it does not require resource deallocation.
	 */
399 400
	if (psb->seg_cnt > 0)
		scsi_dma_unmap(psb->pCmd);
401 402
}

已提交
403
static void
J
James Smart 已提交
404 405
lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
		    struct lpfc_iocbq *rsp_iocb)
已提交
406 407 408 409
{
	struct scsi_cmnd *cmnd = lpfc_cmd->pCmd;
	struct fcp_cmnd *fcpcmd = lpfc_cmd->fcp_cmnd;
	struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
J
James Smart 已提交
410
	struct lpfc_hba *phba = vport->phba;
411
	uint32_t fcpi_parm = rsp_iocb->iocb.un.fcpi.fcpi_parm;
412
	uint32_t vpi = vport->vpi;
已提交
413 414
	uint32_t resp_info = fcprsp->rspStatus2;
	uint32_t scsi_status = fcprsp->rspStatus3;
415
	uint32_t *lp;
已提交
416 417
	uint32_t host_status = DID_OK;
	uint32_t rsplen = 0;
418
	uint32_t logit = LOG_FCP | LOG_FCP_ERROR;
已提交
419 420 421 422 423 424 425 426 427 428 429

	/*
	 *  If this is a task management command, there is no
	 *  scsi packet associated with this lpfc_cmd.  The driver
	 *  consumes it.
	 */
	if (fcpcmd->fcpCntl2) {
		scsi_status = 0;
		goto out;
	}

430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
	if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) {
		uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen);
		if (snslen > SCSI_SENSE_BUFFERSIZE)
			snslen = SCSI_SENSE_BUFFERSIZE;

		if (resp_info & RSP_LEN_VALID)
		  rsplen = be32_to_cpu(fcprsp->rspRspLen);
		memcpy(cmnd->sense_buffer, &fcprsp->rspInfo0 + rsplen, snslen);
	}
	lp = (uint32_t *)cmnd->sense_buffer;

	if (!scsi_status && (resp_info & RESID_UNDER))
		logit = LOG_FCP;

	lpfc_printf_log(phba, KERN_WARNING, logit,
445
			"%d (%d):0730 FCP command x%x failed: x%x SNS x%x x%x "
446
			"Data: x%x x%x x%x x%x x%x\n",
447
			phba->brd_no, vpi, cmnd->cmnd[0], scsi_status,
448
			be32_to_cpu(*lp), be32_to_cpu(*(lp + 3)), resp_info,
已提交
449 450 451 452 453 454 455 456 457 458 459 460 461 462
			be32_to_cpu(fcprsp->rspResId),
			be32_to_cpu(fcprsp->rspSnsLen),
			be32_to_cpu(fcprsp->rspRspLen),
			fcprsp->rspInfo3);

	if (resp_info & RSP_LEN_VALID) {
		rsplen = be32_to_cpu(fcprsp->rspRspLen);
		if ((rsplen != 0 && rsplen != 4 && rsplen != 8) ||
		    (fcprsp->rspInfo3 != RSP_NO_FAILURE)) {
			host_status = DID_ERROR;
			goto out;
		}
	}

463
	scsi_set_resid(cmnd, 0);
已提交
464
	if (resp_info & RESID_UNDER) {
465
		scsi_set_resid(cmnd, be32_to_cpu(fcprsp->rspResId));
已提交
466 467

		lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
468 469 470
				"%d (%d):0716 FCP Read Underrun, expected %d, "
				"residual %d Data: x%x x%x x%x\n",
				phba->brd_no, vpi, be32_to_cpu(fcpcmd->fcpDl),
471
				scsi_get_resid(cmnd), fcpi_parm, cmnd->cmnd[0],
472
				cmnd->underflow);
已提交
473

474 475 476 477 478 479 480
		/*
		 * If there is an under run check if under run reported by
		 * storage array is same as the under run reported by HBA.
		 * If this is not same, there is a dropped frame.
		 */
		if ((cmnd->sc_data_direction == DMA_FROM_DEVICE) &&
			fcpi_parm &&
481
			(scsi_get_resid(cmnd) != fcpi_parm)) {
482
			lpfc_printf_log(phba, KERN_WARNING,
483 484 485 486 487
					LOG_FCP | LOG_FCP_ERROR,
					"%d (%d):0735 FCP Read Check Error "
					"and Underrun Data: x%x x%x x%x x%x\n",
					phba->brd_no, vpi,
					be32_to_cpu(fcpcmd->fcpDl),
488 489 490
					scsi_get_resid(cmnd), fcpi_parm,
					cmnd->cmnd[0]);
			scsi_set_resid(cmnd, scsi_bufflen(cmnd));
491 492
			host_status = DID_ERROR;
		}
已提交
493 494 495 496 497 498 499 500
		/*
		 * The cmnd->underflow is the minimum number of bytes that must
		 * be transfered for this command.  Provided a sense condition
		 * is not present, make sure the actual amount transferred is at
		 * least the underflow value or fail.
		 */
		if (!(resp_info & SNS_LEN_VALID) &&
		    (scsi_status == SAM_STAT_GOOD) &&
501 502
		    (scsi_bufflen(cmnd) - scsi_get_resid(cmnd)
		     < cmnd->underflow)) {
已提交
503
			lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
504
					"%d (%d):0717 FCP command x%x residual "
已提交
505
					"underrun converted to error "
506 507
					"Data: x%x x%x x%x\n",
					phba->brd_no, vpi, cmnd->cmnd[0],
508
					scsi_bufflen(cmnd),
509
					scsi_get_resid(cmnd), cmnd->underflow);
已提交
510 511 512 513
			host_status = DID_ERROR;
		}
	} else if (resp_info & RESID_OVER) {
		lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
514
				"%d (%d):0720 FCP command x%x residual "
已提交
515
				"overrun error. Data: x%x x%x \n",
516
				phba->brd_no, vpi, cmnd->cmnd[0],
517
				scsi_bufflen(cmnd), scsi_get_resid(cmnd));
已提交
518 519 520 521 522 523 524 525
		host_status = DID_ERROR;

	/*
	 * Check SLI validation that all the transfer was actually done
	 * (fcpi_parm should be zero). Apply check only to reads.
	 */
	} else if ((scsi_status == SAM_STAT_GOOD) && fcpi_parm &&
			(cmnd->sc_data_direction == DMA_FROM_DEVICE)) {
526
		lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_FCP_ERROR,
527 528 529 530 531 532
				"%d (%d):0734 FCP Read Check Error Data: "
				"x%x x%x x%x x%x\n",
				phba->brd_no, vpi,
				be32_to_cpu(fcpcmd->fcpDl),
				be32_to_cpu(fcprsp->rspResId),
				fcpi_parm, cmnd->cmnd[0]);
已提交
533
		host_status = DID_ERROR;
534
		scsi_set_resid(cmnd, scsi_bufflen(cmnd));
已提交
535 536 537 538 539 540 541 542 543 544 545 546
	}

 out:
	cmnd->result = ScsiResult(host_status, scsi_status);
}

static void
lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
			struct lpfc_iocbq *pIocbOut)
{
	struct lpfc_scsi_buf *lpfc_cmd =
		(struct lpfc_scsi_buf *) pIocbIn->context1;
J
James Smart 已提交
547
	struct lpfc_vport      *vport = pIocbIn->vport;
已提交
548 549 550
	struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
	struct lpfc_nodelist *pnode = rdata->pnode;
	struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
551 552 553
	uint32_t vpi = (lpfc_cmd->cur_iocbq.vport
			? lpfc_cmd->cur_iocbq.vport->vpi
			: 0);
554 555 556
	int result;
	struct scsi_device *sdev, *tmp_sdev;
	int depth = 0;
已提交
557 558 559 560 561 562 563 564 565 566 567 568

	lpfc_cmd->result = pIocbOut->iocb.un.ulpWord[4];
	lpfc_cmd->status = pIocbOut->iocb.ulpStatus;

	if (lpfc_cmd->status) {
		if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
		    (lpfc_cmd->result & IOERR_DRVR_MASK))
			lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
		else if (lpfc_cmd->status >= IOSTAT_CNT)
			lpfc_cmd->status = IOSTAT_DEFAULT;

		lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
569 570 571 572 573 574 575
				"%d (%d):0729 FCP cmd x%x failed <%d/%d> "
				"status: x%x result: x%x Data: x%x x%x\n",
				phba->brd_no, vpi, cmd->cmnd[0],
				cmd->device ? cmd->device->id : 0xffff,
				cmd->device ? cmd->device->lun : 0xffff,
				lpfc_cmd->status, lpfc_cmd->result,
				pIocbOut->iocb.ulpContext,
已提交
576 577 578 579 580
				lpfc_cmd->cur_iocbq.iocb.ulpIoTag);

		switch (lpfc_cmd->status) {
		case IOSTAT_FCP_RSP_ERROR:
			/* Call FCP RSP handler to determine result */
J
James Smart 已提交
581
			lpfc_handle_fcp_err(vport, lpfc_cmd, pIocbOut);
已提交
582 583 584 585 586
			break;
		case IOSTAT_NPORT_BSY:
		case IOSTAT_FABRIC_BSY:
			cmd->result = ScsiResult(DID_BUS_BUSY, 0);
			break;
587 588 589 590 591 592 593
		case IOSTAT_LOCAL_REJECT:
			if (lpfc_cmd->result == RJT_UNAVAIL_PERM ||
			    lpfc_cmd->result == IOERR_NO_RESOURCES ||
			    lpfc_cmd->result == RJT_LOGIN_REQUIRED) {
				cmd->result = ScsiResult(DID_REQUEUE, 0);
			break;
		} /* else: fall through */
已提交
594 595 596 597 598
		default:
			cmd->result = ScsiResult(DID_ERROR, 0);
			break;
		}

599 600 601
		if ((pnode == NULL )
		    || (pnode->nlp_state != NLP_STE_MAPPED_NODE))
			cmd->result = ScsiResult(DID_BUS_BUSY, SAM_STAT_BUSY);
已提交
602 603 604 605 606 607 608 609
	} else {
		cmd->result = ScsiResult(DID_OK, 0);
	}

	if (cmd->result || lpfc_cmd->fcp_rsp->rspSnsLen) {
		uint32_t *lp = (uint32_t *)cmd->sense_buffer;

		lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
610 611 612
				"%d (%d):0710 Iodone <%d/%d> cmd %p, error "
				"x%x SNS x%x x%x Data: x%x x%x\n",
				phba->brd_no, vpi, cmd->device->id,
已提交
613
				cmd->device->lun, cmd, cmd->result,
614 615
				*lp, *(lp + 3), cmd->retries,
				scsi_get_resid(cmd));
已提交
616 617
	}

618 619
	result = cmd->result;
	sdev = cmd->device;
620
	lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
621 622
	cmd->scsi_done(cmd);

623 624 625 626 627
	if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
		lpfc_release_scsi_buf(phba, lpfc_cmd);
		return;
	}

628 629 630 631

	if (!result)
		lpfc_rampup_queue_depth(phba, sdev);

632
	if (!result && pnode != NULL &&
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
	   ((jiffies - pnode->last_ramp_up_time) >
		LPFC_Q_RAMP_UP_INTERVAL * HZ) &&
	   ((jiffies - pnode->last_q_full_time) >
		LPFC_Q_RAMP_UP_INTERVAL * HZ) &&
	   (phba->cfg_lun_queue_depth > sdev->queue_depth)) {
		shost_for_each_device(tmp_sdev, sdev->host) {
			if (phba->cfg_lun_queue_depth > tmp_sdev->queue_depth) {
				if (tmp_sdev->id != sdev->id)
					continue;
				if (tmp_sdev->ordered_tags)
					scsi_adjust_queue_depth(tmp_sdev,
						MSG_ORDERED_TAG,
						tmp_sdev->queue_depth+1);
				else
					scsi_adjust_queue_depth(tmp_sdev,
						MSG_SIMPLE_TAG,
						tmp_sdev->queue_depth+1);

				pnode->last_ramp_up_time = jiffies;
			}
		}
	}

	/*
	 * Check for queue full.  If the lun is reporting queue full, then
	 * back off the lun queue depth to prevent target overloads.
	 */
660
	if (result == SAM_STAT_TASK_SET_FULL && pnode != NULL) {
661 662 663 664 665 666 667 668 669
		pnode->last_q_full_time = jiffies;

		shost_for_each_device(tmp_sdev, sdev->host) {
			if (tmp_sdev->id != sdev->id)
				continue;
			depth = scsi_track_queue_full(tmp_sdev,
					tmp_sdev->queue_depth - 1);
		}
		/*
J
James Smart 已提交
670
		 * The queue depth cannot be lowered any more.
671 672 673 674 675 676 677 678 679
		 * Modify the returned error code to store
		 * the final depth value set by
		 * scsi_track_queue_full.
		 */
		if (depth == -1)
			depth = sdev->host->cmd_per_lun;

		if (depth) {
			lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
680 681 682
					"%d (%d):0711 detected queue full - "
					"lun queue depth  adjusted to %d.\n",
					phba->brd_no, vpi, depth);
683 684 685
		}
	}

686
	lpfc_release_scsi_buf(phba, lpfc_cmd);
已提交
687 688 689
}

static void
J
James Smart 已提交
690 691
lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
		    struct lpfc_nodelist *pnode)
已提交
692
{
J
James Smart 已提交
693
	struct lpfc_hba *phba = vport->phba;
已提交
694 695 696 697 698 699 700
	struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
	struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
	IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
	struct lpfc_iocbq *piocbq = &(lpfc_cmd->cur_iocbq);
	int datadir = scsi_cmnd->sc_data_direction;

	lpfc_cmd->fcp_rsp->rspSnsLen = 0;
701 702
	/* clear task management bits */
	lpfc_cmd->fcp_cmnd->fcpCntl2 = 0;
已提交
703

704 705
	int_to_scsilun(lpfc_cmd->pCmd->device->lun,
			&lpfc_cmd->fcp_cmnd->fcp_lun);
已提交
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729

	memcpy(&fcp_cmnd->fcpCdb[0], scsi_cmnd->cmnd, 16);

	if (scsi_cmnd->device->tagged_supported) {
		switch (scsi_cmnd->tag) {
		case HEAD_OF_QUEUE_TAG:
			fcp_cmnd->fcpCntl1 = HEAD_OF_Q;
			break;
		case ORDERED_QUEUE_TAG:
			fcp_cmnd->fcpCntl1 = ORDERED_Q;
			break;
		default:
			fcp_cmnd->fcpCntl1 = SIMPLE_Q;
			break;
		}
	} else
		fcp_cmnd->fcpCntl1 = 0;

	/*
	 * There are three possibilities here - use scatter-gather segment, use
	 * the single mapping, or neither.  Start the lpfc command prep by
	 * bumping the bpl beyond the fcp_cmnd and fcp_rsp regions to the first
	 * data bde entry.
	 */
730
	if (scsi_sg_count(scsi_cmnd)) {
已提交
731 732 733 734 735 736 737 738 739
		if (datadir == DMA_TO_DEVICE) {
			iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
			iocb_cmd->un.fcpi.fcpi_parm = 0;
			iocb_cmd->ulpPU = 0;
			fcp_cmnd->fcpCntl3 = WRITE_DATA;
			phba->fc4OutputRequests++;
		} else {
			iocb_cmd->ulpCommand = CMD_FCP_IREAD64_CR;
			iocb_cmd->ulpPU = PARM_READ_CHECK;
740
			iocb_cmd->un.fcpi.fcpi_parm = scsi_bufflen(scsi_cmnd);
已提交
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
			fcp_cmnd->fcpCntl3 = READ_DATA;
			phba->fc4InputRequests++;
		}
	} else {
		iocb_cmd->ulpCommand = CMD_FCP_ICMND64_CR;
		iocb_cmd->un.fcpi.fcpi_parm = 0;
		iocb_cmd->ulpPU = 0;
		fcp_cmnd->fcpCntl3 = 0;
		phba->fc4ControlRequests++;
	}

	/*
	 * Finish initializing those IOCB fields that are independent
	 * of the scsi_cmnd request_buffer
	 */
	piocbq->iocb.ulpContext = pnode->nlp_rpi;
	if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE)
		piocbq->iocb.ulpFCP2Rcvy = 1;

	piocbq->iocb.ulpClass = (pnode->nlp_fcp_info & 0x0f);
	piocbq->context1  = lpfc_cmd;
	piocbq->iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
	piocbq->iocb.ulpTimeout = lpfc_cmd->timeout;
J
James Smart 已提交
764
	piocbq->vport = vport;
已提交
765 766 767
}

static int
J
James Smart 已提交
768
lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
已提交
769
			     struct lpfc_scsi_buf *lpfc_cmd,
770
			     unsigned int lun,
已提交
771 772 773 774 775
			     uint8_t task_mgmt_cmd)
{
	struct lpfc_iocbq *piocbq;
	IOCB_t *piocb;
	struct fcp_cmnd *fcp_cmnd;
776
	struct lpfc_rport_data *rdata = lpfc_cmd->rdata;
已提交
777 778
	struct lpfc_nodelist *ndlp = rdata->pnode;

779
	if ((ndlp == NULL) || (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
已提交
780 781 782 783
		return 0;
	}

	piocbq = &(lpfc_cmd->cur_iocbq);
J
James Smart 已提交
784 785
	piocbq->vport = vport;

已提交
786 787 788
	piocb = &piocbq->iocb;

	fcp_cmnd = lpfc_cmd->fcp_cmnd;
789
	int_to_scsilun(lun, &lpfc_cmd->fcp_cmnd->fcp_lun);
已提交
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
	fcp_cmnd->fcpCntl2 = task_mgmt_cmd;

	piocb->ulpCommand = CMD_FCP_ICMND64_CR;

	piocb->ulpContext = ndlp->nlp_rpi;
	if (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) {
		piocb->ulpFCP2Rcvy = 1;
	}
	piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f);

	/* ulpTimeout is only one byte */
	if (lpfc_cmd->timeout > 0xff) {
		/*
		 * Do not timeout the command at the firmware level.
		 * The driver will provide the timeout mechanism.
		 */
		piocb->ulpTimeout = 0;
	} else {
		piocb->ulpTimeout = lpfc_cmd->timeout;
	}

J
James Smart 已提交
811
	return 1;
已提交
812 813
}

814 815 816 817 818 819 820 821 822 823 824 825
static void
lpfc_tskmgmt_def_cmpl(struct lpfc_hba *phba,
			struct lpfc_iocbq *cmdiocbq,
			struct lpfc_iocbq *rspiocbq)
{
	struct lpfc_scsi_buf *lpfc_cmd =
		(struct lpfc_scsi_buf *) cmdiocbq->context1;
	if (lpfc_cmd)
		lpfc_release_scsi_buf(phba, lpfc_cmd);
	return;
}

已提交
826
static int
J
James Smart 已提交
827
lpfc_scsi_tgt_reset(struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_vport *vport,
828 829
		    unsigned  tgt_id, unsigned int lun,
		    struct lpfc_rport_data *rdata)
已提交
830
{
J
James Smart 已提交
831
	struct lpfc_hba   *phba = vport->phba;
已提交
832
	struct lpfc_iocbq *iocbq;
833
	struct lpfc_iocbq *iocbqrsp;
已提交
834 835
	int ret;

J
James Smart 已提交
836 837 838
	if (!rdata->pnode)
		return FAILED;

839
	lpfc_cmd->rdata = rdata;
J
James Smart 已提交
840
	ret = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun,
841
					   FCP_TARGET_RESET);
已提交
842 843 844 845
	if (!ret)
		return FAILED;

	iocbq = &lpfc_cmd->cur_iocbq;
846 847
	iocbqrsp = lpfc_sli_get_iocbq(phba);

已提交
848 849 850
	if (!iocbqrsp)
		return FAILED;

851 852
	/* Issue Target Reset to TGT <num> */
	lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
853
			"%d (%d):0702 Issue Target Reset to TGT %d "
854
			"Data: x%x x%x\n",
855 856
			phba->brd_no, vport->vpi, tgt_id,
			rdata->pnode->nlp_rpi, rdata->pnode->nlp_flag);
857

858 859 860
	ret = lpfc_sli_issue_iocb_wait(phba,
				       &phba->sli.ring[phba->sli.fcp_ring],
				       iocbq, iocbqrsp, lpfc_cmd->timeout);
已提交
861
	if (ret != IOCB_SUCCESS) {
862 863
		if (ret == IOCB_TIMEDOUT)
			iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
已提交
864 865 866 867 868 869 870 871 872 873
		lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
	} else {
		ret = SUCCESS;
		lpfc_cmd->result = iocbqrsp->iocb.un.ulpWord[4];
		lpfc_cmd->status = iocbqrsp->iocb.ulpStatus;
		if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
			(lpfc_cmd->result & IOERR_DRVR_MASK))
				lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
	}

874
	lpfc_sli_release_iocbq(phba, iocbqrsp);
已提交
875 876 877 878 879 880
	return ret;
}

const char *
lpfc_info(struct Scsi_Host *host)
{
J
James Smart 已提交
881 882
	struct lpfc_vport *vport = (struct lpfc_vport *) host->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
	int len;
	static char  lpfcinfobuf[384];

	memset(lpfcinfobuf,0,384);
	if (phba && phba->pcidev){
		strncpy(lpfcinfobuf, phba->ModelDesc, 256);
		len = strlen(lpfcinfobuf);
		snprintf(lpfcinfobuf + len,
			384-len,
			" on PCI bus %02x device %02x irq %d",
			phba->pcidev->bus->number,
			phba->pcidev->devfn,
			phba->pcidev->irq);
		len = strlen(lpfcinfobuf);
		if (phba->Port[0]) {
			snprintf(lpfcinfobuf + len,
				 384-len,
				 " port %s",
				 phba->Port);
		}
	}
	return lpfcinfobuf;
}

907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
static __inline__ void lpfc_poll_rearm_timer(struct lpfc_hba * phba)
{
	unsigned long  poll_tmo_expires =
		(jiffies + msecs_to_jiffies(phba->cfg_poll_tmo));

	if (phba->sli.ring[LPFC_FCP_RING].txcmplq_cnt)
		mod_timer(&phba->fcp_poll_timer,
			  poll_tmo_expires);
}

void lpfc_poll_start_timer(struct lpfc_hba * phba)
{
	lpfc_poll_rearm_timer(phba);
}

void lpfc_poll_timeout(unsigned long ptr)
{
J
James Smart 已提交
924
	struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
925 926 927 928 929 930 931 932

	if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
		lpfc_sli_poll_fcp_ring (phba);
		if (phba->cfg_poll & DISABLE_FCP_RING_INT)
			lpfc_poll_rearm_timer(phba);
	}
}

已提交
933 934 935
static int
lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
{
J
James Smart 已提交
936 937 938 939
	struct Scsi_Host  *shost = cmnd->device->host;
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	struct lpfc_sli   *psli = &phba->sli;
已提交
940 941
	struct lpfc_rport_data *rdata = cmnd->device->hostdata;
	struct lpfc_nodelist *ndlp = rdata->pnode;
942
	struct lpfc_scsi_buf *lpfc_cmd;
943 944
	struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
	int err;
已提交
945

946 947 948
	err = fc_remote_port_chkready(rport);
	if (err) {
		cmnd->result = err;
已提交
949 950 951 952
		goto out_fail_command;
	}

	/*
953 954
	 * Catch race where our node has transitioned, but the
	 * transport is still transitioning.
已提交
955
	 */
956 957 958
	if (!ndlp) {
		cmnd->result = ScsiResult(DID_BUS_BUSY, 0);
		goto out_fail_command;
已提交
959
	}
960
	lpfc_cmd = lpfc_get_scsi_buf(phba);
已提交
961
	if (lpfc_cmd == NULL) {
962 963
		lpfc_adjust_queue_depth(phba);

964
		lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
965 966 967
				"%d (%d):0707 driver's buffer pool is empty, "
				"IO busied\n",
				phba->brd_no, vport->vpi);
已提交
968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
		goto out_host_busy;
	}

	/*
	 * Store the midlayer's command structure for the completion phase
	 * and complete the command initialization.
	 */
	lpfc_cmd->pCmd  = cmnd;
	lpfc_cmd->rdata = rdata;
	lpfc_cmd->timeout = 0;
	cmnd->host_scribble = (unsigned char *)lpfc_cmd;
	cmnd->scsi_done = done;

	err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
	if (err)
		goto out_host_busy_free_buf;

J
James Smart 已提交
985
	lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp);
已提交
986 987

	err = lpfc_sli_issue_iocb(phba, &phba->sli.ring[psli->fcp_ring],
988
				  &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
已提交
989 990
	if (err)
		goto out_host_busy_free_buf;
991 992 993 994 995 996 997

	if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
		lpfc_sli_poll_fcp_ring(phba);
		if (phba->cfg_poll & DISABLE_FCP_RING_INT)
			lpfc_poll_rearm_timer(phba);
	}

已提交
998 999 1000
	return 0;

 out_host_busy_free_buf:
1001
	lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
1002
	lpfc_release_scsi_buf(phba, lpfc_cmd);
已提交
1003 1004 1005 1006 1007 1008 1009 1010
 out_host_busy:
	return SCSI_MLQUEUE_HOST_BUSY;

 out_fail_command:
	done(cmnd);
	return 0;
}

1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
static void
lpfc_block_error_handler(struct scsi_cmnd *cmnd)
{
	struct Scsi_Host *shost = cmnd->device->host;
	struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));

	spin_lock_irq(shost->host_lock);
	while (rport->port_state == FC_PORTSTATE_BLOCKED) {
		spin_unlock_irq(shost->host_lock);
		msleep(1000);
		spin_lock_irq(shost->host_lock);
	}
	spin_unlock_irq(shost->host_lock);
	return;
}
1026

已提交
1027
static int
1028
lpfc_abort_handler(struct scsi_cmnd *cmnd)
已提交
1029
{
J
James Smart 已提交
1030 1031 1032
	struct Scsi_Host  *shost = cmnd->device->host;
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
1033
	struct lpfc_sli_ring *pring = &phba->sli.ring[phba->sli.fcp_ring];
1034 1035
	struct lpfc_iocbq *iocb;
	struct lpfc_iocbq *abtsiocb;
已提交
1036 1037 1038
	struct lpfc_scsi_buf *lpfc_cmd;
	IOCB_t *cmd, *icmd;
	unsigned int loop_count = 0;
1039
	int ret = SUCCESS;
已提交
1040

1041
	lpfc_block_error_handler(cmnd);
1042 1043
	lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble;
	BUG_ON(!lpfc_cmd);
已提交
1044

1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
	/*
	 * If pCmd field of the corresponding lpfc_scsi_buf structure
	 * points to a different SCSI command, then the driver has
	 * already completed this command, but the midlayer did not
	 * see the completion before the eh fired.  Just return
	 * SUCCESS.
	 */
	iocb = &lpfc_cmd->cur_iocbq;
	if (lpfc_cmd->pCmd != cmnd)
		goto out;
已提交
1055

1056
	BUG_ON(iocb->context1 != lpfc_cmd);
已提交
1057

1058 1059 1060
	abtsiocb = lpfc_sli_get_iocbq(phba);
	if (abtsiocb == NULL) {
		ret = FAILED;
已提交
1061 1062 1063 1064
		goto out;
	}

	/*
1065 1066 1067
	 * The scsi command can not be in txq and it is in flight because the
	 * pCmd is still pointig at the SCSI command we have to abort. There
	 * is no need to search the txcmplq. Just send an abort to the FW.
已提交
1068 1069
	 */

1070 1071 1072 1073 1074
	cmd = &iocb->iocb;
	icmd = &abtsiocb->iocb;
	icmd->un.acxri.abortType = ABORT_TYPE_ABTS;
	icmd->un.acxri.abortContextTag = cmd->ulpContext;
	icmd->un.acxri.abortIoTag = cmd->ulpIoTag;
已提交
1075

1076 1077
	icmd->ulpLe = 1;
	icmd->ulpClass = cmd->ulpClass;
J
James Smart 已提交
1078
	if (lpfc_is_link_up(phba))
1079 1080 1081
		icmd->ulpCommand = CMD_ABORT_XRI_CN;
	else
		icmd->ulpCommand = CMD_CLOSE_XRI_CN;
已提交
1082

1083
	abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
J
James Smart 已提交
1084
	abtsiocb->vport = vport;
1085 1086 1087 1088 1089
	if (lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0) == IOCB_ERROR) {
		lpfc_sli_release_iocbq(phba, abtsiocb);
		ret = FAILED;
		goto out;
	}
已提交
1090

1091 1092 1093
	if (phba->cfg_poll & DISABLE_FCP_RING_INT)
		lpfc_sli_poll_fcp_ring (phba);

1094 1095 1096
	/* Wait for abort to complete */
	while (lpfc_cmd->pCmd == cmnd)
	{
1097 1098 1099
		if (phba->cfg_poll & DISABLE_FCP_RING_INT)
			lpfc_sli_poll_fcp_ring (phba);

J
James Smart 已提交
1100
		schedule_timeout_uninterruptible(LPFC_ABORT_WAIT * HZ);
1101
		if (++loop_count
1102
		    > (2 * phba->cfg_devloss_tmo)/LPFC_ABORT_WAIT)
1103 1104
			break;
	}
已提交
1105

1106 1107 1108
	if (lpfc_cmd->pCmd == cmnd) {
		ret = FAILED;
		lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1109 1110 1111 1112 1113 1114
				"%d (%d):0748 abort handler timed out waiting "
				"for abort to complete: ret %#x, ID %d, "
				"LUN %d, snum %#lx\n",
				phba->brd_no, vport->vpi, ret,
				cmnd->device->id, cmnd->device->lun,
				cmnd->serial_number);
已提交
1115 1116 1117 1118
	}

 out:
	lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
1119
			"%d (%d):0749 SCSI Layer I/O Abort Request "
1120
			"Status x%x ID %d LUN %d snum %#lx\n",
1121
			phba->brd_no, vport->vpi, ret, cmnd->device->id,
1122
			cmnd->device->lun, cmnd->serial_number);
已提交
1123

1124
	return ret;
1125 1126
}

已提交
1127
static int
1128
lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
已提交
1129
{
J
James Smart 已提交
1130 1131 1132
	struct Scsi_Host  *shost = cmnd->device->host;
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
1133 1134
	struct lpfc_scsi_buf *lpfc_cmd;
	struct lpfc_iocbq *iocbq, *iocbqrsp;
已提交
1135 1136
	struct lpfc_rport_data *rdata = cmnd->device->hostdata;
	struct lpfc_nodelist *pnode = rdata->pnode;
1137
	uint32_t cmd_result = 0, cmd_status = 0;
已提交
1138
	int ret = FAILED;
1139
	int iocb_status = IOCB_SUCCESS;
已提交
1140 1141
	int cnt, loopcnt;

1142
	lpfc_block_error_handler(cmnd);
J
James Smart 已提交
1143
	loopcnt = 0;
已提交
1144 1145
	/*
	 * If target is not in a MAPPED state, delay the reset until
1146
	 * target is rediscovered or devloss timeout expires.
已提交
1147
	 */
1148
	while (1) {
已提交
1149
		if (!pnode)
1150
			goto out;
已提交
1151 1152

		if (pnode->nlp_state != NLP_STE_MAPPED_NODE) {
1153
			schedule_timeout_uninterruptible(msecs_to_jiffies(500));
J
James Smart 已提交
1154 1155 1156 1157 1158
			loopcnt++;
			rdata = cmnd->device->hostdata;
			if (!rdata ||
				(loopcnt > ((phba->cfg_devloss_tmo * 2) + 1))) {
				lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1159 1160 1161 1162
						"%d (%d):0721 LUN Reset rport "
						"failure: cnt x%x rdata x%p\n",
						phba->brd_no, vport->vpi,
						loopcnt, rdata);
J
James Smart 已提交
1163 1164 1165 1166
				goto out;
			}
			pnode = rdata->pnode;
			if (!pnode)
1167
				goto out;
已提交
1168
		}
J
James Smart 已提交
1169
		if (pnode->nlp_state == NLP_STE_MAPPED_NODE)
已提交
1170 1171 1172
			break;
	}

J
James Smart 已提交
1173
	lpfc_cmd = lpfc_get_scsi_buf(phba);
已提交
1174 1175 1176 1177
	if (lpfc_cmd == NULL)
		goto out;

	lpfc_cmd->timeout = 60;
1178
	lpfc_cmd->rdata = rdata;
已提交
1179

J
James Smart 已提交
1180
	ret = lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, cmnd->device->lun,
1181
					   FCP_TARGET_RESET);
已提交
1182 1183 1184 1185 1186 1187
	if (!ret)
		goto out_free_scsi_buf;

	iocbq = &lpfc_cmd->cur_iocbq;

	/* get a buffer for this IOCB command response */
1188
	iocbqrsp = lpfc_sli_get_iocbq(phba);
已提交
1189 1190 1191
	if (iocbqrsp == NULL)
		goto out_free_scsi_buf;

1192
	lpfc_printf_log(phba, KERN_INFO, LOG_FCP,
1193 1194 1195
			"%d (%d):0703 Issue target reset to TGT %d LUN %d "
			"rpi x%x nlp_flag x%x\n",
			phba->brd_no, vport->vpi, cmnd->device->id,
1196 1197
			cmnd->device->lun, pnode->nlp_rpi, pnode->nlp_flag);

1198
	iocb_status = lpfc_sli_issue_iocb_wait(phba,
1199 1200
				       &phba->sli.ring[phba->sli.fcp_ring],
				       iocbq, iocbqrsp, lpfc_cmd->timeout);
已提交
1201

1202 1203 1204 1205 1206 1207 1208
	if (iocb_status == IOCB_TIMEDOUT)
		iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;

	if (iocb_status == IOCB_SUCCESS)
		ret = SUCCESS;
	else
		ret = iocb_status;
1209 1210 1211 1212 1213

	cmd_result = iocbqrsp->iocb.un.ulpWord[4];
	cmd_status = iocbqrsp->iocb.ulpStatus;

	lpfc_sli_release_iocbq(phba, iocbqrsp);
已提交
1214 1215

	/*
1216
	 * All outstanding txcmplq I/Os should have been aborted by the device.
已提交
1217 1218 1219
	 * Unfortunately, some targets do not abide by this forcing the driver
	 * to double check.
	 */
1220 1221 1222 1223 1224 1225 1226 1227
	cnt = lpfc_sli_sum_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring],
				cmnd->device->id, cmnd->device->lun,
				LPFC_CTX_LUN);
	if (cnt)
		lpfc_sli_abort_iocb(phba,
				    &phba->sli.ring[phba->sli.fcp_ring],
				    cmnd->device->id, cmnd->device->lun,
				    0, LPFC_CTX_LUN);
已提交
1228
	loopcnt = 0;
1229
	while(cnt) {
1230
		schedule_timeout_uninterruptible(LPFC_RESET_WAIT*HZ);
已提交
1231 1232

		if (++loopcnt
1233
		    > (2 * phba->cfg_devloss_tmo)/LPFC_RESET_WAIT)
已提交
1234
			break;
1235 1236 1237 1238 1239

		cnt = lpfc_sli_sum_iocb(phba,
					&phba->sli.ring[phba->sli.fcp_ring],
					cmnd->device->id, cmnd->device->lun,
					LPFC_CTX_LUN);
已提交
1240 1241 1242
	}

	if (cnt) {
1243
		lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1244 1245 1246
				"%d (%d):0719 device reset I/O flush failure: "
				"cnt x%x\n",
				phba->brd_no, vport->vpi, cnt);
1247
		ret = FAILED;
已提交
1248 1249 1250
	}

out_free_scsi_buf:
1251 1252 1253
	if (iocb_status != IOCB_TIMEDOUT) {
		lpfc_release_scsi_buf(phba, lpfc_cmd);
	}
已提交
1254
	lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1255
			"%d (%d):0713 SCSI layer issued device reset (%d, %d) "
1256
			"return x%x status x%x result x%x\n",
1257 1258
			phba->brd_no, vport->vpi, cmnd->device->id,
			cmnd->device->lun, ret, cmd_status, cmd_result);
1259

已提交
1260 1261 1262 1263
out:
	return ret;
}

1264
static int
1265
lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
已提交
1266
{
J
James Smart 已提交
1267 1268 1269
	struct Scsi_Host  *shost = cmnd->device->host;
	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
1270 1271 1272 1273
	struct lpfc_nodelist *ndlp = NULL;
	int match;
	int ret = FAILED, i, err_count = 0;
	int cnt, loopcnt;
1274
	struct lpfc_scsi_buf * lpfc_cmd;
已提交
1275

1276
	lpfc_block_error_handler(cmnd);
1277

1278
	lpfc_cmd = lpfc_get_scsi_buf(phba);
已提交
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
	if (lpfc_cmd == NULL)
		goto out;

	/* The lpfc_cmd storage is reused.  Set all loop invariants. */
	lpfc_cmd->timeout = 60;

	/*
	 * Since the driver manages a single bus device, reset all
	 * targets known to the driver.  Should any target reset
	 * fail, this routine returns failure to the midlayer.
	 */
1290
	for (i = 0; i < LPFC_MAX_TARGET; i++) {
1291
		/* Search for mapped node by target ID */
已提交
1292
		match = 0;
J
James Smart 已提交
1293 1294
		spin_lock_irq(shost->host_lock);
		list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
1295 1296 1297
			if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
			    i == ndlp->nlp_sid &&
			    ndlp->rport) {
已提交
1298 1299 1300 1301
				match = 1;
				break;
			}
		}
J
James Smart 已提交
1302
		spin_unlock_irq(shost->host_lock);
已提交
1303 1304 1305
		if (!match)
			continue;

J
James Smart 已提交
1306 1307
		ret = lpfc_scsi_tgt_reset(lpfc_cmd, vport, i,
					  cmnd->device->lun,
1308
					  ndlp->rport->dd_data);
已提交
1309
		if (ret != SUCCESS) {
1310
			lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1311 1312 1313
					"%d (%d):0700 Bus Reset on target %d "
					"failed\n",
					phba->brd_no, vport->vpi, i);
已提交
1314
			err_count++;
1315
			break;
已提交
1316 1317 1318
		}
	}

1319 1320 1321
	if (ret != IOCB_TIMEDOUT)
		lpfc_release_scsi_buf(phba, lpfc_cmd);

1322 1323
	if (err_count == 0)
		ret = SUCCESS;
1324 1325
	else
		ret = FAILED;
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336

	/*
	 * All outstanding txcmplq I/Os should have been aborted by
	 * the targets.  Unfortunately, some targets do not abide by
	 * this forcing the driver to double check.
	 */
	cnt = lpfc_sli_sum_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring],
				0, 0, LPFC_CTX_HOST);
	if (cnt)
		lpfc_sli_abort_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring],
				    0, 0, 0, LPFC_CTX_HOST);
已提交
1337
	loopcnt = 0;
1338
	while(cnt) {
1339
		schedule_timeout_uninterruptible(LPFC_RESET_WAIT*HZ);
已提交
1340 1341

		if (++loopcnt
1342
		    > (2 * phba->cfg_devloss_tmo)/LPFC_RESET_WAIT)
已提交
1343
			break;
1344 1345 1346 1347

		cnt = lpfc_sli_sum_iocb(phba,
					&phba->sli.ring[phba->sli.fcp_ring],
					0, 0, LPFC_CTX_HOST);
已提交
1348 1349 1350
	}

	if (cnt) {
1351
		lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1352 1353 1354
				"%d (%d):0715 Bus Reset I/O flush failure: "
				"cnt x%x left x%x\n",
				phba->brd_no, vport->vpi, cnt, i);
1355
		ret = FAILED;
1356
	}
已提交
1357

1358 1359 1360
	lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
			"%d (%d):0714 SCSI layer issued Bus Reset Data: x%x\n",
			phba->brd_no, vport->vpi, ret);
已提交
1361 1362 1363 1364 1365 1366 1367
out:
	return ret;
}

static int
lpfc_slave_alloc(struct scsi_device *sdev)
{
J
James Smart 已提交
1368 1369
	struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
	struct lpfc_hba   *phba = vport->phba;
已提交
1370
	struct lpfc_scsi_buf *scsi_buf = NULL;
1371
	struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
已提交
1372 1373 1374 1375
	uint32_t total = 0, i;
	uint32_t num_to_alloc = 0;
	unsigned long flags;

1376
	if (!rport || fc_remote_port_chkready(rport))
已提交
1377 1378
		return -ENXIO;

1379
	sdev->hostdata = rport->dd_data;
已提交
1380 1381 1382 1383

	/*
	 * Populate the cmds_per_lun count scsi_bufs into this host's globally
	 * available list of scsi buffers.  Don't allocate more than the
1384 1385 1386
	 * HBA limit conveyed to the midlayer via the host structure.  The
	 * formula accounts for the lun_queue_depth + error handlers + 1
	 * extra.  This list of scsi bufs exists for the lifetime of the driver.
已提交
1387 1388
	 */
	total = phba->total_scsi_bufs;
1389
	num_to_alloc = phba->cfg_lun_queue_depth + 2;
1390 1391 1392

	/* Allow some exchanges to be available always to complete discovery */
	if (total >= phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
1393
		lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
1394 1395 1396
				"%d (%d):0704 At limitation of %d "
				"preallocated command buffers\n",
				phba->brd_no, vport->vpi, total);
已提交
1397
		return 0;
1398 1399 1400 1401

	/* Allow some exchanges to be available always to complete discovery */
	} else if (total + num_to_alloc >
		phba->cfg_hba_queue_depth - LPFC_DISC_IOCB_BUFF_COUNT ) {
1402
		lpfc_printf_log(phba, KERN_WARNING, LOG_FCP,
1403 1404 1405 1406 1407
				"%d (%d):0705 Allocation request of %d "
				"command buffers will exceed max of %d.  "
				"Reducing allocation request to %d.\n",
				phba->brd_no, vport->vpi, num_to_alloc,
				phba->cfg_hba_queue_depth,
1408
				(phba->cfg_hba_queue_depth - total));
已提交
1409 1410 1411 1412
		num_to_alloc = phba->cfg_hba_queue_depth - total;
	}

	for (i = 0; i < num_to_alloc; i++) {
J
James Smart 已提交
1413
		scsi_buf = lpfc_new_scsi_buf(vport);
已提交
1414
		if (!scsi_buf) {
1415
			lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
1416 1417 1418
					"%d (%d):0706 Failed to allocate "
					"command buffer\n",
					phba->brd_no, vport->vpi);
已提交
1419 1420 1421
			break;
		}

1422
		spin_lock_irqsave(&phba->scsi_buf_list_lock, flags);
已提交
1423 1424
		phba->total_scsi_bufs++;
		list_add_tail(&scsi_buf->list, &phba->lpfc_scsi_buf_list);
1425
		spin_unlock_irqrestore(&phba->scsi_buf_list_lock, flags);
已提交
1426 1427 1428 1429 1430 1431 1432
	}
	return 0;
}

static int
lpfc_slave_configure(struct scsi_device *sdev)
{
J
James Smart 已提交
1433 1434 1435
	struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
	struct lpfc_hba   *phba = vport->phba;
	struct fc_rport   *rport = starget_to_rport(sdev->sdev_target);
已提交
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447

	if (sdev->tagged_supported)
		scsi_activate_tcq(sdev, phba->cfg_lun_queue_depth);
	else
		scsi_deactivate_tcq(sdev, phba->cfg_lun_queue_depth);

	/*
	 * Initialize the fc transport attributes for the target
	 * containing this scsi device.  Also note that the driver's
	 * target pointer is stored in the starget_data for the
	 * driver's sysfs entry point functions.
	 */
1448
	rport->dev_loss_tmo = phba->cfg_devloss_tmo;
已提交
1449

1450 1451 1452 1453 1454 1455
	if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
		lpfc_sli_poll_fcp_ring(phba);
		if (phba->cfg_poll & DISABLE_FCP_RING_INT)
			lpfc_poll_rearm_timer(phba);
	}

已提交
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
	return 0;
}

static void
lpfc_slave_destroy(struct scsi_device *sdev)
{
	sdev->hostdata = NULL;
	return;
}

1466

已提交
1467 1468 1469 1470 1471 1472
struct scsi_host_template lpfc_template = {
	.module			= THIS_MODULE,
	.name			= LPFC_DRIVER_NAME,
	.info			= lpfc_info,
	.queuecommand		= lpfc_queuecommand,
	.eh_abort_handler	= lpfc_abort_handler,
1473 1474
	.eh_device_reset_handler= lpfc_device_reset_handler,
	.eh_bus_reset_handler	= lpfc_bus_reset_handler,
已提交
1475 1476 1477
	.slave_alloc		= lpfc_slave_alloc,
	.slave_configure	= lpfc_slave_configure,
	.slave_destroy		= lpfc_slave_destroy,
1478
	.scan_finished		= lpfc_scan_finished,
已提交
1479 1480 1481 1482
	.this_id		= -1,
	.sg_tablesize		= LPFC_SG_SEG_CNT,
	.cmd_per_lun		= LPFC_CMD_PER_LUN,
	.use_clustering		= ENABLE_CLUSTERING,
J
James Smart 已提交
1483
	.shost_attrs		= lpfc_hba_attrs,
1484
	.max_sectors		= 0xFFFF,
已提交
1485
};