[SCSI] Merge scsi-misc-2.6 into scsi-rc-fixes-2.6 (95bb335c) · Commits · e / devices / android_kernel_teracube_2e

MAINTAINERS

+12 −11

Original line number	Diff line number	Diff line
		@@ -131,19 +131,12 @@ L: netdev@vger.kernel.org
		S: Maintained
		F: drivers/net/typhoon*

		3W-9XXX SATA-RAID CONTROLLER DRIVER
		M: Adam Radford <linuxraid@amcc.com>
		3WARE SAS/SATA-RAID SCSI DRIVERS (3W-XXXX, 3W-9XXX, 3W-SAS)
		M: Adam Radford <linuxraid@lsi.com>
		L: linux-scsi@vger.kernel.org
		W: http://www.amcc.com
		W: http://www.lsi.com
		S: Supported
		F: drivers/scsi/3w-9xxx*

		3W-XXXX ATA-RAID CONTROLLER DRIVER
		M: Adam Radford <linuxraid@amcc.com>
		L: linux-scsi@vger.kernel.org
		W: http://www.amcc.com
		S: Supported
		F: drivers/scsi/3w-xxxx*
		F: drivers/scsi/3w-*

		53C700 AND 53C700-66 SCSI DRIVER
		M: "James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>
		@@ -4577,6 +4570,14 @@ S: Supported
		F: Documentation/scsi/LICENSE.qla2xxx
		F: drivers/scsi/qla2xxx/

		QLOGIC QLA4XXX iSCSI DRIVER
		M: Ravi Anand <ravi.anand@qlogic.com>
		M: Vikas Chaudhary <vikas.chaudhary@qlogic.com>
		M: iscsi-driver@qlogic.com
		L: linux-scsi@vger.kernel.org
		S: Supported
		F: drivers/scsi/qla4xxx/

		QLOGIC QLA3XXX NETWORK DRIVER
		M: Ron Mercer <ron.mercer@qlogic.com>
		M: linux-driver@qlogic.com

drivers/message/fusion/mptbase.c

+174 −3

