lael-labs/linux

drivers/message/fusion/mptbase.c+2−2

@@ -6658,13 +6658,13 @@ static int mpt_summary_proc_show(struct seq_file m, void v) · 6657 unmodified lines
6658	static int mpt_version_proc_show(struct seq_file m, void v)	6658	static int mpt_version_proc_show(struct seq_file m, void v)
6659	{	6659	{
6660	u8 cb_idx;	6660	u8 cb_idx;
6661	int scsi, fc, sas, lan, ctl, targ, dmp;	6661	int scsi, fc, sas, lan, ctl, targ;
6662	char *drvname;	6662	char *drvname;
6663		6663
6664	seq_printf(m, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);	6664	seq_printf(m, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);
6665	seq_printf(m, " Fusion MPT base driver\n");	6665	seq_printf(m, " Fusion MPT base driver\n");
6666		6666
6667	scsi = fc = sas = lan = ctl = targ = dmp = 0;	6667	scsi = fc = sas = lan = ctl = targ = 0;
6668	for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {	6668	for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6669	drvname = NULL;	6669	drvname = NULL;
6670	if (MptCallbacks[cb_idx]) {	6670	if (MptCallbacks[cb_idx]) {

drivers/scsi/aha152x.c+113−122

 };
 struct aha152x_cmd_priv {
-	struct scsi_pointer scsi_pointer;
+	char *ptr;
+	int this_residual;
+	struct scatterlist *buffer;
+	int status;
+	int message;
+	int sent_command;
+	int phase;
 };
-static struct scsi_pointer *aha152x_scsi_pointer(struct scsi_cmnd *cmd)
+static struct aha152x_cmd_priv *aha152x_priv(struct scsi_cmnd *cmd)
 {
-	struct aha152x_cmd_priv *acmd = scsi_cmd_priv(cmd);
+	return scsi_cmd_priv(cmd);
-	return &acmd->scsi_pointer;
 }
 MODULE_AUTHOR("Jürgen Fischer");
 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
 {
 	if(CURRENT_SC) {
-		struct scsi_pointer *scsi_pointer =
+		struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
-			aha152x_scsi_pointer(CURRENT_SC);
-		scsi_pointer->phase |= 1 << 16;
+		acp->phase |= 1 << 16;
-		if (scsi_pointer->phase & selecting) {
+		if (acp->phase & selecting) {
 			SETPORT(SSTAT1, SELTO);
 			SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
 			SETPORT(SIMODE1, ENSELTIMO);
 		} else {
-			SETPORT(SIMODE0, (scsi_pointer->phase & spiordy) ? ENSPIORDY : 0);
+			SETPORT(SIMODE0, (acp->phase & spiordy) ? ENSPIORDY : 0);
 			SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
 		}
 	} else if(STATE==seldi) {
 static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
 				  struct completion *complete, int phase)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(SCpnt);
+	struct aha152x_cmd_priv *acp = aha152x_priv(SCpnt);
 	struct Scsi_Host *shpnt = SCpnt->device->host;
 	unsigned long flags;
-	scsi_pointer->phase	   = not_issued | phase;
+	acp->phase        = not_issued | phase;
-	scsi_pointer->Status	   = 0x1; /* Ilegal status by SCSI standard */
+	acp->status       = 0x1; /* Illegal status by SCSI standard */
-	scsi_pointer->Message	   = 0;
+	acp->message      = 0;
-	scsi_pointer->have_data_in = 0;
+	acp->sent_command = 0;
-	scsi_pointer->sent_command = 0;
-	if (scsi_pointer->phase & (resetting | check_condition)) {
+	if (acp->phase & (resetting | check_condition)) {
 		if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
 			scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
 			return FAILED;
 	   SCp.phase            : current state of the command */
 	if ((phase & resetting) || !scsi_sglist(SCpnt)) {
-		scsi_pointer->ptr           = NULL;
+		acp->ptr           = NULL;
-		scsi_pointer->this_residual = 0;
+		acp->this_residual = 0;
 		scsi_set_resid(SCpnt, 0);
-		scsi_pointer->buffer        = NULL;
+		acp->buffer        = NULL;
 	} else {
 		scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
-		scsi_pointer->buffer        = scsi_sglist(SCpnt);
+		acp->buffer        = scsi_sglist(SCpnt);
-		scsi_pointer->ptr           = SG_ADDRESS(scsi_pointer->buffer);
+		acp->ptr           = SG_ADDRESS(acp->buffer);
-		scsi_pointer->this_residual = scsi_pointer->buffer->length;
+		acp->this_residual = acp->buffer->length;
 	}
 	DO_LOCK(flags);
 static void aha152x_scsi_done(struct scsi_cmnd *SCpnt)
 {
-	if (aha152x_scsi_pointer(SCpnt)->phase & resetting)
+	if (aha152x_priv(SCpnt)->phase & resetting)
 		reset_done(SCpnt);
 	else
 		scsi_done(SCpnt);
 	DO_LOCK(flags);
-	if (aha152x_scsi_pointer(SCpnt)->phase & resetted) {
+	if (aha152x_priv(SCpnt)->phase & resetted) {
 		HOSTDATA(shpnt)->commands--;
 		if (!HOSTDATA(shpnt)->commands)
 			SETPORT(PORTA, 0);
 	SETPORT(SSTAT1, CLRBUSFREE);
 	if(CURRENT_SC) {
-		struct scsi_pointer *scsi_pointer =
+		struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
-			aha152x_scsi_pointer(CURRENT_SC);
 #if defined(AHA152X_STAT)
 		action++;
 #endif
-		scsi_pointer->phase &= ~syncneg;
+		acp->phase &= ~syncneg;
-		if (scsi_pointer->phase & completed) {
+		if (acp->phase & completed) {
 			/* target sent COMMAND COMPLETE */
-			done(shpnt, scsi_pointer->Status, DID_OK);
+			done(shpnt, acp->status, DID_OK);
-		} else if (scsi_pointer->phase & aborted) {
+		} else if (acp->phase & aborted) {
-			done(shpnt, scsi_pointer->Status, DID_ABORT);
+			done(shpnt, acp->status, DID_ABORT);
-		} else if (scsi_pointer->phase & resetted) {
+		} else if (acp->phase & resetted) {
-			done(shpnt, scsi_pointer->Status, DID_RESET);
+			done(shpnt, acp->status, DID_RESET);
-		} else if (scsi_pointer->phase & disconnected) {
+		} else if (acp->phase & disconnected) {
 			/* target sent DISCONNECT */
 #if defined(AHA152X_STAT)
 			HOSTDATA(shpnt)->disconnections++;
 #endif
 			append_SC(&DISCONNECTED_SC, CURRENT_SC);
-			scsi_pointer->phase |= 1 << 16;
+			acp->phase |= 1 << 16;
 			CURRENT_SC = NULL;
 		} else {
 		action++;
 #endif
-		if (aha152x_scsi_pointer(DONE_SC)->phase & check_condition) {
+		if (aha152x_priv(DONE_SC)->phase & check_condition) {
 			struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
 			struct aha152x_scdata *sc = SCDATA(cmd);
 			scsi_eh_restore_cmnd(cmd, &sc->ses);
-			aha152x_scsi_pointer(cmd)->Status = SAM_STAT_CHECK_CONDITION;
+			aha152x_priv(cmd)->status = SAM_STAT_CHECK_CONDITION;
 			HOSTDATA(shpnt)->commands--;
 			if (!HOSTDATA(shpnt)->commands)
 				SETPORT(PORTA, 0);	/* turn led off */
-		} else if (aha152x_scsi_pointer(DONE_SC)->Status ==
+		} else if (aha152x_priv(DONE_SC)->status == SAM_STAT_CHECK_CONDITION) {
-			   SAM_STAT_CHECK_CONDITION) {
 #if defined(AHA152X_STAT)
 			HOSTDATA(shpnt)->busfree_with_check_condition++;
 #endif
-			if(!(aha152x_scsi_pointer(DONE_SC)->phase & not_issued)) {
+			if (!(aha152x_priv(DONE_SC)->phase & not_issued)) {
 				struct aha152x_scdata *sc;
 				struct scsi_cmnd *ptr = DONE_SC;
 				DONE_SC=NULL;
 			if (!HOSTDATA(shpnt)->commands)
 				SETPORT(PORTA, 0);	/* turn led off */
-			if (!(aha152x_scsi_pointer(ptr)->phase & resetting)) {
+			if (!(aha152x_priv(ptr)->phase & resetting)) {
 				kfree(ptr->host_scribble);
 				ptr->host_scribble=NULL;
 			}
 	DO_UNLOCK(flags);
 	if(CURRENT_SC) {
-		struct scsi_pointer *scsi_pointer =
+		struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
-			aha152x_scsi_pointer(CURRENT_SC);
 #if defined(AHA152X_STAT)
 		action++;
 #endif
-		scsi_pointer->phase |= selecting;
+		acp->phase |= selecting;
 		/* clear selection timeout */
 		SETPORT(SSTAT1, SELTO);
  */
 static void seldo_run(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+	struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
 	SETPORT(SCSISIG, 0);
 	SETPORT(SSTAT1, CLRBUSFREE);
 	SETPORT(SSTAT1, CLRPHASECHG);
-	scsi_pointer->phase &= ~(selecting | not_issued);
+	acp->phase &= ~(selecting | not_issued);
 	SETPORT(SCSISEQ, 0);
 	ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
-	if (scsi_pointer->phase & aborting) {
+	if (acp->phase & aborting) {
 		ADDMSGO(ABORT);
-	} else if (scsi_pointer->phase & resetting) {
+	} else if (acp->phase & resetting) {
 		ADDMSGO(BUS_DEVICE_RESET);
 	} else if (SYNCNEG==0 && SYNCHRONOUS) {
-		scsi_pointer->phase |= syncneg;
+		acp->phase |= syncneg;
 		MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
 		SYNCNEG=1;		/* negotiation in progress */
 	}
  */
 static void selto_run(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+	struct aha152x_cmd_priv *acp;
 	SETPORT(SCSISEQ, 0);
 	SETPORT(SSTAT1, CLRSELTIMO);
 	if (!CURRENT_SC)
 		return;
-	scsi_pointer->phase &= ~selecting;
+	acp = aha152x_priv(CURRENT_SC);
+	acp->phase &= ~selecting;
-	if (scsi_pointer->phase & aborted)
+	if (acp->phase & aborted)
 		done(shpnt, SAM_STAT_GOOD, DID_ABORT);
 	else if (TESTLO(SSTAT0, SELINGO))
 		done(shpnt, SAM_STAT_GOOD, DID_BUS_BUSY);
 	SETPORT(SSTAT1, CLRPHASECHG);
 	if(CURRENT_SC) {
-		struct scsi_pointer *scsi_pointer =
+		struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
-			aha152x_scsi_pointer(CURRENT_SC);
-		if (!(scsi_pointer->phase & not_issued))
+		if (!(acp->phase & not_issued))
 			scmd_printk(KERN_ERR, CURRENT_SC,
 				    "command should not have been issued yet\n");
 static void msgi_run(struct Scsi_Host *shpnt)
 {
 	for(;;) {
-		struct scsi_pointer *scsi_pointer;
+		struct aha152x_cmd_priv *acp;
 		int sstat1 = GETPORT(SSTAT1);
 		if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
 				continue;
 			}
-			scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+			acp = aha152x_priv(CURRENT_SC);
-			scsi_pointer->Message = MSGI(0);
+			acp->message = MSGI(0);
-			scsi_pointer->phase &= ~disconnected;
+			acp->phase &= ~disconnected;
 			MSGILEN=0;
 			continue;
 		}
-		scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+		acp = aha152x_priv(CURRENT_SC);
-		scsi_pointer->Message = MSGI(0);
+		acp->message = MSGI(0);
 		switch (MSGI(0)) {
 		case DISCONNECT:
 				scmd_printk(KERN_WARNING, CURRENT_SC,
 					    "target was not allowed to disconnect\n");
-			scsi_pointer->phase |= disconnected;
+			acp->phase |= disconnected;
 			break;
 		case COMMAND_COMPLETE:
-			scsi_pointer->phase |= completed;
+			acp->phase |= completed;
 			break;
 		case MESSAGE_REJECT:
  */
 static void msgo_init(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
 	if(MSGOLEN==0) {
-		if ((scsi_pointer->phase & syncneg) && SYNCNEG==2 &&
+		if ((aha152x_priv(CURRENT_SC)->phase & syncneg) &&
-		    SYNCRATE==0) {
+		    SYNCNEG == 2 && SYNCRATE == 0) {
 			ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
 		} else {
 			scmd_printk(KERN_INFO, CURRENT_SC,
  */
 static void msgo_run(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+	struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
 	while(MSGO_I<MSGOLEN) {
 		if (TESTLO(SSTAT0, SPIORDY))
 		if (MSGO(MSGO_I) & IDENTIFY_BASE)
-			scsi_pointer->phase |= identified;
+			acp->phase |= identified;
 		if (MSGO(MSGO_I)==ABORT)
-			scsi_pointer->phase |= aborted;
+			acp->phase |= aborted;
 		if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
-			scsi_pointer->phase |= resetted;
+			acp->phase |= resetted;
 		SETPORT(SCSIDAT, MSGO(MSGO_I++));
 	}
  */
 static void cmd_init(struct Scsi_Host *shpnt)
 {
-	if (aha152x_scsi_pointer(CURRENT_SC)->sent_command) {
+	if (aha152x_priv(CURRENT_SC)->sent_command) {
 		scmd_printk(KERN_ERR, CURRENT_SC,
 			    "command already sent\n");
 		done(shpnt, SAM_STAT_GOOD, DID_ERROR);
 			    "command sent incompletely (%d/%d)\n",
 			    CMD_I, CURRENT_SC->cmd_len);
 	else
-		aha152x_scsi_pointer(CURRENT_SC)->sent_command++;
+		aha152x_priv(CURRENT_SC)->sent_command++;
 }
 /*
 	if (TESTLO(SSTAT0, SPIORDY))
 		return;
-	aha152x_scsi_pointer(CURRENT_SC)->Status = GETPORT(SCSIDAT);
+	aha152x_priv(CURRENT_SC)->status = GETPORT(SCSIDAT);
 }
 static void datai_run(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer;
+	struct aha152x_cmd_priv *acp;
 	unsigned long the_time;
 	int fifodata, data_count;
 			fifodata = GETPORT(FIFOSTAT);
 		}
-		scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+		acp = aha152x_priv(CURRENT_SC);
-		if (scsi_pointer->this_residual > 0) {
+		if (acp->this_residual > 0) {
-			while (fifodata > 0 && scsi_pointer->this_residual > 0) {
+			while (fifodata > 0 && acp->this_residual > 0) {
-				data_count = fifodata > scsi_pointer->this_residual ?
+				data_count = fifodata > acp->this_residual ?
-						scsi_pointer->this_residual :
+						acp->this_residual : fifodata;
-						fifodata;
 				fifodata -= data_count;
 				if (data_count & 1) {
 					SETPORT(DMACNTRL0, ENDMA|_8BIT);
-					*scsi_pointer->ptr++ = GETPORT(DATAPORT);
+					*acp->ptr++ = GETPORT(DATAPORT);
-					scsi_pointer->this_residual--;
+					acp->this_residual--;
 					DATA_LEN++;
 					SETPORT(DMACNTRL0, ENDMA);
 				}
 				if (data_count > 1) {
 					data_count >>= 1;
-					insw(DATAPORT, scsi_pointer->ptr, data_count);
+					insw(DATAPORT, acp->ptr, data_count);
-					scsi_pointer->ptr += 2 * data_count;
+					acp->ptr += 2 * data_count;
-					scsi_pointer->this_residual -= 2 * data_count;
+					acp->this_residual -= 2 * data_count;
 					DATA_LEN += 2 * data_count;
 				}
-				if (scsi_pointer->this_residual == 0 &&
+				if (acp->this_residual == 0 &&
-				    !sg_is_last(scsi_pointer->buffer)) {
+				    !sg_is_last(acp->buffer)) {
 					/* advance to next buffer */
-					scsi_pointer->buffer = sg_next(scsi_pointer->buffer);
+					acp->buffer = sg_next(acp->buffer);
-					scsi_pointer->ptr           = SG_ADDRESS(scsi_pointer->buffer);
+					acp->ptr = SG_ADDRESS(acp->buffer);
-					scsi_pointer->this_residual = scsi_pointer->buffer->length;
+					acp->this_residual = acp->buffer->length;
 				}
 			}
 		} else if (fifodata > 0) {
 static void datao_run(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+	struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
 	unsigned long the_time;
 	int data_count;
 	/* until phase changes or all data sent */
-	while (TESTLO(DMASTAT, INTSTAT) && scsi_pointer->this_residual > 0) {
+	while (TESTLO(DMASTAT, INTSTAT) && acp->this_residual > 0) {
 		data_count = 128;
-		if (data_count > scsi_pointer->this_residual)
+		if (data_count > acp->this_residual)
-			data_count = scsi_pointer->this_residual;
+			data_count = acp->this_residual;
 		if(TESTLO(DMASTAT, DFIFOEMP)) {
 			scmd_printk(KERN_ERR, CURRENT_SC,
 		if(data_count & 1) {
 			SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
-			SETPORT(DATAPORT, *scsi_pointer->ptr++);
+			SETPORT(DATAPORT, *acp->ptr++);
-			scsi_pointer->this_residual--;
+			acp->this_residual--;
 			CMD_INC_RESID(CURRENT_SC, -1);
 			SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
 		}
 		if(data_count > 1) {
 			data_count >>= 1;
-			outsw(DATAPORT, scsi_pointer->ptr, data_count);
+			outsw(DATAPORT, acp->ptr, data_count);
-			scsi_pointer->ptr           += 2 * data_count;
+			acp->ptr += 2 * data_count;
-			scsi_pointer->this_residual -= 2 * data_count;
+			acp->this_residual -= 2 * data_count;
 			CMD_INC_RESID(CURRENT_SC, -2 * data_count);
 		}
-		if (scsi_pointer->this_residual == 0 &&
+		if (acp->this_residual == 0 && !sg_is_last(acp->buffer)) {
-		    !sg_is_last(scsi_pointer->buffer)) {
 			/* advance to next buffer */
-			scsi_pointer->buffer = sg_next(scsi_pointer->buffer);
+			acp->buffer = sg_next(acp->buffer);
-			scsi_pointer->ptr           = SG_ADDRESS(scsi_pointer->buffer);
+			acp->ptr = SG_ADDRESS(acp->buffer);
-			scsi_pointer->this_residual = scsi_pointer->buffer->length;
+			acp->this_residual = acp->buffer->length;
 		}
 		the_time=jiffies + 100*HZ;
 static void datao_end(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
+	struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
 	if(TESTLO(DMASTAT, DFIFOEMP)) {
 		u32 datao_cnt = GETSTCNT();
 			sg = sg_next(sg);
 		}
-		scsi_pointer->buffer = sg;
+		acp->buffer = sg;
-		scsi_pointer->ptr = SG_ADDRESS(scsi_pointer->buffer) + done;
+		acp->ptr = SG_ADDRESS(acp->buffer) + done;
-		scsi_pointer->this_residual = scsi_pointer->buffer->length -
+		acp->this_residual = acp->buffer->length - done;
-			done;
 	}
 	SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
  */
 static int update_state(struct Scsi_Host *shpnt)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(CURRENT_SC);
 	int dataphase=0;
 	unsigned int stat0 = GETPORT(SSTAT0);
 	unsigned int stat1 = GETPORT(SSTAT1);
 	} else if (stat0 & SELDI && PREVSTATE == busfree) {
 		STATE=seldi;
 	} else if (stat0 & SELDO && CURRENT_SC &&
-		   (scsi_pointer->phase & selecting)) {
+		   (aha152x_priv(CURRENT_SC)->phase & selecting)) {
 		STATE=seldo;
 	} else if(stat1 & SELTO) {
 		STATE=selto;
 			SETPORT(SXFRCTL0, CH1);
 			SETPORT(DMACNTRL0, 0);
 			if(CURRENT_SC)
-				aha152x_scsi_pointer(CURRENT_SC)->phase &=
+				aha152x_priv(CURRENT_SC)->phase &= ~spiordy;
-					~spiordy;
 		}
 		/*
 			SETPORT(DMACNTRL0, 0);
 			SETPORT(SXFRCTL0, CH1|SPIOEN);
 			if(CURRENT_SC)
-				aha152x_scsi_pointer(CURRENT_SC)->phase |=
+				aha152x_priv(CURRENT_SC)->phase |= spiordy;
-					spiordy;
 		}
 		/*
  */
 static void show_command(struct scsi_cmnd *ptr)
 {
-	const int phase = aha152x_scsi_pointer(ptr)->phase;
+	const int phase = aha152x_priv(ptr)->phase;
 	scsi_print_command(ptr);
 	scmd_printk(KERN_DEBUG, ptr,
 static void get_command(struct seq_file *m, struct scsi_cmnd * ptr)
 {
-	struct scsi_pointer *scsi_pointer = aha152x_scsi_pointer(ptr);
+	struct aha152x_cmd_priv *acp = aha152x_priv(ptr);
-	const int phase = scsi_pointer->phase;
+	const int phase = acp->phase;
 	int i;
 	seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
 		seq_printf(m, "0x%02x ", ptr->cmnd[i]);
 	seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
-		scsi_get_resid(ptr), scsi_pointer->this_residual,
+		scsi_get_resid(ptr), acp->this_residual,
-		sg_nents(scsi_pointer->buffer) - 1);
+		sg_nents(acp->buffer) - 1);
 	if (phase & not_issued)
 		seq_puts(m, "not issued|");

drivers/scsi/aic7xxx/aic79xx_osm.h+0−2

@@ -420,8 +420,6 @@ ahd_unlock(struct ahd_softc ahd, unsigned long flags) · 419 unmodified lines
420		420
421	/* config registers for header type 0 devices */	421	/* config registers for header type 0 devices */
422	#define PCIR_MAPS 0x10	422	#define PCIR_MAPS 0x10
423	#define PCIR_SUBVEND_0 0x2c
424	#define PCIR_SUBDEV_0 0x2e
425		423
426	/**************************** PCI-X definitions ***************************/	424	/**************************** PCI-X definitions ***************************/
427	#define PCIXR_COMMAND 0x96	425	#define PCIXR_COMMAND 0x96

drivers/scsi/aic7xxx/aic79xx_pci.c+3−3

@@ -260,8 +260,8 @@ ahd_find_pci_device(ahd_dev_softc_t pci) · 259 unmodified lines
260		260
261	vendor = ahd_pci_read_config(pci, PCIR_DEVVENDOR, /bytes/2);	261	vendor = ahd_pci_read_config(pci, PCIR_DEVVENDOR, /bytes/2);
262	device = ahd_pci_read_config(pci, PCIR_DEVICE, /bytes/2);	262	device = ahd_pci_read_config(pci, PCIR_DEVICE, /bytes/2);
263	subvendor = ahd_pci_read_config(pci, PCIR_SUBVEND_0, /bytes/2);	263	subvendor = ahd_pci_read_config(pci, PCI_SUBSYSTEM_VENDOR_ID, /bytes/2);
264	subdevice = ahd_pci_read_config(pci, PCIR_SUBDEV_0, /bytes/2);	264	subdevice = ahd_pci_read_config(pci, PCI_SUBSYSTEM_ID, /bytes/2);
265	full_id = ahd_compose_id(device,	265	full_id = ahd_compose_id(device,
266	vendor,	266	vendor,
267	subdevice,	267	subdevice,
@@ -298,7 +298,7 @@ ahd_pci_config(struct ahd_softc ahd, const struct ahd_pci_identity entry) · 30 unmodified lines
298	* Record if this is an HP board.	298	* Record if this is an HP board.
299	*/	299	*/
300	subvendor = ahd_pci_read_config(ahd->dev_softc,	300	subvendor = ahd_pci_read_config(ahd->dev_softc,
301	PCIR_SUBVEND_0, /bytes/2);	301	PCI_SUBSYSTEM_VENDOR_ID, /bytes/2);
302	if (subvendor == SUBID_HP)	302	if (subvendor == SUBID_HP)
303	ahd->flags \|= AHD_HP_BOARD;	303	ahd->flags \|= AHD_HP_BOARD;
304		304

drivers/scsi/aic7xxx/aic7xxx_osm.h+0−2

@@ -433,8 +433,6 @@ ahc_unlock(struct ahc_softc ahc, unsigned long flags) · 432 unmodified lines
433		433
434	/* config registers for header type 0 devices */	434	/* config registers for header type 0 devices */
435	#define PCIR_MAPS 0x10	435	#define PCIR_MAPS 0x10
436	#define PCIR_SUBVEND_0 0x2c
437	#define PCIR_SUBDEV_0 0x2e
438		436
439	typedef enum	437	typedef enum
440	{	438	{

drivers/scsi/aic7xxx/aic7xxx_pci.c+2−2

@@ -673,8 +673,8 @@ ahc_find_pci_device(ahc_dev_softc_t pci) · 672 unmodified lines
673		673
674	vendor = ahc_pci_read_config(pci, PCIR_DEVVENDOR, /bytes/2);	674	vendor = ahc_pci_read_config(pci, PCIR_DEVVENDOR, /bytes/2);
675	device = ahc_pci_read_config(pci, PCIR_DEVICE, /bytes/2);	675	device = ahc_pci_read_config(pci, PCIR_DEVICE, /bytes/2);
676	subvendor = ahc_pci_read_config(pci, PCIR_SUBVEND_0, /bytes/2);	676	subvendor = ahc_pci_read_config(pci, PCI_SUBSYSTEM_VENDOR_ID, /bytes/2);
677	subdevice = ahc_pci_read_config(pci, PCIR_SUBDEV_0, /bytes/2);	677	subdevice = ahc_pci_read_config(pci, PCI_SUBSYSTEM_ID, /bytes/2);
678	full_id = ahc_compose_id(device, vendor, subdevice, subvendor);	678	full_id = ahc_compose_id(device, vendor, subdevice, subvendor);
679		679
680	/*	680	/*

drivers/scsi/bnx2fc/bnx2fc_hwi.c+3−3

@@ -1169,7 +1169,7 @@ static void bnx2fc_process_ofld_cmpl(struct bnx2fc_hba *hba, · 1168 unmodified lines
1169	ofld_kcqe->fcoe_conn_context_id);	1169	ofld_kcqe->fcoe_conn_context_id);
1170	interface = tgt->port->priv;	1170	interface = tgt->port->priv;
1171	if (hba != interface->hba) {	1171	if (hba != interface->hba) {
1172	printk(KERN_ERR PFX "ERROR:ofld_cmpl: HBA mis-match\n");	1172	printk(KERN_ERR PFX "ERROR:ofld_cmpl: HBA mismatch\n");
1173	goto ofld_cmpl_err;	1173	goto ofld_cmpl_err;
1174	}	1174	}
1175	/*	1175	/*
@@ -1226,12 +1226,12 @@ static void bnx2fc_process_enable_conn_cmpl(struct bnx2fc_hba *hba, · 50 unmodified lines
1226	* and enable	1226	* and enable
1227	*/	1227	*/
1228	if (tgt->context_id != context_id) {	1228	if (tgt->context_id != context_id) {
1229	printk(KERN_ERR PFX "context id mis-match\n");	1229	printk(KERN_ERR PFX "context id mismatch\n");
1230	return;	1230	return;
1231	}	1231	}
1232	interface = tgt->port->priv;	1232	interface = tgt->port->priv;
1233	if (hba != interface->hba) {	1233	if (hba != interface->hba) {
1234	printk(KERN_ERR PFX "bnx2fc-enbl_cmpl: HBA mis-match\n");	1234	printk(KERN_ERR PFX "bnx2fc-enbl_cmpl: HBA mismatch\n");
1235	goto enbl_cmpl_err;	1235	goto enbl_cmpl_err;
1236	}	1236	}
1237	if (!ofld_kcqe->completion_status)	1237	if (!ofld_kcqe->completion_status)

drivers/scsi/bnx2i/bnx2i_hwi.c+2−2

@@ -2398,7 +2398,7 @@ static void bnx2i_process_conn_destroy_cmpl(struct bnx2i_hba *hba, · 2397 unmodified lines
2398	}	2398	}
2399		2399
2400	if (hba != ep->hba) {	2400	if (hba != ep->hba) {
2401	printk(KERN_ALERT "conn destroy- error hba mis-match\n");	2401	printk(KERN_ALERT "conn destroy- error hba mismatch\n");
2402	return;	2402	return;
2403	}	2403	}
2404		2404
@@ -2432,7 +2432,7 @@ static void bnx2i_process_ofld_cmpl(struct bnx2i_hba *hba, · 27 unmodified lines
2432	}	2432	}
2433		2433
2434	if (hba != ep->hba) {	2434	if (hba != ep->hba) {
2435	printk(KERN_ALERT "ofld_cmpl: error hba mis-match\n");	2435	printk(KERN_ALERT "ofld_cmpl: error hba mismatch\n");
2436	return;	2436	return;
2437	}	2437	}
2438		2438

drivers/scsi/hisi_sas/hisi_sas_main.c+0−1

@@ -442,7 +442,6 @@ void hisi_sas_task_deliver(struct hisi_hba *hisi_hba, · 441 unmodified lines
442	case SAS_PROTOCOL_INTERNAL_ABORT:	442	case SAS_PROTOCOL_INTERNAL_ABORT:
443	hisi_sas_task_prep_abort(hisi_hba, slot);	443	hisi_sas_task_prep_abort(hisi_hba, slot);
444	break;	444	break;
445	fallthrough;
446	default:	445	default:
447	return;	446	return;
448	}	447	}

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c+1−1

@@ -36,7 +36,7 @@ · 35 unmodified lines
36		36
37	#define IBMVSCSIS_VERSION "v0.2"	37	#define IBMVSCSIS_VERSION "v0.2"
38		38
39	#define INITIAL_SRP_LIMIT 800	39	#define INITIAL_SRP_LIMIT 1024
40	#define DEFAULT_MAX_SECTORS 256	40	#define DEFAULT_MAX_SECTORS 256
41	#define MAX_TXU 1024 * 1024	41	#define MAX_TXU 1024 * 1024
42		42

drivers/scsi/isci/host.c+3−3

@@ -413,7 +413,7 @@ static void sci_controller_event_completion(struct isci_host *ihost, u32 ent) · 412 unmodified lines
413	dev_warn(&ihost->pdev->dev,	413	dev_warn(&ihost->pdev->dev,
414	"%s: SCIC Controller 0x%p received "	414	"%s: SCIC Controller 0x%p received "
415	"event 0x%x for io request object "	415	"event 0x%x for io request object "
416	"that doesnt exist.\n",	416	"that doesn't exist.\n",
417	__func__,	417	__func__,
418	ihost,	418	ihost,
419	ent);	419	ent);
@@ -428,7 +428,7 @@ static void sci_controller_event_completion(struct isci_host *ihost, u32 ent) · 8 unmodified lines
428	dev_warn(&ihost->pdev->dev,	428	dev_warn(&ihost->pdev->dev,
429	"%s: SCIC Controller 0x%p received "	429	"%s: SCIC Controller 0x%p received "
430	"event 0x%x for remote device object "	430	"event 0x%x for remote device object "
431	"that doesnt exist.\n",	431	"that doesn't exist.\n",
432	__func__,	432	__func__,
433	ihost,	433	ihost,
434	ent);	434	ent);
@@ -462,7 +462,7 @@ static void sci_controller_event_completion(struct isci_host *ihost, u32 ent) · 27 unmodified lines
462	} else	462	} else
463	dev_err(&ihost->pdev->dev,	463	dev_err(&ihost->pdev->dev,
464	"%s: SCIC Controller 0x%p received event 0x%x "	464	"%s: SCIC Controller 0x%p received event 0x%x "
465	"for remote device object 0x%0x that doesnt "	465	"for remote device object 0x%0x that doesn't "
466	"exist.\n",	466	"exist.\n",
467	__func__,	467	__func__,
468	ihost,	468	ihost,

drivers/scsi/libiscsi.c+0−1

@@ -3045,7 +3045,6 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, · 3044 unmodified lines
3045	if (!cls_conn)	3045	if (!cls_conn)
3046	return NULL;	3046	return NULL;
3047	conn = cls_conn->dd_data;	3047	conn = cls_conn->dd_data;
3048	memset(conn, 0, sizeof(*conn) + dd_size);
3049		3048
3050	conn->dd_data = cls_conn->dd_data + sizeof(*conn);	3049	conn->dd_data = cls_conn->dd_data + sizeof(*conn);
3051	conn->session = session;	3050	conn->session = session;

drivers/scsi/lpfc/lpfc.h+5−2

 	NHT_MODE,
 };
+enum lpfc_hba_bit_flags {
+	FABRIC_COMANDS_BLOCKED,
+	HBA_PCI_ERR,
+};
 struct lpfc_hba {
 	/* SCSI interface function jump table entries */
 	struct lpfc_io_buf * (*lpfc_get_scsi_buf)
 					 * Firmware supports Forced Link Speed
 					 * capability
 					 */
-#define HBA_PCI_ERR		0x80000 /* The PCI slot is offline */
 #define HBA_FLOGI_ISSUED	0x100000 /* FLOGI was issued */
 #define HBA_SHORT_CMF		0x200000 /* shorter CMF timer routine */
 #define HBA_CGN_DAY_WRAP	0x400000 /* HBA Congestion info day wraps */
 	atomic_t fabric_iocb_count;
 	struct timer_list fabric_block_timer;
 	unsigned long bit_flags;
-#define	FABRIC_COMANDS_BLOCKED	0
 	atomic_t num_rsrc_err;
 	atomic_t num_cmd_success;
 	unsigned long last_rsrc_error_time;

drivers/scsi/lpfc/lpfc_crtn.h+3−0

@@ -670,3 +670,6 @@ struct lpfc_vmid lpfc_get_vmid_from_hashtable(struct lpfc_vport vport, · 669 unmodified lines
670	uint32_t hash, uint8_t *buf);	670	uint32_t hash, uint8_t *buf);
671	void lpfc_vmid_vport_cleanup(struct lpfc_vport *vport);	671	void lpfc_vmid_vport_cleanup(struct lpfc_vport *vport);
672	int lpfc_issue_els_qfpa(struct lpfc_vport *vport);	672	int lpfc_issue_els_qfpa(struct lpfc_vport *vport);
		673
		674	void lpfc_sli_rpi_release(struct lpfc_vport *vport,
		675	struct lpfc_nodelist *ndlp);

drivers/scsi/lpfc/lpfc_hbadisc.c+97−23

 	ndlp = rdata->pnode;
 	if (!rdata->pnode) {
-		pr_err("**** %s: NULL ndlp on rport x%px SID x%x\n",
+		pr_info("**** %s: NULL ndlp on rport x%px SID x%x\n",
-		       __func__, rport, rport->scsi_target_id);
+			__func__, rport, rport->scsi_target_id);
 		return -EINVAL;
 	}
 	lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
 			 "3181 dev_loss_callbk x%06x, rport x%px flg x%x "
-			 "load_flag x%x refcnt %d\n",
+			 "load_flag x%x refcnt %d state %d xpt x%x\n",
 			 ndlp->nlp_DID, ndlp->rport, ndlp->nlp_flag,
-			 vport->load_flag, kref_read(&ndlp->kref));
+			 vport->load_flag, kref_read(&ndlp->kref),
+			 ndlp->nlp_state, ndlp->fc4_xpt_flags);
 	/* Don't schedule a worker thread event if the vport is going down.
 	 * The teardown process cleans up the node via lpfc_drop_node.
 		ndlp->rport = NULL;
 		ndlp->fc4_xpt_flags &= ~SCSI_XPT_REGD;
+		/* clear the NLP_XPT_REGD if the node is not registered
+		 * with nvme-fc
+		 */
+		if (ndlp->fc4_xpt_flags == NLP_XPT_REGD)
+			ndlp->fc4_xpt_flags &= ~NLP_XPT_REGD;
 		/* Remove the node reference from remote_port_add now.
 		 * The driver will not call remote_port_delete.
 	ndlp->rport = NULL;
 	spin_unlock_irqrestore(&ndlp->lock, iflags);
-	/* We need to hold the node by incrementing the reference
+	if (phba->worker_thread) {
-	 * count until this queued work is done
+		/* We need to hold the node by incrementing the reference
-	 */
+		 * count until this queued work is done
-	evtp->evt_arg1 = lpfc_nlp_get(ndlp);
+		 */
+		evtp->evt_arg1 = lpfc_nlp_get(ndlp);
+		spin_lock_irqsave(&phba->hbalock, iflags);
+		if (evtp->evt_arg1) {
+			evtp->evt = LPFC_EVT_DEV_LOSS;
+			list_add_tail(&evtp->evt_listp, &phba->work_list);
+			lpfc_worker_wake_up(phba);
+		}
+		spin_unlock_irqrestore(&phba->hbalock, iflags);
+	} else {
+		lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
+				 "3188 worker thread is stopped %s x%06x, "
+				 " rport x%px flg x%x load_flag x%x refcnt "
+				 "%d\n", __func__, ndlp->nlp_DID,
+				 ndlp->rport, ndlp->nlp_flag,
+				 vport->load_flag, kref_read(&ndlp->kref));
+		if (!(ndlp->fc4_xpt_flags & NVME_XPT_REGD)) {
+			spin_lock_irqsave(&ndlp->lock, iflags);
+			/* Node is in dev loss.  No further transaction. */
+			ndlp->nlp_flag &= ~NLP_IN_DEV_LOSS;
+			spin_unlock_irqrestore(&ndlp->lock, iflags);
+			lpfc_disc_state_machine(vport, ndlp, NULL,
+						NLP_EVT_DEVICE_RM);
+		}
-	spin_lock_irqsave(&phba->hbalock, iflags);
-	if (evtp->evt_arg1) {
-		evtp->evt = LPFC_EVT_DEV_LOSS;
-		list_add_tail(&evtp->evt_listp, &phba->work_list);
-		lpfc_worker_wake_up(phba);
 	}
-	spin_unlock_irqrestore(&phba->hbalock, iflags);
 	return;
 }
 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 				 "0203 Devloss timeout on "
 				 "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
-				 "NPort x%06x Data: x%x x%x x%x\n",
+				 "NPort x%06x Data: x%x x%x x%x refcnt %d\n",
 				 *name, *(name+1), *(name+2), *(name+3),
 				 *(name+4), *(name+5), *(name+6), *(name+7),
 				 ndlp->nlp_DID, ndlp->nlp_flag,
-				 ndlp->nlp_state, ndlp->nlp_rpi);
+				 ndlp->nlp_state, ndlp->nlp_rpi,
+				 kref_read(&ndlp->kref));
 	} else {
 		lpfc_printf_vlog(vport, KERN_INFO, LOG_TRACE_EVENT,
 				 "0204 Devloss timeout on "
 	int free_evt;
 	int fcf_inuse;
 	uint32_t nlp_did;
+	bool hba_pci_err;
 	spin_lock_irq(&phba->hbalock);
 	while (!list_empty(&phba->work_list)) {
 		list_remove_head((&phba->work_list), evtp, typeof(*evtp),
 				 evt_listp);
 		spin_unlock_irq(&phba->hbalock);
+		hba_pci_err = test_bit(HBA_PCI_ERR, &phba->bit_flags);
 		free_evt = 1;
 		switch (evtp->evt) {
 		case LPFC_EVT_ELS_RETRY:
 			ndlp = (struct lpfc_nodelist *) (evtp->evt_arg1);
-			lpfc_els_retry_delay_handler(ndlp);
+			if (!hba_pci_err) {
-			free_evt = 0; /* evt is part of ndlp */
+				lpfc_els_retry_delay_handler(ndlp);
+				free_evt = 0; /* evt is part of ndlp */
+			}
 			/* decrement the node reference count held
 			 * for this queued work
 			 */
 			break;
 		case LPFC_EVT_RECOVER_PORT:
 			ndlp = (struct lpfc_nodelist *)(evtp->evt_arg1);
-			lpfc_sli_abts_recover_port(ndlp->vport, ndlp);
+			if (!hba_pci_err) {
-			free_evt = 0;
+				lpfc_sli_abts_recover_port(ndlp->vport, ndlp);
+				free_evt = 0;
+			}
 			/* decrement the node reference count held for
 			 * this queued work
 			 */
 	struct lpfc_vport **vports;
 	struct lpfc_vport *vport;
 	int i;
+	bool hba_pci_err;
+	hba_pci_err = test_bit(HBA_PCI_ERR, &phba->bit_flags);
 	spin_lock_irq(&phba->hbalock);
 	ha_copy = phba->work_ha;
 	phba->work_ha = 0;
 	spin_unlock_irq(&phba->hbalock);
+	if (hba_pci_err)
+		ha_copy = 0;
 	/* First, try to post the next mailbox command to SLI4 device */
-	if (phba->pci_dev_grp == LPFC_PCI_DEV_OC)
+	if (phba->pci_dev_grp == LPFC_PCI_DEV_OC && !hba_pci_err)
 		lpfc_sli4_post_async_mbox(phba);
 	if (ha_copy & HA_ERATT) {
 		lpfc_handle_latt(phba);
 	/* Handle VMID Events */
-	if (lpfc_is_vmid_enabled(phba)) {
+	if (lpfc_is_vmid_enabled(phba) && !hba_pci_err) {
 		if (phba->pport->work_port_events &
 		    WORKER_CHECK_VMID_ISSUE_QFPA) {
 			lpfc_check_vmid_qfpa_issue(phba);
 			work_port_events = vport->work_port_events;
 			vport->work_port_events &= ~work_port_events;
 			spin_unlock_irq(&vport->work_port_lock);
+			if (hba_pci_err)
+				continue;
 			if (work_port_events & WORKER_DISC_TMO)
 				lpfc_disc_timeout_handler(vport);
 			if (work_port_events & WORKER_ELS_TMO)
 	struct lpfc_vport **vports;
 	LPFC_MBOXQ_t          *mb;
 	int i;
+	int offline;
 	if (phba->link_state == LPFC_LINK_DOWN)
 		return 0;
 	/* Block all SCSI stack I/Os */
 	lpfc_scsi_dev_block(phba);
+	offline = pci_channel_offline(phba->pcidev);
 	phba->defer_flogi_acc_flag = false;
 	lpfc_destroy_vport_work_array(phba, vports);
 	/* Clean up any SLI3 firmware default rpi's */
-	if (phba->sli_rev > LPFC_SLI_REV3)
+	if (phba->sli_rev > LPFC_SLI_REV3 || offline)
 		goto skip_unreg_did;
 	mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 	spin_lock_irqsave(&ndlp->lock, iflags);
 	if (!(ndlp->fc4_xpt_flags & NLP_XPT_REGD)) {
 		spin_unlock_irqrestore(&ndlp->lock, iflags);
+		lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
+				 "0999 %s Not regd: ndlp x%px rport x%px DID "
+				 "x%x FLG x%x XPT x%x\n",
+				  __func__, ndlp, ndlp->rport, ndlp->nlp_DID,
+				  ndlp->nlp_flag, ndlp->fc4_xpt_flags);
 		return;
 	}
 	    ndlp->fc4_xpt_flags & SCSI_XPT_REGD) {
 		vport->phba->nport_event_cnt++;
 		lpfc_unregister_remote_port(ndlp);
+	} else if (!ndlp->rport) {
+		lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
+				 "1999 %s NDLP in devloss x%px DID x%x FLG x%x"
+				 " XPT x%x refcnt %d\n",
+				 __func__, ndlp, ndlp->nlp_DID, ndlp->nlp_flag,
+				 ndlp->fc4_xpt_flags,
+				 kref_read(&ndlp->kref));
 	}
 	if (ndlp->fc4_xpt_flags & NVME_XPT_REGD) {
 				ndlp->nlp_flag &= ~NLP_UNREG_INP;
 				mempool_free(mbox, phba->mbox_mem_pool);
 				acc_plogi = 1;
+				lpfc_nlp_put(ndlp);
 			}
 		} else {
 			lpfc_printf_vlog(vport, KERN_INFO,
 	}
 }
+/*
+ * lpfc_notify_xport_npr - notifies xport of node disappearance
+ * @vport: Pointer to Virtual Port object.
+ *
+ * Transitions all ndlps to NPR state.  When lpfc_nlp_set_state
+ * calls lpfc_nlp_state_cleanup, the ndlp->rport is unregistered
+ * and transport notified that the node is gone.
+ * Return Code:
+ *	none
+ */
+static void
+lpfc_notify_xport_npr(struct lpfc_vport *vport)
+{
+	struct lpfc_nodelist *ndlp, *next_ndlp;
+	list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
+				 nlp_listp) {
+		lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
+	}
+}
 void
 lpfc_cleanup_discovery_resources(struct lpfc_vport *vport)
 {
 	lpfc_els_flush_rscn(vport);
 	lpfc_els_flush_cmd(vport);
 	lpfc_disc_flush_list(vport);
+	if (pci_channel_offline(vport->phba->pcidev))
+		lpfc_notify_xport_npr(vport);
 }
 /*****************************************************************************/

drivers/scsi/lpfc/lpfc_init.c+63−25

@@ -95,6 +95,7 @@ static void lpfc_sli4_oas_verify(struct lpfc_hba *phba); · 94 unmodified lines
95	static uint16_t lpfc_find_cpu_handle(struct lpfc_hba *, uint16_t, int);	95	static uint16_t lpfc_find_cpu_handle(struct lpfc_hba *, uint16_t, int);
96	static void lpfc_setup_bg(struct lpfc_hba , struct Scsi_Host );	96	static void lpfc_setup_bg(struct lpfc_hba , struct Scsi_Host );
97	static int lpfc_sli4_cgn_parm_chg_evt(struct lpfc_hba *);	97	static int lpfc_sli4_cgn_parm_chg_evt(struct lpfc_hba *);
		98	static void lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba);
98		99
99	static struct scsi_transport_template *lpfc_transport_template = NULL;	100	static struct scsi_transport_template *lpfc_transport_template = NULL;
100	static struct scsi_transport_template *lpfc_vport_transport_template = NULL;	101	static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
@@ -1642,7 +1643,7 @@ lpfc_sli4_offline_eratt(struct lpfc_hba *phba) · 1541 unmodified lines
1642	{	1643	{
1643	spin_lock_irq(&phba->hbalock);	1644	spin_lock_irq(&phba->hbalock);
1644	if (phba->link_state == LPFC_HBA_ERROR &&	1645	if (phba->link_state == LPFC_HBA_ERROR &&
1645	phba->hba_flag & HBA_PCI_ERR) {	1646	test_bit(HBA_PCI_ERR, &phba->bit_flags)) {
1646	spin_unlock_irq(&phba->hbalock);	1647	spin_unlock_irq(&phba->hbalock);
1647	return;	1648	return;
1648	}	1649	}
@@ -1985,6 +1986,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba) · 336 unmodified lines
1985	if (pci_channel_offline(phba->pcidev)) {	1986	if (pci_channel_offline(phba->pcidev)) {
1986	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,	1987	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
1987	"3166 pci channel is offline\n");	1988	"3166 pci channel is offline\n");
		1989	lpfc_sli_flush_io_rings(phba);
1988	return;	1990	return;
1989	}	1991	}
1990		1992
@@ -2973,6 +2975,22 @@ lpfc_cleanup(struct lpfc_vport *vport) · 982 unmodified lines
2973	NLP_EVT_DEVICE_RM);	2975	NLP_EVT_DEVICE_RM);
2974	}	2976	}
2975		2977
		2978	/* This is a special case flush to return all
		2979	* IOs before entering this loop. There are
		2980	* two points in the code where a flush is
		2981	* avoided if the FC_UNLOADING flag is set.
		2982	* one is in the multipool destroy,
		2983	* (this prevents a crash) and the other is
		2984	* in the nvme abort handler, ( also prevents
		2985	* a crash). Both of these exceptions are
		2986	* cases where the slot is still accessible.
		2987	* The flush here is only when the pci slot
		2988	* is offline.
		2989	*/
		2990	if (vport->load_flag & FC_UNLOADING &&
		2991	pci_channel_offline(phba->pcidev))
		2992	lpfc_sli_flush_io_rings(vport->phba);
		2993
2976	/* At this point, ALL ndlp's should be gone	2994	/* At this point, ALL ndlp's should be gone
2977	* because of the previous NLP_EVT_DEVICE_RM.	2995	* because of the previous NLP_EVT_DEVICE_RM.
2978	* Lets wait for this to happen, if needed.	2996	* Lets wait for this to happen, if needed.
@@ -2985,7 +3003,7 @@ lpfc_cleanup(struct lpfc_vport *vport) · 6 unmodified lines
2985	list_for_each_entry_safe(ndlp, next_ndlp,	3003	list_for_each_entry_safe(ndlp, next_ndlp,
2986	&vport->fc_nodes, nlp_listp) {	3004	&vport->fc_nodes, nlp_listp) {
2987	lpfc_printf_vlog(ndlp->vport, KERN_ERR,	3005	lpfc_printf_vlog(ndlp->vport, KERN_ERR,
2988	LOG_TRACE_EVENT,	3006	LOG_DISCOVERY,
2989	"0282 did:x%x ndlp:x%px "	3007	"0282 did:x%x ndlp:x%px "
2990	"refcnt:%d xflags x%x nflag x%x\n",	3008	"refcnt:%d xflags x%x nflag x%x\n",
2991	ndlp->nlp_DID, (void *)ndlp,	3009	ndlp->nlp_DID, (void *)ndlp,
@@ -3682,7 +3700,8 @@ lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action) · 690 unmodified lines
3682	struct lpfc_vport **vports;	3700	struct lpfc_vport **vports;
3683	struct Scsi_Host *shost;	3701	struct Scsi_Host *shost;
3684	int i;	3702	int i;
3685	int offline = 0;	3703	int offline;
		3704	bool hba_pci_err;
3686		3705
3687	if (vport->fc_flag & FC_OFFLINE_MODE)	3706	if (vport->fc_flag & FC_OFFLINE_MODE)
3688	return;	3707	return;
@@ -3692,6 +3711,7 @@ lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action) · 3 unmodified lines
3692	lpfc_linkdown(phba);	3711	lpfc_linkdown(phba);
3693		3712
3694	offline = pci_channel_offline(phba->pcidev);	3713	offline = pci_channel_offline(phba->pcidev);
		3714	hba_pci_err = test_bit(HBA_PCI_ERR, &phba->bit_flags);
3695		3715
3696	/* Issue an unreg_login to all nodes on all vports */	3716	/* Issue an unreg_login to all nodes on all vports */
3697	vports = lpfc_create_vport_work_array(phba);	3717	vports = lpfc_create_vport_work_array(phba);
@@ -3715,11 +3735,14 @@ lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action) · 17 unmodified lines
3715	ndlp->nlp_flag &= ~NLP_NPR_ADISC;	3735	ndlp->nlp_flag &= ~NLP_NPR_ADISC;
3716	spin_unlock_irq(&ndlp->lock);	3736	spin_unlock_irq(&ndlp->lock);
3717		3737
3718	if (offline) {	3738	if (offline \|\| hba_pci_err) {
3719	spin_lock_irq(&ndlp->lock);	3739	spin_lock_irq(&ndlp->lock);
3720	ndlp->nlp_flag &= ~(NLP_UNREG_INP \|	3740	ndlp->nlp_flag &= ~(NLP_UNREG_INP \|
3721	NLP_RPI_REGISTERED);	3741	NLP_RPI_REGISTERED);
3722	spin_unlock_irq(&ndlp->lock);	3742	spin_unlock_irq(&ndlp->lock);
		3743	if (phba->sli_rev == LPFC_SLI_REV4)
		3744	lpfc_sli_rpi_release(vports[i],
		3745	ndlp);
3723	} else {	3746	} else {
3724	lpfc_unreg_rpi(vports[i], ndlp);	3747	lpfc_unreg_rpi(vports[i], ndlp);
3725	}	3748	}
@@ -13354,8 +13377,9 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba) · 9628 unmodified lines
13354	/* Abort all iocbs associated with the hba */	13377	/* Abort all iocbs associated with the hba */
13355	lpfc_sli_hba_iocb_abort(phba);	13378	lpfc_sli_hba_iocb_abort(phba);
13356		13379
13357	/* Wait for completion of device XRI exchange busy */	13380	if (!pci_channel_offline(phba->pcidev))
13358	lpfc_sli4_xri_exchange_busy_wait(phba);	13381	/* Wait for completion of device XRI exchange busy */
		13382	lpfc_sli4_xri_exchange_busy_wait(phba);
13359		13383
13360	/* per-phba callback de-registration for hotplug event */	13384	/* per-phba callback de-registration for hotplug event */
13361	if (phba->pport)	13385	if (phba->pport)
@@ -13374,15 +13398,12 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba) · 12 unmodified lines
13374	/* Disable FW logging to host memory */	13398	/* Disable FW logging to host memory */
13375	lpfc_ras_stop_fwlog(phba);	13399	lpfc_ras_stop_fwlog(phba);
13376		13400
13377	/* Unset the queues shared with the hardware then release all
13378	* allocated resources.
13379	*/
13380	lpfc_sli4_queue_unset(phba);
13381	lpfc_sli4_queue_destroy(phba);
13382
13383	/* Reset SLI4 HBA FCoE function */	13401	/* Reset SLI4 HBA FCoE function */
13384	lpfc_pci_function_reset(phba);	13402	lpfc_pci_function_reset(phba);
13385		13403
		13404	/* release all queue allocated resources. */
		13405	lpfc_sli4_queue_destroy(phba);
		13406
13386	/* Free RAS DMA memory */	13407	/* Free RAS DMA memory */
13387	if (phba->ras_fwlog.ras_enabled)	13408	if (phba->ras_fwlog.ras_enabled)
13388	lpfc_sli4_ras_dma_free(phba);	13409	lpfc_sli4_ras_dma_free(phba);
@@ -14262,6 +14283,7 @@ lpfc_sli_prep_dev_for_perm_failure(struct lpfc_hba *phba) · 873 unmodified lines
14262	"2711 PCI channel permanent disable for failure\n");	14283	"2711 PCI channel permanent disable for failure\n");
14263	/* Block all SCSI devices' I/Os on the host */	14284	/* Block all SCSI devices' I/Os on the host */
14264	lpfc_scsi_dev_block(phba);	14285	lpfc_scsi_dev_block(phba);
		14286	lpfc_sli4_prep_dev_for_reset(phba);
14265		14287
14266	/* stop all timers */	14288	/* stop all timers */
14267	lpfc_stop_hba_timers(phba);	14289	lpfc_stop_hba_timers(phba);
@@ -15057,24 +15079,28 @@ lpfc_sli4_prep_dev_for_recover(struct lpfc_hba *phba) · 789 unmodified lines
15057	static void	15079	static void
15058	lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)	15080	lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)
15059	{	15081	{
15060	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,	15082	int offline = pci_channel_offline(phba->pcidev);
15061	"2826 PCI channel disable preparing for reset\n");	15083
		15084	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
		15085	"2826 PCI channel disable preparing for reset offline"
		15086	" %d\n", offline);
15062		15087
15063	/* Block any management I/Os to the device */	15088	/* Block any management I/Os to the device */
15064	lpfc_block_mgmt_io(phba, LPFC_MBX_NO_WAIT);	15089	lpfc_block_mgmt_io(phba, LPFC_MBX_NO_WAIT);
15065		15090
15066	/* Block all SCSI devices' I/Os on the host */
15067	lpfc_scsi_dev_block(phba);
15068		15091
		15092	/* HBA_PCI_ERR was set in io_error_detect */
		15093	lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
15069	/* Flush all driver's outstanding I/Os as we are to reset */	15094	/* Flush all driver's outstanding I/Os as we are to reset */
15070	lpfc_sli_flush_io_rings(phba);	15095	lpfc_sli_flush_io_rings(phba);
		15096	lpfc_offline(phba);
15071		15097
15072	/* stop all timers */	15098	/* stop all timers */
15073	lpfc_stop_hba_timers(phba);	15099	lpfc_stop_hba_timers(phba);
15074		15100
		15101	lpfc_sli4_queue_destroy(phba);
15075	/* Disable interrupt and pci device */	15102	/* Disable interrupt and pci device */
15076	lpfc_sli4_disable_intr(phba);	15103	lpfc_sli4_disable_intr(phba);
15077	lpfc_sli4_queue_destroy(phba);
15078	pci_disable_device(phba->pcidev);	15104	pci_disable_device(phba->pcidev);
15079	}	15105	}
15080		15106
@@ -15123,6 +15149,7 @@ lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state) · 42 unmodified lines
15123	{	15149	{
15124	struct Scsi_Host *shost = pci_get_drvdata(pdev);	15150	struct Scsi_Host *shost = pci_get_drvdata(pdev);
15125	struct lpfc_hba phba = ((struct lpfc_vport )shost->hostdata)->phba;	15151	struct lpfc_hba phba = ((struct lpfc_vport )shost->hostdata)->phba;
		15152	bool hba_pci_err;
15126		15153
15127	switch (state) {	15154	switch (state) {
15128	case pci_channel_io_normal:	15155	case pci_channel_io_normal:
@@ -15130,17 +15157,24 @@ lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state) · 1 unmodified line
15130	lpfc_sli4_prep_dev_for_recover(phba);	15157	lpfc_sli4_prep_dev_for_recover(phba);
15131	return PCI_ERS_RESULT_CAN_RECOVER;	15158	return PCI_ERS_RESULT_CAN_RECOVER;
15132	case pci_channel_io_frozen:	15159	case pci_channel_io_frozen:
15133	phba->hba_flag \|= HBA_PCI_ERR;	15160	hba_pci_err = test_and_set_bit(HBA_PCI_ERR, &phba->bit_flags);
15134	/* Fatal error, prepare for slot reset */	15161	/* Fatal error, prepare for slot reset */
15135	lpfc_sli4_prep_dev_for_reset(phba);	15162	if (!hba_pci_err)
		15163	lpfc_sli4_prep_dev_for_reset(phba);
		15164	else
		15165	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
		15166	"2832 Already handling PCI error "
		15167	"state: x%x\n", state);
15136	return PCI_ERS_RESULT_NEED_RESET;	15168	return PCI_ERS_RESULT_NEED_RESET;
15137	case pci_channel_io_perm_failure:	15169	case pci_channel_io_perm_failure:
15138	phba->hba_flag \|= HBA_PCI_ERR;	15170	set_bit(HBA_PCI_ERR, &phba->bit_flags);
15139	/* Permanent failure, prepare for device down */	15171	/* Permanent failure, prepare for device down */
15140	lpfc_sli4_prep_dev_for_perm_failure(phba);	15172	lpfc_sli4_prep_dev_for_perm_failure(phba);
15141	return PCI_ERS_RESULT_DISCONNECT;	15173	return PCI_ERS_RESULT_DISCONNECT;
15142	default:	15174	default:
15143	phba->hba_flag \|= HBA_PCI_ERR;	15175	hba_pci_err = test_and_set_bit(HBA_PCI_ERR, &phba->bit_flags);
		15176	if (!hba_pci_err)
		15177	lpfc_sli4_prep_dev_for_reset(phba);
15144	/* Unknown state, prepare and request slot reset */	15178	/* Unknown state, prepare and request slot reset */
15145	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,	15179	lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
15146	"2825 Unknown PCI error state: x%x\n", state);	15180	"2825 Unknown PCI error state: x%x\n", state);
@@ -15174,17 +15208,21 @@ lpfc_io_slot_reset_s4(struct pci_dev *pdev) · 27 unmodified lines
15174	struct lpfc_hba phba = ((struct lpfc_vport )shost->hostdata)->phba;	15208	struct lpfc_hba phba = ((struct lpfc_vport )shost->hostdata)->phba;
15175	struct lpfc_sli *psli = &phba->sli;	15209	struct lpfc_sli *psli = &phba->sli;
15176	uint32_t intr_mode;	15210	uint32_t intr_mode;
		15211	bool hba_pci_err;
15177		15212
15178	dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");	15213	dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
15179	if (pci_enable_device_mem(pdev)) {	15214	if (pci_enable_device_mem(pdev)) {
15180	printk(KERN_ERR "lpfc: Cannot re-enable "	15215	printk(KERN_ERR "lpfc: Cannot re-enable "
15181	"PCI device after reset.\n");	15216	"PCI device after reset.\n");
15182	return PCI_ERS_RESULT_DISCONNECT;	15217	return PCI_ERS_RESULT_DISCONNECT;
15183	}	15218	}
15184		15219
15185	pci_restore_state(pdev);	15220	pci_restore_state(pdev);
15186		15221
15187	phba->hba_flag &= ~HBA_PCI_ERR;	15222	hba_pci_err = test_and_clear_bit(HBA_PCI_ERR, &phba->bit_flags);
		15223	if (!hba_pci_err)
		15224	dev_info(&pdev->dev,
		15225	"hba_pci_err was not set, recovering slot reset.\n");
15188	/*	15226	/*
15189	* As the new kernel behavior of pci_restore_state() API call clears	15227	* As the new kernel behavior of pci_restore_state() API call clears
15190	* device saved_state flag, need to save the restored state again.	15228	* device saved_state flag, need to save the restored state again.
@@ -15198,6 +15236,8 @@ lpfc_io_slot_reset_s4(struct pci_dev *pdev) · 7 unmodified lines
15198	psli->sli_flag &= ~LPFC_SLI_ACTIVE;	15236	psli->sli_flag &= ~LPFC_SLI_ACTIVE;
15199	spin_unlock_irq(&phba->hbalock);	15237	spin_unlock_irq(&phba->hbalock);
15200		15238
		15239	/* Init cpu_map array */
		15240	lpfc_cpu_map_array_init(phba);
15201	/* Configure and enable interrupt */	15241	/* Configure and enable interrupt */
15202	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);	15242	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
15203	if (intr_mode == LPFC_INTR_ERROR) {	15243	if (intr_mode == LPFC_INTR_ERROR) {
@@ -15239,8 +15279,6 @@ lpfc_io_resume_s4(struct pci_dev *pdev) · 35 unmodified lines
15239	*/	15279	*/
15240	if (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)) {	15280	if (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)) {
15241	/* Perform device reset */	15281	/* Perform device reset */
15242	lpfc_offline_prep(phba, LPFC_MBX_WAIT);
15243	lpfc_offline(phba);
15244	lpfc_sli_brdrestart(phba);	15282	lpfc_sli_brdrestart(phba);
15245	/* Bring the device back online */	15283	/* Bring the device back online */
15246	lpfc_online(phba);	15284	lpfc_online(phba);

drivers/scsi/lpfc/lpfc_nvme.c+18−9

 	lport = (struct lpfc_nvme_lport *)pnvme_lport->private;
 	vport = lport->vport;
+	if (!vport || vport->load_flag & FC_UNLOADING ||
+	    vport->phba->hba_flag & HBA_IOQ_FLUSH)
+		return -ENODEV;
 	qhandle = kzalloc(sizeof(struct lpfc_nvme_qhandle), GFP_KERNEL);
 	if (qhandle == NULL)
 		return -ENOMEM;
 		return -EINVAL;
 	remoteport = lpfc_rport->remoteport;
-	if (!vport->localport)
+	if (!vport->localport ||
+	    vport->phba->hba_flag & HBA_IOQ_FLUSH)
 		return -EINVAL;
 	lport = vport->localport->private;
 				 ndlp->nlp_DID, ntype, nstate);
 		return -ENODEV;
 	}
+	if (vport->phba->hba_flag & HBA_IOQ_FLUSH)
+		return -ENODEV;
 	if (!vport->phba->sli4_hba.nvmels_wq)
 		return -ENOMEM;
 		return -EINVAL;
 	vport = lport->vport;
-	if (vport->load_flag & FC_UNLOADING)
+	if (vport->load_flag & FC_UNLOADING ||
+	    vport->phba->hba_flag & HBA_IOQ_FLUSH)
 		return -ENODEV;
 	atomic_inc(&lport->fc4NvmeLsRequests);
 	phba = vport->phba;
-	if (unlikely(vport->load_flag & FC_UNLOADING)) {
+	if ((unlikely(vport->load_flag & FC_UNLOADING)) ||
+	    phba->hba_flag & HBA_IOQ_FLUSH) {
 		lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME_IOERR,
 				 "6124 Fail IO, Driver unload\n");
 		atomic_inc(&lport->xmt_fcp_err);
 			abts_nvme = 0;
 			for (i = 0; i < phba->cfg_hdw_queue; i++) {
 				qp = &phba->sli4_hba.hdwq[i];
-				if (!vport || !vport->localport ||
+				if (!vport->localport || !qp || !qp->io_wq)
-				    !qp || !qp->io_wq)
 					return;
 				pring = qp->io_wq->pring;
 				abts_scsi += qp->abts_scsi_io_bufs;
 				abts_nvme += qp->abts_nvme_io_bufs;
 			}
-			if (!vport || !vport->localport ||
+			if (!vport->localport ||
-			    vport->phba->hba_flag & HBA_PCI_ERR)
+			    test_bit(HBA_PCI_ERR, &vport->phba->bit_flags) ||
+			    vport->load_flag & FC_UNLOADING)
 				return;
 			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
 		 * return values is ignored.  The upcall is a courtesy to the
 		 * transport.
 		 */
-		if (vport->load_flag & FC_UNLOADING ||
+		if (vport->load_flag & FC_UNLOADING)
-		    unlikely(vport->phba->hba_flag & HBA_PCI_ERR))
 			(void)nvme_fc_set_remoteport_devloss(remoteport, 0);
 		ret = nvme_fc_unregister_remoteport(remoteport);

drivers/scsi/lpfc/lpfc_scsi.c+7−5

@@ -5929,13 +5929,15 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd) · 5928 unmodified lines
5929	}	5929	}
5930		5930
5931	lpfc_cmd->waitq = &waitq;	5931	lpfc_cmd->waitq = &waitq;
5932	if (phba->sli_rev == LPFC_SLI_REV4)	5932	if (phba->sli_rev == LPFC_SLI_REV4) {
5933	spin_unlock(&pring_s4->ring_lock);	5933	spin_unlock(&pring_s4->ring_lock);
5934	else	5934	ret_val = lpfc_sli4_issue_abort_iotag(phba, iocb,
		5935	lpfc_sli_abort_fcp_cmpl);
		5936	} else {
5935	pring = &phba->sli.sli3_ring[LPFC_FCP_RING];	5937	pring = &phba->sli.sli3_ring[LPFC_FCP_RING];
5936		5938	ret_val = lpfc_sli_issue_abort_iotag(phba, pring, iocb,
5937	ret_val = lpfc_sli_issue_abort_iotag(phba, pring, iocb,	5939	lpfc_sli_abort_fcp_cmpl);
5938	lpfc_sli_abort_fcp_cmpl);	5940	}
5939		5941
5940	/* Make sure HBA is alive */	5942	/* Make sure HBA is alive */
5941	lpfc_issue_hb_tmo(phba);	5943	lpfc_issue_hb_tmo(phba);

drivers/scsi/lpfc/lpfc_sli.c+53−22

 	ndlp->nlp_flag &= ~NLP_UNREG_INP;
 }
+void
+lpfc_sli_rpi_release(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
+{
+	__lpfc_sli_rpi_release(vport, ndlp);
+}
 /**
  * lpfc_sli_def_mbox_cmpl - Default mailbox completion handler
  * @phba: Pointer to HBA context object.
 	unsigned long iflag;
 	u32 ulp_command, ulp_status, ulp_word4, ulp_context, iotag;
+	if (phba->sli_rev == LPFC_SLI_REV4)
+		spin_lock_irqsave(&pring->ring_lock, iflag);
+	else
+		spin_lock_irqsave(&phba->hbalock, iflag);
 	cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
+	if (phba->sli_rev == LPFC_SLI_REV4)
+		spin_unlock_irqrestore(&pring->ring_lock, iflag);
+	else
+		spin_unlock_irqrestore(&phba->hbalock, iflag);
 	ulp_command = get_job_cmnd(phba, saveq);
 	ulp_status = get_job_ulpstatus(phba, saveq);
 				break;
 			}
-			spin_unlock_irqrestore(&phba->hbalock, iflag);
 			cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
 							 &rspiocbq);
-			spin_lock_irqsave(&phba->hbalock, iflag);
 			if (unlikely(!cmdiocbq))
 				break;
 			if (cmdiocbq->cmd_flag & LPFC_DRIVER_ABORTED)
 void
 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
 {
-	LIST_HEAD(completions);
+	LIST_HEAD(tx_completions);
+	LIST_HEAD(txcmplq_completions);
 	struct lpfc_iocbq *iocb, *next_iocb;
+	int offline;
 	if (pring->ringno == LPFC_ELS_RING) {
 		lpfc_fabric_abort_hba(phba);
 	}
+	offline = pci_channel_offline(phba->pcidev);
 	/* Error everything on txq and txcmplq
 	 * First do the txq.
 	 */
 	if (phba->sli_rev >= LPFC_SLI_REV4) {
 		spin_lock_irq(&pring->ring_lock);
-		list_splice_init(&pring->txq, &completions);
+		list_splice_init(&pring->txq, &tx_completions);
 		pring->txq_cnt = 0;
-		spin_unlock_irq(&pring->ring_lock);
-		spin_lock_irq(&phba->hbalock);
+		if (offline) {
-		/* Next issue ABTS for everything on the txcmplq */
+			list_splice_init(&pring->txcmplq,
-		list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
+					 &txcmplq_completions);
-			lpfc_sli_issue_abort_iotag(phba, pring, iocb, NULL);
+		} else {
-		spin_unlock_irq(&phba->hbalock);
+			/* Next issue ABTS for everything on the txcmplq */
+			list_for_each_entry_safe(iocb, next_iocb,
+						 &pring->txcmplq, list)
+				lpfc_sli_issue_abort_iotag(phba, pring,
+							   iocb, NULL);
+		}
+		spin_unlock_irq(&pring->ring_lock);
 	} else {
 		spin_lock_irq(&phba->hbalock);
-		list_splice_init(&pring->txq, &completions);
+		list_splice_init(&pring->txq, &tx_completions);
 		pring->txq_cnt = 0;
-		/* Next issue ABTS for everything on the txcmplq */
+		if (offline) {
-		list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list)
+			list_splice_init(&pring->txcmplq, &txcmplq_completions);
-			lpfc_sli_issue_abort_iotag(phba, pring, iocb, NULL);
+		} else {
+			/* Next issue ABTS for everything on the txcmplq */
+			list_for_each_entry_safe(iocb, next_iocb,
+						 &pring->txcmplq, list)
+				lpfc_sli_issue_abort_iotag(phba, pring,
+							   iocb, NULL);
+		}
 		spin_unlock_irq(&phba->hbalock);
 	}
-	/* Make sure HBA is alive */
-	lpfc_issue_hb_tmo(phba);
+	if (offline) {
+		/* Cancel all the IOCBs from the completions list */
+		lpfc_sli_cancel_iocbs(phba, &txcmplq_completions,
+				      IOSTAT_LOCAL_REJECT, IOERR_SLI_ABORTED);
+	} else {
+		/* Make sure HBA is alive */
+		lpfc_issue_hb_tmo(phba);
+	}
 	/* Cancel all the IOCBs from the completions list */
-	lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
+	lpfc_sli_cancel_iocbs(phba, &tx_completions, IOSTAT_LOCAL_REJECT,
 			      IOERR_SLI_ABORTED);
 }
 	struct lpfc_iocbq *piocb, *next_iocb;
 	spin_lock_irq(&phba->hbalock);
-	if (phba->hba_flag & HBA_IOQ_FLUSH ||
-	    !phba->sli4_hba.hdwq) {
-		spin_unlock_irq(&phba->hbalock);
-		return;
-	}
 	/* Indicate the I/O queues are flushed */
 	phba->hba_flag |= HBA_IOQ_FLUSH;
 	spin_unlock_irq(&phba->hbalock);
 	unsigned long iflags;
 	int rc;
+	/* If the PCI channel is in offline state, do not post iocbs. */
+	if (unlikely(pci_channel_offline(phba->pcidev)))
+		return IOCB_ERROR;
 	if (phba->sli_rev == LPFC_SLI_REV4) {
 		lpfc_sli_prep_wqe(phba, piocb);

drivers/scsi/lpfc/lpfc_version.h+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20	* included with this package. *	20	* included with this package. *
21	*******************************************************************/	21	*******************************************************************/
22		22
23	#define LPFC_DRIVER_VERSION "14.2.0.0"	23	#define LPFC_DRIVER_VERSION "14.2.0.1"
24	#define LPFC_DRIVER_NAME "lpfc"	24	#define LPFC_DRIVER_NAME "lpfc"
25		25
26	/* Used for SLI 2/3 */	26	/* Used for SLI 2/3 */

drivers/scsi/megaraid/megaraid_sas.h+3−0

@@ -2560,6 +2560,9 @@ struct megasas_instance_template { · 2559 unmodified lines
2560	#define MEGASAS_IS_LOGICAL(sdev) \	2560	#define MEGASAS_IS_LOGICAL(sdev) \
2561	((sdev->channel < MEGASAS_MAX_PD_CHANNELS) ? 0 : 1)	2561	((sdev->channel < MEGASAS_MAX_PD_CHANNELS) ? 0 : 1)
2562		2562
		2563	#define MEGASAS_IS_LUN_VALID(sdev) \
		2564	(((sdev)->lun == 0) ? 1 : 0)
		2565
2563	#define MEGASAS_DEV_INDEX(scp) \	2566	#define MEGASAS_DEV_INDEX(scp) \
2564	(((scp->device->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL) + \	2567	(((scp->device->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL) + \
2565	scp->device->id)	2568	scp->device->id)

drivers/scsi/megaraid/megaraid_sas_base.c+7−0

 			goto scan_target;
 		}
 		return -ENXIO;
+	} else if (!MEGASAS_IS_LUN_VALID(sdev)) {
+		sdev_printk(KERN_INFO, sdev, "%s: invalid LUN\n", __func__);
+		return -ENXIO;
 	}
 scan_target:
 	instance = megasas_lookup_instance(sdev->host->host_no);
 	if (MEGASAS_IS_LOGICAL(sdev)) {
+		if (!MEGASAS_IS_LUN_VALID(sdev)) {
+			sdev_printk(KERN_INFO, sdev, "%s: invalid LUN\n", __func__);
+			return;
+		}
 		ld_tgt_id = MEGASAS_TARGET_ID(sdev);
 		instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_DELETED;
 		if (megasas_dbg_lvl & LD_PD_DEBUG)

drivers/scsi/mpt3sas/mpt3sas_base.c+1−2

@@ -5716,13 +5716,12 @@ _base_release_memory_pools(struct MPT3SAS_ADAPTER *ioc) · 5715 unmodified lines
5716	/**	5716	/**
5717	* mpt3sas_check_same_4gb_region - checks whether all reply queues in a set are	5717	* mpt3sas_check_same_4gb_region - checks whether all reply queues in a set are
5718	* having same upper 32bits in their base memory address.	5718	* having same upper 32bits in their base memory address.
5719	* @reply_pool_start_address: Base address of a reply queue set	5719	* @start_address: Base address of a reply queue set
5720	* @pool_sz: Size of single Reply Descriptor Post Queues pool size	5720	* @pool_sz: Size of single Reply Descriptor Post Queues pool size
5721	*	5721	*
5722	* Return: 1 if reply queues in a set have a same upper 32bits in their base	5722	* Return: 1 if reply queues in a set have a same upper 32bits in their base
5723	* memory address, else 0.	5723	* memory address, else 0.
5724	*/	5724	*/
5725
5726	static int	5725	static int
5727	mpt3sas_check_same_4gb_region(dma_addr_t start_address, u32 pool_sz)	5726	mpt3sas_check_same_4gb_region(dma_addr_t start_address, u32 pool_sz)
5728	{	5727	{

drivers/scsi/mpt3sas/mpt3sas_config.c+6−3

 		retry_count++;
 		if (ioc->config_cmds.smid == smid)
 			mpt3sas_base_free_smid(ioc, smid);
-		if ((ioc->shost_recovery) || (ioc->config_cmds.status &
+		if (ioc->config_cmds.status & MPT3_CMD_RESET)
-		    MPT3_CMD_RESET) || ioc->pci_error_recovery)
 			goto retry_config;
-		issue_host_reset = 1;
+		if (ioc->shost_recovery || ioc->pci_error_recovery) {
+			issue_host_reset = 0;
+			r = -EFAULT;
+		} else
+			issue_host_reset = 1;
 		goto free_mem;
 	}

drivers/scsi/mpt3sas/mpt3sas_scsih.c+4−1

 {
 	struct _sas_port *mpt3sas_port, *next;
 	unsigned long flags;
+	int port_id;
 	/* remove sibling ports attached to this expander */
 	list_for_each_entry_safe(mpt3sas_port, next,
 			    mpt3sas_port->hba_port);
 	}
+	port_id = sas_expander->port->port_id;
 	mpt3sas_transport_port_remove(ioc, sas_expander->sas_address,
 	    sas_expander->sas_address_parent, sas_expander->port);
 	    "expander_remove: handle(0x%04x), sas_addr(0x%016llx), port:%d\n",
 	    sas_expander->handle, (unsigned long long)
 	    sas_expander->sas_address,
-	    sas_expander->port->port_id);
+	    port_id);
 	spin_lock_irqsave(&ioc->sas_node_lock, flags);
 	list_del(&sas_expander->list);

drivers/scsi/mvsas/mv_init.c+1−0

@@ -647,6 +647,7 @@ static struct pci_device_id mvs_pci_table[] = { · 646 unmodified lines
647	{ PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1300), chip_1300 },	647	{ PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1300), chip_1300 },
648	{ PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1320), chip_1320 },	648	{ PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1320), chip_1320 },
649	{ PCI_VDEVICE(ADAPTEC2, 0x0450), chip_6440 },	649	{ PCI_VDEVICE(ADAPTEC2, 0x0450), chip_6440 },
		650	{ PCI_VDEVICE(TTI, 0x2640), chip_6440 },
650	{ PCI_VDEVICE(TTI, 0x2710), chip_9480 },	651	{ PCI_VDEVICE(TTI, 0x2710), chip_9480 },
651	{ PCI_VDEVICE(TTI, 0x2720), chip_9480 },	652	{ PCI_VDEVICE(TTI, 0x2720), chip_9480 },
652	{ PCI_VDEVICE(TTI, 0x2721), chip_9480 },	653	{ PCI_VDEVICE(TTI, 0x2721), chip_9480 },

drivers/scsi/pcmcia/sym53c500_cs.c+25−27

 	int fast_pio;
 };
-static struct scsi_pointer *sym53c500_scsi_pointer(struct scsi_cmnd *cmd)
+struct sym53c500_cmd_priv {
-{
+	int status;
-	return scsi_cmd_priv(cmd);
+	int message;
-}
+	int phase;
+};
 enum Phase {
     idle,
 	struct sym53c500_data *data =
 	    (struct sym53c500_data *)dev->hostdata;
 	struct scsi_cmnd *curSC = data->current_SC;
-	struct scsi_pointer *scsi_pointer = sym53c500_scsi_pointer(curSC);
+	struct sym53c500_cmd_priv *scp = scsi_cmd_priv(curSC);
 	int fast_pio = data->fast_pio;
 	spin_lock_irqsave(dev->host_lock, flags);
 	if (int_reg & 0x20) {		/* Disconnect */
 		DEB(printk("SYM53C500: disconnect intr received\n"));
-		if (scsi_pointer->phase != message_in) {	/* Unexpected disconnect */
+		if (scp->phase != message_in) {	/* Unexpected disconnect */
 			curSC->result = DID_NO_CONNECT << 16;
 		} else {	/* Command complete, return status and message */
-			curSC->result = (scsi_pointer->Status & 0xff) |
+			curSC->result = (scp->status & 0xff) |
-				((scsi_pointer->Message & 0xff) << 8) |
+				((scp->message & 0xff) << 8) | (DID_OK << 16);
-				(DID_OK << 16);
 		}
 		goto idle_out;
 	}
 			struct scatterlist *sg;
 			int i;
-			scsi_pointer->phase = data_out;
+			scp->phase = data_out;
 			VDEB(printk("SYM53C500: Data-Out phase\n"));
 			outb(FLUSH_FIFO, port_base + CMD_REG);
 			LOAD_DMA_COUNT(port_base, scsi_bufflen(curSC));	/* Max transfer size */
 			struct scatterlist *sg;
 			int i;
-			scsi_pointer->phase = data_in;
+			scp->phase = data_in;
 			VDEB(printk("SYM53C500: Data-In phase\n"));
 			outb(FLUSH_FIFO, port_base + CMD_REG);
 			LOAD_DMA_COUNT(port_base, scsi_bufflen(curSC));	/* Max transfer size */
 		break;
 	case 0x02:		/* COMMAND */
-		scsi_pointer->phase = command_ph;
+		scp->phase = command_ph;
 		printk("SYM53C500: Warning: Unknown interrupt occurred in command phase!\n");
 		break;
 	case 0x03:		/* STATUS */
-		scsi_pointer->phase = status_ph;
+		scp->phase = status_ph;
 		VDEB(printk("SYM53C500: Status phase\n"));
 		outb(FLUSH_FIFO, port_base + CMD_REG);
 		outb(INIT_CMD_COMPLETE, port_base + CMD_REG);
 	case 0x06:		/* MESSAGE-OUT */
 		DEB(printk("SYM53C500: Message-Out phase\n"));
-		scsi_pointer->phase = message_out;
+		scp->phase = message_out;
 		outb(SET_ATN, port_base + CMD_REG);	/* Reject the message */
 		outb(MSG_ACCEPT, port_base + CMD_REG);
 		break;
 	case 0x07:		/* MESSAGE-IN */
 		VDEB(printk("SYM53C500: Message-In phase\n"));
-		scsi_pointer->phase = message_in;
+		scp->phase = message_in;
-		scsi_pointer->Status = inb(port_base + SCSI_FIFO);
+		scp->status = inb(port_base + SCSI_FIFO);
-		scsi_pointer->Message = inb(port_base + SCSI_FIFO);
+		scp->message = inb(port_base + SCSI_FIFO);
 		VDEB(printk("SCSI FIFO size=%d\n", inb(port_base + FIFO_FLAGS) & 0x1f));
-		DEB(printk("Status = %02x  Message = %02x\n",
+		DEB(printk("Status = %02x  Message = %02x\n", scp->status, scp->message));
-			   scsi_pointer->Status, scsi_pointer->Message));
-		if (scsi_pointer->Message == SAVE_POINTERS ||
+		if (scp->message == SAVE_POINTERS || scp->message == DISCONNECT) {
-		    scsi_pointer->Message == DISCONNECT) {
 			outb(SET_ATN, port_base + CMD_REG);	/* Reject message */
 			DEB(printk("Discarding SAVE_POINTERS message\n"));
 		}
 	return IRQ_HANDLED;
 idle_out:
-	scsi_pointer->phase = idle;
+	scp->phase = idle;
 	scsi_done(curSC);
 	goto out;
 }
 static int SYM53C500_queue_lck(struct scsi_cmnd *SCpnt)
 {
-	struct scsi_pointer *scsi_pointer = sym53c500_scsi_pointer(SCpnt);
+	struct sym53c500_cmd_priv *scp = scsi_cmd_priv(SCpnt);
 	int i;
 	int port_base = SCpnt->device->host->io_port;
 	struct sym53c500_data *data =
 	VDEB(printk("\n"));
 	data->current_SC = SCpnt;
-	scsi_pointer->phase = command_ph;
+	scp->phase = command_ph;
-	scsi_pointer->Status = 0;
+	scp->status = 0;
-	scsi_pointer->Message = 0;
+	scp->message = 0;
 	/* We are locked here already by the mid layer */
 	REG0(port_base);
      .this_id			= 7,
      .sg_tablesize		= 32,
      .shost_groups		= SYM53C500_shost_groups,
-     .cmd_size			= sizeof(struct scsi_pointer),
+     .cmd_size			= sizeof(struct sym53c500_cmd_priv),
 };
 static int SYM53C500_config_check(struct pcmcia_device *p_dev, void *priv_data)

drivers/scsi/pmcraid.c+0−491

@@ -3181,124 +3181,6 @@ static int pmcraid_build_ioadl( · 3180 unmodified lines
3181	return 0;	3181	return 0;
3182	}	3182	}
3183		3183
3184	/**
3185	* pmcraid_free_sglist - Frees an allocated SG buffer list
3186	* @sglist: scatter/gather list pointer
3187	*
3188	* Free a DMA'able memory previously allocated with pmcraid_alloc_sglist
3189	*
3190	* Return value:
3191	* none
3192	*/
3193	static void pmcraid_free_sglist(struct pmcraid_sglist *sglist)
3194	{
3195	sgl_free_order(sglist->scatterlist, sglist->order);
3196	kfree(sglist);
3197	}
3198
3199	/**
3200	* pmcraid_alloc_sglist - Allocates memory for a SG list
3201	* @buflen: buffer length
3202	*
3203	* Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3204	* list.
3205	*
3206	* Return value
3207	* pointer to sglist / NULL on failure
3208	*/
3209	static struct pmcraid_sglist *pmcraid_alloc_sglist(int buflen)
3210	{
3211	struct pmcraid_sglist *sglist;
3212	int sg_size;
3213	int order;
3214
3215	sg_size = buflen / (PMCRAID_MAX_IOADLS - 1);
3216	order = (sg_size > 0) ? get_order(sg_size) : 0;
3217
3218	/* Allocate a scatter/gather list for the DMA */
3219	sglist = kzalloc(sizeof(struct pmcraid_sglist), GFP_KERNEL);
3220	if (sglist == NULL)
3221	return NULL;
3222
3223	sglist->order = order;
3224	sgl_alloc_order(buflen, order, false, GFP_KERNEL \| __GFP_ZERO,
3225	&sglist->num_sg);
3226
3227	return sglist;
3228	}
3229
3230	/**
3231	* pmcraid_copy_sglist - Copy user buffer to kernel buffer's SG list
3232	* @sglist: scatter/gather list pointer
3233	* @buffer: buffer pointer
3234	* @len: buffer length
3235	* @direction: data transfer direction
3236	*
3237	* Copy a user buffer into a buffer allocated by pmcraid_alloc_sglist
3238	*
3239	* Return value:
3240	* 0 on success / other on failure
3241	*/
3242	static int pmcraid_copy_sglist(
3243	struct pmcraid_sglist *sglist,
3244	void __user *buffer,
3245	u32 len,
3246	int direction
3247	)
3248	{
3249	struct scatterlist *sg;
3250	void *kaddr;
3251	int bsize_elem;
3252	int i;
3253	int rc = 0;
3254
3255	/* Determine the actual number of bytes per element */
3256	bsize_elem = PAGE_SIZE * (1 << sglist->order);
3257
3258	sg = sglist->scatterlist;
3259
3260	for (i = 0; i < (len / bsize_elem); i++, sg = sg_next(sg), buffer += bsize_elem) {
3261	struct page *page = sg_page(sg);
3262
3263	kaddr = kmap(page);
3264	if (direction == DMA_TO_DEVICE)
3265	rc = copy_from_user(kaddr, buffer, bsize_elem);
3266	else
3267	rc = copy_to_user(buffer, kaddr, bsize_elem);
3268
3269	kunmap(page);
3270
3271	if (rc) {
3272	pmcraid_err("failed to copy user data into sg list\n");
3273	return -EFAULT;
3274	}
3275
3276	sg->length = bsize_elem;
3277	}
3278
3279	if (len % bsize_elem) {
3280	struct page *page = sg_page(sg);
3281
3282	kaddr = kmap(page);
3283
3284	if (direction == DMA_TO_DEVICE)
3285	rc = copy_from_user(kaddr, buffer, len % bsize_elem);
3286	else
3287	rc = copy_to_user(buffer, kaddr, len % bsize_elem);
3288
3289	kunmap(page);
3290
3291	sg->length = len % bsize_elem;
3292	}
3293
3294	if (rc) {
3295	pmcraid_err("failed to copy user data into sg list\n");
3296	rc = -EFAULT;
3297	}
3298
3299	return rc;
3300	}
3301
3302	/**	3184	/**
3303	* pmcraid_queuecommand_lck - Queue a mid-layer request	3185	* pmcraid_queuecommand_lck - Queue a mid-layer request
3304	* @scsi_cmd: scsi command struct	3186	* @scsi_cmd: scsi command struct
@@ -3454,365 +3336,6 @@ static int pmcraid_chr_fasync(int fd, struct file *filep, int mode) · 149 unmodified lines
3454	return rc;	3336	return rc;
3455	}	3337	}
3456		3338
3457
3458	/**
3459	* pmcraid_build_passthrough_ioadls - builds SG elements for passthrough
3460	* commands sent over IOCTL interface
3461	*
3462	* @cmd : pointer to struct pmcraid_cmd
3463	* @buflen : length of the request buffer
3464	* @direction : data transfer direction
3465	*
3466	* Return value
3467	* 0 on success, non-zero error code on failure
3468	*/
3469	static int pmcraid_build_passthrough_ioadls(
3470	struct pmcraid_cmd *cmd,
3471	int buflen,
3472	int direction
3473	)
3474	{
3475	struct pmcraid_sglist *sglist = NULL;
3476	struct scatterlist *sg = NULL;
3477	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
3478	struct pmcraid_ioadl_desc *ioadl;
3479	int i;
3480
3481	sglist = pmcraid_alloc_sglist(buflen);
3482
3483	if (!sglist) {
3484	pmcraid_err("can't allocate memory for passthrough SGls\n");
3485	return -ENOMEM;
3486	}
3487
3488	sglist->num_dma_sg = dma_map_sg(&cmd->drv_inst->pdev->dev,
3489	sglist->scatterlist,
3490	sglist->num_sg, direction);
3491
3492	if (!sglist->num_dma_sg \|\| sglist->num_dma_sg > PMCRAID_MAX_IOADLS) {
3493	dev_err(&cmd->drv_inst->pdev->dev,
3494	"Failed to map passthrough buffer!\n");
3495	pmcraid_free_sglist(sglist);
3496	return -EIO;
3497	}
3498
3499	cmd->sglist = sglist;
3500	ioarcb->request_flags0 \|= NO_LINK_DESCS;
3501
3502	ioadl = pmcraid_init_ioadls(cmd, sglist->num_dma_sg);
3503
3504	/* Initialize IOADL descriptor addresses */
3505	for_each_sg(sglist->scatterlist, sg, sglist->num_dma_sg, i) {
3506	ioadl[i].data_len = cpu_to_le32(sg_dma_len(sg));
3507	ioadl[i].address = cpu_to_le64(sg_dma_address(sg));
3508	ioadl[i].flags = 0;
3509	}
3510
3511	/* setup the last descriptor */
3512	ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;
3513
3514	return 0;
3515	}
3516
3517
3518	/**
3519	* pmcraid_release_passthrough_ioadls - release passthrough ioadls
3520	*
3521	* @cmd: pointer to struct pmcraid_cmd for which ioadls were allocated
3522	* @buflen: size of the request buffer
3523	* @direction: data transfer direction
3524	*
3525	* Return value
3526	* 0 on success, non-zero error code on failure
3527	*/
3528	static void pmcraid_release_passthrough_ioadls(
3529	struct pmcraid_cmd *cmd,
3530	int buflen,
3531	int direction
3532	)
3533	{
3534	struct pmcraid_sglist *sglist = cmd->sglist;
3535
3536	if (buflen > 0) {
3537	dma_unmap_sg(&cmd->drv_inst->pdev->dev,
3538	sglist->scatterlist,
3539	sglist->num_sg,
3540	direction);
3541	pmcraid_free_sglist(sglist);
3542	cmd->sglist = NULL;
3543	}
3544	}
3545
3546	/**
3547	* pmcraid_ioctl_passthrough - handling passthrough IOCTL commands
3548	*
3549	* @pinstance: pointer to adapter instance structure
3550	* @ioctl_cmd: ioctl code
3551	* @buflen: unused
3552	* @arg: pointer to pmcraid_passthrough_buffer user buffer
3553	*
3554	* Return value
3555	* 0 on success, non-zero error code on failure
3556	*/
3557	static long pmcraid_ioctl_passthrough(
3558	struct pmcraid_instance *pinstance,
3559	unsigned int ioctl_cmd,
3560	unsigned int buflen,
3561	void __user *arg
3562	)
3563	{
3564	struct pmcraid_passthrough_ioctl_buffer *buffer;
3565	struct pmcraid_ioarcb *ioarcb;
3566	struct pmcraid_cmd *cmd;
3567	struct pmcraid_cmd *cancel_cmd;
3568	void __user *request_buffer;
3569	unsigned long request_offset;
3570	unsigned long lock_flags;
3571	void __user *ioasa;
3572	u32 ioasc;
3573	int request_size;
3574	int buffer_size;
3575	u8 direction;
3576	int rc = 0;
3577
3578	/* If IOA reset is in progress, wait 10 secs for reset to complete */
3579	if (pinstance->ioa_reset_in_progress) {
3580	rc = wait_event_interruptible_timeout(
3581	pinstance->reset_wait_q,
3582	!pinstance->ioa_reset_in_progress,
3583	msecs_to_jiffies(10000));
3584
3585	if (!rc)
3586	return -ETIMEDOUT;
3587	else if (rc < 0)
3588	return -ERESTARTSYS;
3589	}
3590
3591	/* If adapter is not in operational state, return error */
3592	if (pinstance->ioa_state != IOA_STATE_OPERATIONAL) {
3593	pmcraid_err("IOA is not operational\n");
3594	return -ENOTTY;
3595	}
3596
3597	buffer_size = sizeof(struct pmcraid_passthrough_ioctl_buffer);
3598	buffer = kmalloc(buffer_size, GFP_KERNEL);
3599
3600	if (!buffer) {
3601	pmcraid_err("no memory for passthrough buffer\n");
3602	return -ENOMEM;
3603	}
3604
3605	request_offset =
3606	offsetof(struct pmcraid_passthrough_ioctl_buffer, request_buffer);
3607
3608	request_buffer = arg + request_offset;
3609
3610	rc = copy_from_user(buffer, arg,
3611	sizeof(struct pmcraid_passthrough_ioctl_buffer));
3612
3613	ioasa = arg + offsetof(struct pmcraid_passthrough_ioctl_buffer, ioasa);
3614
3615	if (rc) {
3616	pmcraid_err("ioctl: can't copy passthrough buffer\n");
3617	rc = -EFAULT;
3618	goto out_free_buffer;
3619	}
3620
3621	request_size = le32_to_cpu(buffer->ioarcb.data_transfer_length);
3622
3623	if (buffer->ioarcb.request_flags0 & TRANSFER_DIR_WRITE) {
3624	direction = DMA_TO_DEVICE;
3625	} else {
3626	direction = DMA_FROM_DEVICE;
3627	}
3628
3629	if (request_size < 0) {
3630	rc = -EINVAL;
3631	goto out_free_buffer;
3632	}
3633
3634	/* check if we have any additional command parameters */
3635	if (le16_to_cpu(buffer->ioarcb.add_cmd_param_length)
3636	> PMCRAID_ADD_CMD_PARAM_LEN) {
3637	rc = -EINVAL;
3638	goto out_free_buffer;
3639	}
3640
3641	cmd = pmcraid_get_free_cmd(pinstance);
3642
3643	if (!cmd) {
3644	pmcraid_err("free command block is not available\n");
3645	rc = -ENOMEM;
3646	goto out_free_buffer;
3647	}
3648
3649	cmd->scsi_cmd = NULL;
3650	ioarcb = &(cmd->ioa_cb->ioarcb);
3651
3652	/* Copy the user-provided IOARCB stuff field by field */
3653	ioarcb->resource_handle = buffer->ioarcb.resource_handle;
3654	ioarcb->data_transfer_length = buffer->ioarcb.data_transfer_length;
3655	ioarcb->cmd_timeout = buffer->ioarcb.cmd_timeout;
3656	ioarcb->request_type = buffer->ioarcb.request_type;
3657	ioarcb->request_flags0 = buffer->ioarcb.request_flags0;
3658	ioarcb->request_flags1 = buffer->ioarcb.request_flags1;
3659	memcpy(ioarcb->cdb, buffer->ioarcb.cdb, PMCRAID_MAX_CDB_LEN);
3660
3661	if (buffer->ioarcb.add_cmd_param_length) {
3662	ioarcb->add_cmd_param_length =
3663	buffer->ioarcb.add_cmd_param_length;
3664	ioarcb->add_cmd_param_offset =
3665	buffer->ioarcb.add_cmd_param_offset;
3666	memcpy(ioarcb->add_data.u.add_cmd_params,
3667	buffer->ioarcb.add_data.u.add_cmd_params,
3668	le16_to_cpu(buffer->ioarcb.add_cmd_param_length));
3669	}
3670
3671	/* set hrrq number where the IOA should respond to. Note that all cmds
3672	* generated internally uses hrrq_id 0, exception to this is the cmd
3673	* block of scsi_cmd which is re-used (e.g. cancel/abort), which uses
3674	* hrrq_id assigned here in queuecommand
3675	*/
3676	ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
3677	pinstance->num_hrrq;
3678
3679	if (request_size) {
3680	rc = pmcraid_build_passthrough_ioadls(cmd,
3681	request_size,
3682	direction);
3683	if (rc) {
3684	pmcraid_err("couldn't build passthrough ioadls\n");
3685	goto out_free_cmd;
3686	}
3687	}
3688
3689	/* If data is being written into the device, copy the data from user
3690	* buffers
3691	*/
3692	if (direction == DMA_TO_DEVICE && request_size > 0) {
3693	rc = pmcraid_copy_sglist(cmd->sglist,
3694	request_buffer,
3695	request_size,
3696	direction);
3697	if (rc) {
3698	pmcraid_err("failed to copy user buffer\n");
3699	goto out_free_sglist;
3700	}
3701	}
3702
3703	/* passthrough ioctl is a blocking command so, put the user to sleep
3704	* until timeout. Note that a timeout value of 0 means, do timeout.
3705	*/
3706	cmd->cmd_done = pmcraid_internal_done;
3707	init_completion(&cmd->wait_for_completion);
3708	cmd->completion_req = 1;
3709
3710	pmcraid_info("command(%d) (CDB[0] = %x) for %x\n",
3711	le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
3712	cmd->ioa_cb->ioarcb.cdb[0],
3713	le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle));
3714
3715	spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3716	_pmcraid_fire_command(cmd);
3717	spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3718
3719	/* NOTE ! Remove the below line once abort_task is implemented
3720	* in firmware. This line disables ioctl command timeout handling logic
3721	* similar to IO command timeout handling, making ioctl commands to wait
3722	* until the command completion regardless of timeout value specified in
3723	* ioarcb
3724	*/
3725	buffer->ioarcb.cmd_timeout = 0;
3726
3727	/* If command timeout is specified put caller to wait till that time,
3728	* otherwise it would be blocking wait. If command gets timed out, it
3729	* will be aborted.
3730	*/
3731	if (buffer->ioarcb.cmd_timeout == 0) {
3732	wait_for_completion(&cmd->wait_for_completion);
3733	} else if (!wait_for_completion_timeout(
3734	&cmd->wait_for_completion,
3735	msecs_to_jiffies(le16_to_cpu(buffer->ioarcb.cmd_timeout) * 1000))) {
3736
3737	pmcraid_info("aborting cmd %d (CDB[0] = %x) due to timeout\n",
3738	le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
3739	cmd->ioa_cb->ioarcb.cdb[0]);
3740
3741	spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3742	cancel_cmd = pmcraid_abort_cmd(cmd);
3743	spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3744
3745	if (cancel_cmd) {
3746	wait_for_completion(&cancel_cmd->wait_for_completion);
3747	ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc);
3748	pmcraid_return_cmd(cancel_cmd);
3749
3750	/* if abort task couldn't find the command i.e it got
3751	* completed prior to aborting, return good completion.
3752	* if command got aborted successfully or there was IOA
3753	* reset due to abort task itself getting timedout then
3754	* return -ETIMEDOUT
3755	*/
3756	if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET \|\|
3757	PMCRAID_IOASC_SENSE_KEY(ioasc) == 0x00) {
3758	if (ioasc != PMCRAID_IOASC_GC_IOARCB_NOTFOUND)
3759	rc = -ETIMEDOUT;
3760	goto out_handle_response;
3761	}
3762	}
3763
3764	/* no command block for abort task or abort task failed to abort
3765	* the IOARCB, then wait for 150 more seconds and initiate reset
3766	* sequence after timeout
3767	*/
3768	if (!wait_for_completion_timeout(
3769	&cmd->wait_for_completion,
3770	msecs_to_jiffies(150 * 1000))) {
3771	pmcraid_reset_bringup(cmd->drv_inst);
3772	rc = -ETIMEDOUT;
3773	}
3774	}
3775
3776	out_handle_response:
3777	/* copy entire IOASA buffer and return IOCTL success.
3778	* If copying IOASA to user-buffer fails, return
3779	* EFAULT
3780	*/
3781	if (copy_to_user(ioasa, &cmd->ioa_cb->ioasa,
3782	sizeof(struct pmcraid_ioasa))) {
3783	pmcraid_err("failed to copy ioasa buffer to user\n");
3784	rc = -EFAULT;
3785	}
3786
3787	/* If the data transfer was from device, copy the data onto user
3788	* buffers
3789	*/
3790	else if (direction == DMA_FROM_DEVICE && request_size > 0) {
3791	rc = pmcraid_copy_sglist(cmd->sglist,
3792	request_buffer,
3793	request_size,
3794	direction);
3795	if (rc) {
3796	pmcraid_err("failed to copy user buffer\n");
3797	rc = -EFAULT;
3798	}
3799	}
3800
3801	out_free_sglist:
3802	pmcraid_release_passthrough_ioadls(cmd, request_size, direction);
3803
3804	out_free_cmd:
3805	pmcraid_return_cmd(cmd);
3806
3807	out_free_buffer:
3808	kfree(buffer);
3809
3810	return rc;
3811	}
3812
3813
3814
3815
3816	/**	3339	/**
3817	* pmcraid_ioctl_driver - ioctl handler for commands handled by driver itself	3340	* pmcraid_ioctl_driver - ioctl handler for commands handled by driver itself
3818	*	3341	*
@@ -3922,20 +3445,6 @@ static long pmcraid_chr_ioctl( · 103 unmodified lines
3922		3445
3923	switch (_IOC_TYPE(cmd)) {	3446	switch (_IOC_TYPE(cmd)) {
3924		3447
3925	case PMCRAID_PASSTHROUGH_IOCTL:
3926	/* If ioctl code is to download microcode, we need to block
3927	* mid-layer requests.
3928	*/
3929	if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
3930	scsi_block_requests(pinstance->host);
3931
3932	retval = pmcraid_ioctl_passthrough(pinstance, cmd,
3933	hdr->buffer_length, argp);
3934
3935	if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
3936	scsi_unblock_requests(pinstance->host);
3937	break;
3938
3939	case PMCRAID_DRIVER_IOCTL:	3448	case PMCRAID_DRIVER_IOCTL:
3940	arg += sizeof(struct pmcraid_ioctl_header);	3449	arg += sizeof(struct pmcraid_ioctl_header);
3941	retval = pmcraid_ioctl_driver(pinstance, cmd,	3450	retval = pmcraid_ioctl_driver(pinstance, cmd,

drivers/scsi/pmcraid.h+0−33

@@ -1022,41 +1022,16 @@ struct pmcraid_ioctl_header { · 1021 unmodified lines
1022		1022
1023	#define PMCRAID_IOCTL_SIGNATURE "PMCRAID"	1023	#define PMCRAID_IOCTL_SIGNATURE "PMCRAID"
1024		1024
1025	/*
1026	* pmcraid_passthrough_ioctl_buffer - structure given as argument to
1027	* passthrough(or firmware handled) IOCTL commands. Note that ioarcb requires
1028	* 32-byte alignment so, it is necessary to pack this structure to avoid any
1029	* holes between ioctl_header and passthrough buffer
1030	*
1031	* .ioactl_header : ioctl header
1032	* .ioarcb : filled-up ioarcb buffer, driver always reads this buffer
1033	* .ioasa : buffer for ioasa, driver fills this with IOASA from firmware
1034	* .request_buffer: The I/O buffer (flat), driver reads/writes to this based on
1035	* the transfer directions passed in ioarcb.flags0. Contents
1036	* of this buffer are valid only when ioarcb.data_transfer_len
1037	* is not zero.
1038	*/
1039	struct pmcraid_passthrough_ioctl_buffer {
1040	struct pmcraid_ioctl_header ioctl_header;
1041	struct pmcraid_ioarcb ioarcb;
1042	struct pmcraid_ioasa ioasa;
1043	u8 request_buffer[];
1044	} __attribute__ ((packed, aligned(PMCRAID_IOARCB_ALIGNMENT)));
1045
1046	/*	1025	/*
1047	* keys to differentiate between driver handled IOCTLs and passthrough	1026	* keys to differentiate between driver handled IOCTLs and passthrough
1048	* IOCTLs passed to IOA. driver determines the ioctl type using macro	1027	* IOCTLs passed to IOA. driver determines the ioctl type using macro
1049	* _IOC_TYPE	1028	* _IOC_TYPE
1050	*/	1029	*/
1051	#define PMCRAID_DRIVER_IOCTL 'D'	1030	#define PMCRAID_DRIVER_IOCTL 'D'
1052	#define PMCRAID_PASSTHROUGH_IOCTL 'F'
1053		1031
1054	#define DRV_IOCTL(n, size) \	1032	#define DRV_IOCTL(n, size) \
1055	_IOC(_IOC_READ\|_IOC_WRITE, PMCRAID_DRIVER_IOCTL, (n), (size))	1033	_IOC(_IOC_READ\|_IOC_WRITE, PMCRAID_DRIVER_IOCTL, (n), (size))
1056		1034
1057	#define FMW_IOCTL(n, size) \
1058	_IOC(_IOC_READ\|_IOC_WRITE, PMCRAID_PASSTHROUGH_IOCTL, (n), (size))
1059
1060	/*	1035	/*
1061	* _ARGSIZE: macro that gives size of the argument type passed to an IOCTL cmd.	1036	* _ARGSIZE: macro that gives size of the argument type passed to an IOCTL cmd.
1062	* This is to facilitate applications avoiding un-necessary memory allocations.	1037	* This is to facilitate applications avoiding un-necessary memory allocations.
@@ -1069,12 +1044,4 @@ struct pmcraid_passthrough_ioctl_buffer { · 6 unmodified lines
1069	#define PMCRAID_IOCTL_RESET_ADAPTER \	1044	#define PMCRAID_IOCTL_RESET_ADAPTER \
1070	DRV_IOCTL(5, sizeof(struct pmcraid_ioctl_header))	1045	DRV_IOCTL(5, sizeof(struct pmcraid_ioctl_header))
1071		1046
1072	/* passthrough/firmware handled commands */
1073	#define PMCRAID_IOCTL_PASSTHROUGH_COMMAND \
1074	FMW_IOCTL(1, sizeof(struct pmcraid_passthrough_ioctl_buffer))
1075
1076	#define PMCRAID_IOCTL_DOWNLOAD_MICROCODE \
1077	FMW_IOCTL(2, sizeof(struct pmcraid_passthrough_ioctl_buffer))
1078
1079
1080	#endif /* _PMCRAID_H */	1047	#endif /* _PMCRAID_H */

drivers/scsi/scsi_debug.c+5−3

 	struct sdebug_defer *sd_dp;
 	sqp = sdebug_q_arr + queue_num;
-	qc_idx = find_first_bit(sqp->in_use_bm, sdebug_max_queue);
-	if (qc_idx >= sdebug_max_queue)
-		return 0;
 	spin_lock_irqsave(&sqp->qc_lock, iflags);
+	qc_idx = find_first_bit(sqp->in_use_bm, sdebug_max_queue);
+	if (qc_idx >= sdebug_max_queue)
+		goto unlock;
 	for (first = true; first || qc_idx + 1 < sdebug_max_queue; )   {
 		if (first) {
 			first = false;
 			break;
 	}
+unlock:
 	spin_unlock_irqrestore(&sqp->qc_lock, iflags);
 	if (num_entries > 0)

drivers/scsi/scsi_logging.c+1−1

@@ -30,7 +30,7 @@ static inline const char scmd_name(const struct scsi_cmnd scmd) · 29 unmodified lines
30	{	30	{
31	struct request rq = scsi_cmd_to_rq((struct scsi_cmnd )scmd);	31	struct request rq = scsi_cmd_to_rq((struct scsi_cmnd )scmd);
32		32
33	if (!rq->q->disk)	33	if (!rq->q \|\| !rq->q->disk)
34	return NULL;	34	return NULL;
35	return rq->q->disk->disk_name;	35	return rq->q->disk->disk_name;
36	}	36	}

drivers/scsi/scsi_scan.c+5−0

 	int ret;
 	struct sbitmap sb_backup;
+	depth = min_t(unsigned int, depth, scsi_device_max_queue_depth(sdev));
 	/*
 	 * realloc if new shift is calculated, which is caused by setting
 	 * up one new default queue depth after calling ->slave_configure
 				scsi_device_max_queue_depth(sdev),
 				new_shift, GFP_KERNEL,
 				sdev->request_queue->node, false, true);
+	if (!ret)
+		sbitmap_resize(&sdev->budget_map, depth);
 	if (need_free) {
 		if (ret)
 			sdev->budget_map = sb_backup;

drivers/scsi/scsi_sysfs.c+0−4

 	if (IS_ENABLED(CONFIG_BLK_DEV_BSG)) {
 		sdev->bsg_dev = scsi_bsg_register_queue(sdev);
 		if (IS_ERR(sdev->bsg_dev)) {
-			/*
-			 * We're treating error on bsg register as non-fatal, so
-			 * pretend nothing went wrong.
-			 */
 			error = PTR_ERR(sdev->bsg_dev);
 			sdev_printk(KERN_INFO, sdev,
 				    "Failed to register bsg queue, errno=%d\n",

drivers/scsi/sd.c+2−1

 			sd_read_block_limits(sdkp);
 			sd_read_block_characteristics(sdkp);
 			sd_zbc_read_zones(sdkp, buffer);
+			sd_read_cpr(sdkp);
 		}
 		sd_print_capacity(sdkp, old_capacity);
 		sd_read_app_tag_own(sdkp, buffer);
 		sd_read_write_same(sdkp, buffer);
 		sd_read_security(sdkp, buffer);
-		sd_read_cpr(sdkp);
 	}
 	/*
 	error = device_add_disk(dev, gd, NULL);
 	if (error) {
 		put_device(&sdkp->disk_dev);
+		blk_cleanup_disk(gd);
 		goto out;
 	}

drivers/scsi/sr.c+1−1

@@ -535,7 +535,7 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd, · 534 unmodified lines
535		535
536	scsi_autopm_get_device(sdev);	536	scsi_autopm_get_device(sdev);
537		537
538	if (ret != CDROMCLOSETRAY && ret != CDROMEJECT) {	538	if (cmd != CDROMCLOSETRAY && cmd != CDROMEJECT) {
539	ret = cdrom_ioctl(&cd->cdi, bdev, mode, cmd, arg);	539	ret = cdrom_ioctl(&cd->cdi, bdev, mode, cmd, arg);
540	if (ret != -ENOSYS)	540	if (ret != -ENOSYS)
541	goto put;	541	goto put;

drivers/scsi/ufs/ufs-qcom.c+0−15

@@ -957,18 +957,6 @@ static const struct reset_control_ops ufs_qcom_reset_ops = { · 956 unmodified lines
957	.deassert = ufs_qcom_reset_deassert,	957	.deassert = ufs_qcom_reset_deassert,
958	};	958	};
959		959
960	#define ANDROID_BOOT_DEV_MAX 30
961	static char android_boot_dev[ANDROID_BOOT_DEV_MAX];
962
963	#ifndef MODULE
964	static int __init get_android_boot_dev(char *str)
965	{
966	strlcpy(android_boot_dev, str, ANDROID_BOOT_DEV_MAX);
967	return 1;
968	}
969	__setup("androidboot.bootdevice=", get_android_boot_dev);
970	#endif
971
972	/**	960	/**
973	* ufs_qcom_init - bind phy with controller	961	* ufs_qcom_init - bind phy with controller
974	* @hba: host controller instance	962	* @hba: host controller instance
@@ -988,9 +976,6 @@ static int ufs_qcom_init(struct ufs_hba *hba) · 13 unmodified lines
988	struct resource *res;	976	struct resource *res;
989	struct ufs_clk_info *clki;	977	struct ufs_clk_info *clki;
990		978
991	if (strlen(android_boot_dev) && strcmp(android_boot_dev, dev_name(dev)))
992	return -ENODEV;
993
994	host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL);	979	host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL);
995	if (!host) {	980	if (!host) {
996	err = -ENOMEM;	981	err = -ENOMEM;

drivers/scsi/ufs/ufshcd-pci.c+17−0

 	return ufs_intel_common_init(hba);
 }
+static int ufs_intel_mtl_init(struct ufs_hba *hba)
+{
+	hba->caps |= UFSHCD_CAP_CRYPTO | UFSHCD_CAP_WB_EN;
+	return ufs_intel_common_init(hba);
+}
 static struct ufs_hba_variant_ops ufs_intel_cnl_hba_vops = {
 	.name                   = "intel-pci",
 	.init			= ufs_intel_common_init,
 	.device_reset		= ufs_intel_device_reset,
 };
+static struct ufs_hba_variant_ops ufs_intel_mtl_hba_vops = {
+	.name                   = "intel-pci",
+	.init			= ufs_intel_mtl_init,
+	.exit			= ufs_intel_common_exit,
+	.hce_enable_notify	= ufs_intel_hce_enable_notify,
+	.link_startup_notify	= ufs_intel_link_startup_notify,
+	.resume			= ufs_intel_resume,
+	.device_reset		= ufs_intel_device_reset,
+};
 #ifdef CONFIG_PM_SLEEP
 static int ufshcd_pci_restore(struct device *dev)
 {
 	{ PCI_VDEVICE(INTEL, 0x98FA), (kernel_ulong_t)&ufs_intel_lkf_hba_vops },
 	{ PCI_VDEVICE(INTEL, 0x51FF), (kernel_ulong_t)&ufs_intel_adl_hba_vops },
 	{ PCI_VDEVICE(INTEL, 0x54FF), (kernel_ulong_t)&ufs_intel_adl_hba_vops },
+	{ PCI_VDEVICE(INTEL, 0x7E47), (kernel_ulong_t)&ufs_intel_mtl_hba_vops },
 	{ }	/* terminate list */
 };

drivers/scsi/ufs/ufshcd.h+0−2

@@ -820,8 +820,6 @@ struct ufs_hba { · 819 unmodified lines
820	enum ufs_pm_level rpm_lvl;	820	enum ufs_pm_level rpm_lvl;
821	/* Desired UFS power management level during system PM */	821	/* Desired UFS power management level during system PM */
822	enum ufs_pm_level spm_lvl;	822	enum ufs_pm_level spm_lvl;
823	struct device_attribute rpm_lvl_attr;
824	struct device_attribute spm_lvl_attr;
825	int pm_op_in_progress;	823	int pm_op_in_progress;
826		824
827	/* Auto-Hibernate Idle Timer register value */	825	/* Auto-Hibernate Idle Timer register value */

drivers/scsi/ufs/ufshpb.c+5−6

 	struct ufshpb_region *rgn, *victim_rgn = NULL;
 	list_for_each_entry(rgn, &lru_info->lh_lru_rgn, list_lru_rgn) {
-		if (!rgn) {
-			dev_err(&hpb->sdev_ufs_lu->sdev_dev,
-				"%s: no region allocated\n",
-				__func__);
-			return NULL;
-		}
 		if (ufshpb_check_srgns_issue_state(hpb, rgn))
 			continue;
 		break;
 	}
+	if (!victim_rgn)
+		dev_err(&hpb->sdev_ufs_lu->sdev_dev,
+			"%s: no region allocated\n",
+			__func__);
 	return victim_rgn;
 }

drivers/scsi/virtio_scsi.c+4−4

@@ -988,7 +988,7 @@ static struct virtio_driver virtio_scsi_driver = { · 987 unmodified lines
988	.remove = virtscsi_remove,	988	.remove = virtscsi_remove,
989	};	989	};
990		990
991	static int __init init(void)	991	static int __init virtio_scsi_init(void)
992	{	992	{
993	int ret = -ENOMEM;	993	int ret = -ENOMEM;
994		994
@@ -1020,14 +1020,14 @@ error: · 25 unmodified lines
1020	return ret;	1020	return ret;
1021	}	1021	}
1022		1022
1023	static void __exit fini(void)	1023	static void __exit virtio_scsi_fini(void)
1024	{	1024	{
1025	unregister_virtio_driver(&virtio_scsi_driver);	1025	unregister_virtio_driver(&virtio_scsi_driver);
1026	mempool_destroy(virtscsi_cmd_pool);	1026	mempool_destroy(virtscsi_cmd_pool);
1027	kmem_cache_destroy(virtscsi_cmd_cache);	1027	kmem_cache_destroy(virtscsi_cmd_cache);
1028	}	1028	}
1029	module_init(init);	1029	module_init(virtio_scsi_init);
1030	module_exit(fini);	1030	module_exit(virtio_scsi_fini);
1031		1031
1032	MODULE_DEVICE_TABLE(virtio, id_table);	1032	MODULE_DEVICE_TABLE(virtio, id_table);
1033	MODULE_DESCRIPTION("Virtio SCSI HBA driver");	1033	MODULE_DESCRIPTION("Virtio SCSI HBA driver");

drivers/scsi/zorro7xx.c+2−0

@@ -159,6 +159,8 @@ static void zorro7xx_remove_one(struct zorro_dev *z) · 158 unmodified lines
159	scsi_remove_host(host);	159	scsi_remove_host(host);
160		160
161	NCR_700_release(host);	161	NCR_700_release(host);
		162	if (host->base > 0x01000000)
		163	iounmap(hostdata->base);
162	kfree(hostdata);	164	kfree(hostdata);
163	free_irq(host->irq, host);	165	free_irq(host->irq, host);
164	zorro_release_device(z);	166	zorro_release_device(z);

drivers/target/target_core_user.c+2−1

 	mutex_lock(&udev->cmdr_lock);
 	page = xa_load(&udev->data_pages, dpi);
 	if (likely(page)) {
+		get_page(page);
 		mutex_unlock(&udev->cmdr_lock);
 		return page;
 	}
 		/* For the vmalloc()ed cmd area pages */
 		addr = (void *)(unsigned long)info->mem[mi].addr + offset;
 		page = vmalloc_to_page(addr);
+		get_page(page);
 	} else {
 		uint32_t dpi;
 			return VM_FAULT_SIGBUS;
 	}
-	get_page(page);
 	vmf->page = page;
 	return 0;
 }