Original line number	Diff line number	Diff line
		@@ -5064,7 +5064,7 @@ mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
		if (!timeleft) {
		printk(KERN_DEBUG "%s: Issuing Reset from %s!!\n",
		ioc->name, __func__);
		mpt_HardResetHandler(ioc, CAN_SLEEP);
		mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
		mpt_free_msg_frame(ioc, mf);
		}
		goto out;
		@@ -6456,10 +6456,15 @@ mpt_config(MPT_ADAPTER ioc, CONFIGPARMS pCfg)
		issue_hard_reset = 0;
		printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
		ioc->name, __func__);
		if (retry_count == 0) {
		if (mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP) != 0)
		retry_count++;
		} else
		mpt_HardResetHandler(ioc, CAN_SLEEP);

		mpt_free_msg_frame(ioc, mf);
		/* attempt one retry for a timed out command */
		if (!retry_count) {
		if (retry_count < 2) {
		printk(MYIOC_s_INFO_FMT
		"Attempting Retry Config request"
		" type 0x%x, page 0x%x,"
		@@ -6904,6 +6909,172 @@ mpt_halt_firmware(MPT_ADAPTER *ioc)
		}
		EXPORT_SYMBOL(mpt_halt_firmware);

		/**
		* mpt_SoftResetHandler - Issues a less expensive reset
		* @ioc: Pointer to MPT_ADAPTER structure
		* @sleepFlag: Indicates if sleep or schedule must be called.

		*
		* Returns 0 for SUCCESS or -1 if FAILED.
		*
		* Message Unit Reset - instructs the IOC to reset the Reply Post and
		* Free FIFO's. All the Message Frames on Reply Free FIFO are discarded.
		* All posted buffers are freed, and event notification is turned off.
		* IOC doesnt reply to any outstanding request. This will transfer IOC
		* to READY state.
		**/
		int
		mpt_SoftResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
		{
		int rc;
		int ii;
		u8 cb_idx;
		unsigned long flags;
		u32 ioc_state;
		unsigned long time_count;

		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SoftResetHandler Entered!\n",
		ioc->name));

		ioc_state = mpt_GetIocState(ioc, 0) & MPI_IOC_STATE_MASK;

		if (mpt_fwfault_debug)
		mpt_halt_firmware(ioc);

		if (ioc_state == MPI_IOC_STATE_FAULT \|\|
		ioc_state == MPI_IOC_STATE_RESET) {
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
		"skipping, either in FAULT or RESET state!\n", ioc->name));
		return -1;
		}

		if (ioc->bus_type == FC) {
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
		"skipping, because the bus type is FC!\n", ioc->name));
		return -1;
		}

		spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
		if (ioc->ioc_reset_in_progress) {
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
		return -1;
		}
		ioc->ioc_reset_in_progress = 1;
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);

		rc = -1;

		for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
		if (MptResetHandlers[cb_idx])
		mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
		}

		spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
		if (ioc->taskmgmt_in_progress) {
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
		return -1;
		}
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
		/* Disable reply interrupts (also blocks FreeQ) */
		CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
		ioc->active = 0;
		time_count = jiffies;

		rc = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);

		for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
		if (MptResetHandlers[cb_idx])
		mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
		}

		if (rc)
		goto out;

		ioc_state = mpt_GetIocState(ioc, 0) & MPI_IOC_STATE_MASK;
		if (ioc_state != MPI_IOC_STATE_READY)
		goto out;

		for (ii = 0; ii < 5; ii++) {
		/* Get IOC facts! Allow 5 retries */
		rc = GetIocFacts(ioc, sleepFlag,
		MPT_HOSTEVENT_IOC_RECOVER);
		if (rc == 0)
		break;
		if (sleepFlag == CAN_SLEEP)
		msleep(100);
		else
		mdelay(100);
		}
		if (ii == 5)
		goto out;

		rc = PrimeIocFifos(ioc);
		if (rc != 0)
		goto out;

		rc = SendIocInit(ioc, sleepFlag);
		if (rc != 0)
		goto out;

		rc = SendEventNotification(ioc, 1, sleepFlag);
		if (rc != 0)
		goto out;

		if (ioc->hard_resets < -1)
		ioc->hard_resets++;

		/*
		* At this point, we know soft reset succeeded.
		*/

		ioc->active = 1;
		CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);

		out:
		spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
		ioc->ioc_reset_in_progress = 0;
		ioc->taskmgmt_quiesce_io = 0;
		ioc->taskmgmt_in_progress = 0;
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);

		if (ioc->active) { /* otherwise, hard reset coming */
		for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
		if (MptResetHandlers[cb_idx])
		mpt_signal_reset(cb_idx, ioc,
		MPT_IOC_POST_RESET);
		}
		}

		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
		"SoftResetHandler: completed (%d seconds): %s\n",
		ioc->name, jiffies_to_msecs(jiffies - time_count)/1000,
		((rc == 0) ? "SUCCESS" : "FAILED")));

		return rc;
		}

		/**
		* mpt_Soft_Hard_ResetHandler - Try less expensive reset
		* @ioc: Pointer to MPT_ADAPTER structure
		* @sleepFlag: Indicates if sleep or schedule must be called.

		*
		* Returns 0 for SUCCESS or -1 if FAILED.
		* Try for softreset first, only if it fails go for expensive
		* HardReset.
		**/
		int
		mpt_Soft_Hard_ResetHandler(MPT_ADAPTER *ioc, int sleepFlag) {
		int ret = -1;

		ret = mpt_SoftResetHandler(ioc, sleepFlag);
		if (ret == 0)
		return ret;
		ret = mpt_HardResetHandler(ioc, sleepFlag);
		return ret;
		}
		EXPORT_SYMBOL(mpt_Soft_Hard_ResetHandler);

		/=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=/
		/*
		* Reset Handling

drivers/message/fusion/mptbase.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -76,8 +76,8 @@
		#define COPYRIGHT "Copyright (c) 1999-2008 " MODULEAUTHOR
		#endif

		#define MPT_LINUX_VERSION_COMMON "3.04.14"
		#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-3.04.14"
		#define MPT_LINUX_VERSION_COMMON "3.04.15"
		#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-3.04.15"
		#define WHAT_MAGIC_STRING "@" "(" "#" ")"

		#define show_mptmod_ver(s,ver) \
		@@ -940,6 +940,7 @@ extern int mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp);
		extern u32 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked);
		extern void mpt_print_ioc_summary(MPT_ADAPTER ioc, char buf, int *size, int len, int showlan);
		extern int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
		extern int mpt_Soft_Hard_ResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
		extern int mpt_config(MPT_ADAPTER ioc, CONFIGPARMS cfg);
		extern int mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size);
		extern void mpt_free_fw_memory(MPT_ADAPTER *ioc);

drivers/message/fusion/mptctl.c

+105 −76

Original line number	Diff line number	Diff line
		@@ -128,7 +128,6 @@ static MptSge_t kbuf_alloc_2_sgl(int bytes, u32 dir, int sge_offset, int frags
		struct buflist *blp, dma_addr_t sglbuf_dma, MPT_ADAPTER *ioc);
		static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
		struct buflist buflist, MPT_ADAPTER ioc);
		static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function);

		/*
		* Reset Handler cleanup function
		@@ -275,45 +274,6 @@ mptctl_reply(MPT_ADAPTER ioc, MPT_FRAME_HDR req, MPT_FRAME_HDR *reply)
		return 1;
		}

		/=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=/
		/* mptctl_timeout_expired
		*
		* Expecting an interrupt, however timed out.
		*
		*/
		static void
		mptctl_timeout_expired(MPT_ADAPTER ioc, MPT_FRAME_HDR mf)
		{
		unsigned long flags;

		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": %s\n",
		ioc->name, __func__));

		if (mpt_fwfault_debug)
		mpt_halt_firmware(ioc);

		spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
		if (ioc->ioc_reset_in_progress) {
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
		CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
		mpt_free_msg_frame(ioc, mf);
		return;
		}
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);


		if (!mptctl_bus_reset(ioc, mf->u.hdr.Function))
		return;

		/* Issue a reset for this device.
		* The IOC is not responding.
		*/
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling HardReset! \n",
		ioc->name));
		CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
		mpt_HardResetHandler(ioc, CAN_SLEEP);
		mpt_free_msg_frame(ioc, mf);
		}

		static int
		mptctl_taskmgmt_reply(MPT_ADAPTER ioc, MPT_FRAME_HDR mf, MPT_FRAME_HDR *mr)
		@@ -343,12 +303,8 @@ mptctl_taskmgmt_reply(MPT_ADAPTER ioc, MPT_FRAME_HDR mf, MPT_FRAME_HDR *mr)
		return 0;
		}

		/* mptctl_bus_reset
		*
		* Bus reset code.
		*
		*/
		static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		static int
		mptctl_do_taskmgmt(MPT_ADAPTER *ioc, u8 tm_type, u8 bus_id, u8 target_id)
		{
		MPT_FRAME_HDR *mf;
		SCSITaskMgmt_t *pScsiTm;
		@@ -359,13 +315,6 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		unsigned long time_count;
		u16 iocstatus;

		/* bus reset is only good for SCSI IO, RAID PASSTHRU */
		if (!(function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH \|\|
		function == MPI_FUNCTION_SCSI_IO_REQUEST)) {
		dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
		"TaskMgmt, not SCSI_IO!!\n", ioc->name));
		return -EPERM;
		}

		mutex_lock(&ioc->taskmgmt_cmds.mutex);
		if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
		@@ -375,15 +324,14 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)

		retval = 0;

		/* Send request
		*/
		mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc);
		if (mf == NULL) {
		dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
		"TaskMgmt, no msg frames!!\n", ioc->name));
		dtmprintk(ioc,
		printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
		ioc->name));
		mpt_clear_taskmgmt_in_progress_flag(ioc);
		retval = -ENOMEM;
		goto mptctl_bus_reset_done;
		goto tm_done;
		}

		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
		@@ -392,10 +340,13 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		pScsiTm = (SCSITaskMgmt_t *) mf;
		memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
		pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
		pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS;
		pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
		pScsiTm->TargetID = 0;
		pScsiTm->Bus = 0;
		pScsiTm->TaskType = tm_type;
		if ((tm_type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) &&
		(ioc->bus_type == FC))
		pScsiTm->MsgFlags =
		MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
		pScsiTm->TargetID = target_id;
		pScsiTm->Bus = bus_id;
		pScsiTm->ChainOffset = 0;
		pScsiTm->Reserved = 0;
		pScsiTm->Reserved1 = 0;
		@@ -414,16 +365,15 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		break;
		case SPI:
		default:
		timeout = 2;
		timeout = 10;
		break;
		}

		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
		"TaskMgmt type=%d timeout=%ld\n",
		ioc->name, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, timeout));
		dtmprintk(ioc,
		printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
		ioc->name, tm_type, timeout));

		INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
		CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
		time_count = jiffies;
		if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
		(ioc->facts.MsgVersion >= MPI_VERSION_01_05))
		@@ -432,17 +382,20 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		retval = mpt_send_handshake_request(mptctl_taskmgmt_id, ioc,
		sizeof(SCSITaskMgmt_t), (u32 *)pScsiTm, CAN_SLEEP);
		if (retval != 0) {
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
		dfailprintk(ioc,
		printk(MYIOC_s_ERR_FMT
		"TaskMgmt send_handshake FAILED!"
		" (ioc %p, mf %p, rc=%d) \n", ioc->name,
		ioc, mf, retval));
		mpt_free_msg_frame(ioc, mf);
		mpt_clear_taskmgmt_in_progress_flag(ioc);
		goto mptctl_bus_reset_done;
		goto tm_done;
		}
		}

		/* Now wait for the command to complete */
		ii = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);

		if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
		"TaskMgmt failed\n", ioc->name));
		@@ -452,14 +405,14 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		retval = 0;
		else
		retval = -1; /* return failure */
		goto mptctl_bus_reset_done;
		goto tm_done;
		}

		if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
		"TaskMgmt failed\n", ioc->name));
		retval = -1; /* return failure */
		goto mptctl_bus_reset_done;
		goto tm_done;
		}

		pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
		@@ -467,7 +420,7 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		"TaskMgmt fw_channel = %d, fw_id = %d, task_type=0x%02X, "
		"iocstatus=0x%04X\n\tloginfo=0x%08X, response_code=0x%02X, "
		"term_cmnds=%d\n", ioc->name, pScsiTmReply->Bus,
		pScsiTmReply->TargetID, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
		pScsiTmReply->TargetID, tm_type,
		le16_to_cpu(pScsiTmReply->IOCStatus),
		le32_to_cpu(pScsiTmReply->IOCLogInfo),
		pScsiTmReply->ResponseCode,
		@@ -485,13 +438,71 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
		retval = -1; /* return failure */
		}


		mptctl_bus_reset_done:
		tm_done:
		mutex_unlock(&ioc->taskmgmt_cmds.mutex);
		CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
		return retval;
		}

		/=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=/
		/* mptctl_timeout_expired
		*
		* Expecting an interrupt, however timed out.
		*
		*/
		static void
		mptctl_timeout_expired(MPT_ADAPTER ioc, MPT_FRAME_HDR mf)
		{
		unsigned long flags;
		int ret_val = -1;
		SCSIIORequest_t scsi_req = (SCSIIORequest_t ) mf;
		u8 function = mf->u.hdr.Function;

		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": %s\n",
		ioc->name, __func__));

		if (mpt_fwfault_debug)
		mpt_halt_firmware(ioc);

		spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
		if (ioc->ioc_reset_in_progress) {
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
		CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
		mpt_free_msg_frame(ioc, mf);
		return;
		}
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);


		CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)

		if (ioc->bus_type == SAS) {
		if (function == MPI_FUNCTION_SCSI_IO_REQUEST)
		ret_val = mptctl_do_taskmgmt(ioc,
		MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
		scsi_req->Bus, scsi_req->TargetID);
		else if (function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)
		ret_val = mptctl_do_taskmgmt(ioc,
		MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
		scsi_req->Bus, 0);
		if (!ret_val)
		return;
		} else {
		if ((function == MPI_FUNCTION_SCSI_IO_REQUEST) \|\|
		(function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH))
		ret_val = mptctl_do_taskmgmt(ioc,
		MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
		scsi_req->Bus, 0);
		if (!ret_val)
		return;
		}

		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling Reset! \n",
		ioc->name));
		mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
		mpt_free_msg_frame(ioc, mf);
		}


		/=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=/
		/* mptctl_ioc_reset
		@@ -1318,6 +1329,8 @@ mptctl_getiocinfo (unsigned long arg, unsigned int data_size)
		if (ioc->sh) {
		shost_for_each_device(sdev, ioc->sh) {
		vdevice = sdev->hostdata;
		if (vdevice == NULL \|\| vdevice->vtarget == NULL)
		continue;
		if (vdevice->vtarget->tflags &
		MPT_TARGET_FLAGS_RAID_COMPONENT)
		continue;
		@@ -1439,6 +1452,8 @@ mptctl_gettargetinfo (unsigned long arg)
		if (!maxWordsLeft)
		continue;
		vdevice = sdev->hostdata;
		if (vdevice == NULL \|\| vdevice->vtarget == NULL)
		continue;
		if (vdevice->vtarget->tflags &
		MPT_TARGET_FLAGS_RAID_COMPONENT)
		continue;
		@@ -1967,6 +1982,9 @@ mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr)
		struct scsi_target *starget = scsi_target(sdev);
		VirtTarget *vtarget = starget->hostdata;

		if (vtarget == NULL)
		continue;

		if ((pScsiReq->TargetID == vtarget->id) &&
		(pScsiReq->Bus == vtarget->channel) &&
		(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
		@@ -2991,6 +3009,14 @@ static int __init mptctl_init(void)
		}

		mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER);
		if (!mptctl_taskmgmt_id \|\| mptctl_taskmgmt_id >= MPT_MAX_PROTOCOL_DRIVERS) {
		printk(KERN_ERR MYNAM ": ERROR: Failed to register with Fusion MPT base driver\n");
		mpt_deregister(mptctl_id);
		misc_deregister(&mptctl_miscdev);
		err = -EBUSY;
		goto out_fail;
		}

		mpt_reset_register(mptctl_id, mptctl_ioc_reset);
		mpt_event_register(mptctl_id, mptctl_event_process);

		@@ -3010,12 +3036,15 @@ static void mptctl_exit(void)
		printk(KERN_INFO MYNAM ": Deregistered /dev/%s @ (major,minor=%d,%d)\n",
		mptctl_miscdev.name, MISC_MAJOR, mptctl_miscdev.minor);

		/* De-register event handler from base module */
		mpt_event_deregister(mptctl_id);

		/* De-register reset handler from base module */
		mpt_reset_deregister(mptctl_id);

		/* De-register callback handler from base module */
		mpt_deregister(mptctl_taskmgmt_id);
		mpt_deregister(mptctl_id);
		mpt_reset_deregister(mptctl_taskmgmt_id);

		mpt_device_driver_deregister(MPTCTL_DRIVER);

drivers/message/fusion/mptfc.c

+21 −1

Original line number	Diff line number	Diff line
		@@ -482,6 +482,7 @@ mptfc_register_dev(MPT_ADAPTER ioc, int channel, FCDevicePage0_t pg0)
		if (vtarget) {
		vtarget->id = pg0->CurrentTargetID;
		vtarget->channel = pg0->CurrentBus;
		vtarget->deleted = 0;
		}
		}
		((struct mptfc_rport_info *)rport->dd_data) = ri;
		@@ -1092,6 +1093,8 @@ mptfc_setup_reset(struct work_struct *work)
		container_of(work, MPT_ADAPTER, fc_setup_reset_work);
		u64 pn;
		struct mptfc_rport_info *ri;
		struct scsi_target *starget;
		VirtTarget *vtarget;

		/* reset about to happen, delete (block) all rports */
		list_for_each_entry(ri, &ioc->fc_rports, list) {
		@@ -1099,6 +1102,12 @@ mptfc_setup_reset(struct work_struct *work)
		ri->flags &= ~MPT_RPORT_INFO_FLAGS_REGISTERED;
		fc_remote_port_delete(ri->rport); /* won't sleep */
		ri->rport = NULL;
		starget = ri->starget;
		if (starget) {
		vtarget = starget->hostdata;
		if (vtarget)
		vtarget->deleted = 1;
		}

		pn = (u64)ri->pg0.WWPN.High << 32 \|
		(u64)ri->pg0.WWPN.Low;
		@@ -1119,6 +1128,8 @@ mptfc_rescan_devices(struct work_struct *work)
		int ii;
		u64 pn;
		struct mptfc_rport_info *ri;
		struct scsi_target *starget;
		VirtTarget *vtarget;

		/* start by tagging all ports as missing */
		list_for_each_entry(ri, &ioc->fc_rports, list) {
		@@ -1146,6 +1157,12 @@ mptfc_rescan_devices(struct work_struct *work)
		MPT_RPORT_INFO_FLAGS_MISSING);
		fc_remote_port_delete(ri->rport); /* won't sleep */
		ri->rport = NULL;
		starget = ri->starget;
		if (starget) {
		vtarget = starget->hostdata;
		if (vtarget)
		vtarget->deleted = 1;
		}

		pn = (u64)ri->pg0.WWPN.High << 32 \|
		(u64)ri->pg0.WWPN.Low;
		@@ -1358,6 +1375,9 @@ mptfc_event_process(MPT_ADAPTER ioc, EventNotificationReply_t pEvReply)
		unsigned long flags;
		int rc=1;

		if (ioc->bus_type != FC)
		return 0;

		devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
		ioc->name, event));

		@@ -1396,7 +1416,7 @@ mptfc_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
		unsigned long flags;

		rc = mptscsih_ioc_reset(ioc,reset_phase);
		if (rc == 0)
		if ((ioc->bus_type != FC) \|\| (!rc))
		return rc;