mpt3sas: Ported WarpDrive product SSS6200 support (7786ab6a) · Commits · 戴 / test

drivers/scsi/mpt2sas/mpt2sas_warpdrive.c

0 → 100644

+338 −0

Original line number	Diff line number	Diff line
		/*
		* Scsi Host Layer for MPT (Message Passing Technology) based controllers
		*
		* Copyright (C) 2012-2014 LSI Corporation
		* Copyright (C) 2013-2015 Avago Technologies
		* (mailto: MPT-FusionLinux.pdl@avagotech.com)
		*
		* This program is free software; you can redistribute it and/or
		* modify it under the terms of the GNU General Public License
		* as published by the Free Software Foundation; either version 2
		* of the License, or (at your option) any later version.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*
		* NO WARRANTY
		* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
		* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
		* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
		* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
		* solely responsible for determining the appropriateness of using and
		* distributing the Program and assumes all risks associated with its
		* exercise of rights under this Agreement, including but not limited to
		* the risks and costs of program errors, damage to or loss of data,
		* programs or equipment, and unavailability or interruption of operations.

		* DISCLAIMER OF LIABILITY
		* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
		* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
		* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
		* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
		* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
		* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES

		* You should have received a copy of the GNU General Public License
		* along with this program.
		*/

		/**
		* _scsih_disable_ddio - Disable direct I/O for all the volumes
		* @ioc: per adapter object
		*/
		static void
		_scsih_disable_ddio(struct MPT3SAS_ADAPTER *ioc)
		{
		Mpi2RaidVolPage1_t vol_pg1;
		Mpi2ConfigReply_t mpi_reply;
		struct _raid_device *raid_device;
		u16 handle;
		u16 ioc_status;
		unsigned long flags;

		handle = 0xFFFF;
		while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
		&vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
		MPI2_IOCSTATUS_MASK;
		if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
		break;
		handle = le16_to_cpu(vol_pg1.DevHandle);
		spin_lock_irqsave(&ioc->raid_device_lock, flags);
		raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
		if (raid_device)
		raid_device->direct_io_enabled = 0;
		spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
		}
		return;
		}


		/**
		* _scsih_get_num_volumes - Get number of volumes in the ioc
		* @ioc: per adapter object
		*/
		static u8
		_scsih_get_num_volumes(struct MPT3SAS_ADAPTER *ioc)
		{
		Mpi2RaidVolPage1_t vol_pg1;
		Mpi2ConfigReply_t mpi_reply;
		u16 handle;
		u8 vol_cnt = 0;
		u16 ioc_status;

		handle = 0xFFFF;
		while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
		&vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
		ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
		MPI2_IOCSTATUS_MASK;
		if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
		break;
		vol_cnt++;
		handle = le16_to_cpu(vol_pg1.DevHandle);
		}
		return vol_cnt;
		}


		/**
		* _scsih_init_warpdrive_properties - Set properties for warpdrive direct I/O.
		* @ioc: per adapter object
		* @raid_device: the raid_device object
		*/
		static void
		_scsih_init_warpdrive_properties(struct MPT3SAS_ADAPTER *ioc,
		struct _raid_device *raid_device)
		{
		Mpi2RaidVolPage0_t *vol_pg0;
		Mpi2RaidPhysDiskPage0_t pd_pg0;
		Mpi2ConfigReply_t mpi_reply;
		u16 sz;
		u8 num_pds, count;
		unsigned long stripe_sz, block_sz;
		u8 stripe_exp, block_exp;
		u64 dev_max_lba;

		if (!ioc->is_warpdrive)
		return;

		if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"globally as drives are exposed\n", ioc->name);
		return;
		}
		if (_scsih_get_num_volumes(ioc) > 1) {
		_scsih_disable_ddio(ioc);
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"globally as number of drives > 1\n", ioc->name);
		return;
		}
		if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle,
		&num_pds)) \|\| !num_pds) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"Failure in computing number of drives\n", ioc->name);
		return;
		}

		sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
		sizeof(Mpi2RaidVol0PhysDisk_t));
		vol_pg0 = kzalloc(sz, GFP_KERNEL);
		if (!vol_pg0) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"Memory allocation failure for RVPG0\n", ioc->name);
		return;
		}

		if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
		MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"Failure in retrieving RVPG0\n", ioc->name);
		kfree(vol_pg0);
		return;
		}

		/*
		* WARPDRIVE:If number of physical disks in a volume exceeds the max pds
		* assumed for WARPDRIVE, disable direct I/O
		*/
		if (num_pds > MPT_MAX_WARPDRIVE_PDS) {
		pr_warn(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"for the drive with handle(0x%04x): num_mem=%d, "
		"max_mem_allowed=%d\n", ioc->name, raid_device->handle,
		num_pds, MPT_MAX_WARPDRIVE_PDS);
		kfree(vol_pg0);
		return;
		}
		for (count = 0; count < num_pds; count++) {
		if (mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
		&pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
		vol_pg0->PhysDisk[count].PhysDiskNum) \|\|
		pd_pg0.DevHandle == MPT3SAS_INVALID_DEVICE_HANDLE) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is "
		"disabled for the drive with handle(0x%04x) member"
		"handle retrieval failed for member number=%d\n",
		ioc->name, raid_device->handle,
		vol_pg0->PhysDisk[count].PhysDiskNum);
		goto out_error;
		}
		/* Disable direct I/O if member drive lba exceeds 4 bytes */
		dev_max_lba = le64_to_cpu(pd_pg0.DeviceMaxLBA);
		if (dev_max_lba >> 32) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is "
		"disabled for the drive with handle(0x%04x) member"
		" handle (0x%04x) unsupported max lba 0x%016llx\n",
		ioc->name, raid_device->handle,
		le16_to_cpu(pd_pg0.DevHandle),
		(unsigned long long)dev_max_lba);
		goto out_error;
		}

		raid_device->pd_handle[count] = le16_to_cpu(pd_pg0.DevHandle);
		}

		/*
		* Assumption for WD: Direct I/O is not supported if the volume is
		* not RAID0
		*/
		if (raid_device->volume_type != MPI2_RAID_VOL_TYPE_RAID0) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"for the drive with handle(0x%04x): type=%d, "
		"s_sz=%uK, blk_size=%u\n", ioc->name,
		raid_device->handle, raid_device->volume_type,
		(le32_to_cpu(vol_pg0->StripeSize) *
		le16_to_cpu(vol_pg0->BlockSize)) / 1024,
		le16_to_cpu(vol_pg0->BlockSize));
		goto out_error;
		}

		stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
		stripe_exp = find_first_bit(&stripe_sz, 32);
		if (stripe_exp == 32) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"for the drive with handle(0x%04x) invalid stripe sz %uK\n",
		ioc->name, raid_device->handle,
		(le32_to_cpu(vol_pg0->StripeSize) *
		le16_to_cpu(vol_pg0->BlockSize)) / 1024);
		goto out_error;
		}
		raid_device->stripe_exponent = stripe_exp;
		block_sz = le16_to_cpu(vol_pg0->BlockSize);
		block_exp = find_first_bit(&block_sz, 16);
		if (block_exp == 16) {
		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is disabled "
		"for the drive with handle(0x%04x) invalid block sz %u\n",
		ioc->name, raid_device->handle,
		le16_to_cpu(vol_pg0->BlockSize));
		goto out_error;
		}
		raid_device->block_exponent = block_exp;
		raid_device->direct_io_enabled = 1;

		pr_info(MPT3SAS_FMT "WarpDrive : Direct IO is Enabled for the drive"
		" with handle(0x%04x)\n", ioc->name, raid_device->handle);
		/*
		* WARPDRIVE: Though the following fields are not used for direct IO,
		* stored for future purpose:
		*/
		raid_device->max_lba = le64_to_cpu(vol_pg0->MaxLBA);
		raid_device->stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
		raid_device->block_sz = le16_to_cpu(vol_pg0->BlockSize);


		kfree(vol_pg0);
		return;

		out_error:
		raid_device->direct_io_enabled = 0;
		for (count = 0; count < num_pds; count++)
		raid_device->pd_handle[count] = 0;
		kfree(vol_pg0);
		return;
		}

		/**
		* _scsih_scsi_direct_io_get - returns direct io flag
		* @ioc: per adapter object
		* @smid: system request message index
		*
		* Returns the smid stored scmd pointer.
		*/
		static inline u8
		_scsih_scsi_direct_io_get(struct MPT3SAS_ADAPTER *ioc, u16 smid)
		{
		return ioc->scsi_lookup[smid - 1].direct_io;
		}

		/**
		* _scsih_scsi_direct_io_set - sets direct io flag
		* @ioc: per adapter object
		* @smid: system request message index
		* @direct_io: Zero or non-zero value to set in the direct_io flag
		*
		* Returns Nothing.
		*/
		static inline void
		_scsih_scsi_direct_io_set(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 direct_io)
		{
		ioc->scsi_lookup[smid - 1].direct_io = direct_io;
		}

		/**
		* _scsih_setup_direct_io - setup MPI request for WARPDRIVE Direct I/O
		* @ioc: per adapter object
		* @scmd: pointer to scsi command object
		* @raid_device: pointer to raid device data structure
		* @mpi_request: pointer to the SCSI_IO reqest message frame
		* @smid: system request message index
		*
		* Returns nothing
		*/
		static void
		_scsih_setup_direct_io(struct MPT3SAS_ADAPTER ioc, struct scsi_cmnd scmd,
		struct _raid_device raid_device, Mpi2SCSIIORequest_t mpi_request,
		u16 smid)
		{
		sector_t v_lba, p_lba, stripe_off, stripe_unit, column, io_size;
		u32 stripe_sz, stripe_exp;
		u8 num_pds, cmd = scmd->cmnd[0];

		if (cmd != READ_10 && cmd != WRITE_10 &&
		cmd != READ_16 && cmd != WRITE_16)
		return;

		if (cmd == READ_10 \|\| cmd == WRITE_10)
		v_lba = get_unaligned_be32(&mpi_request->CDB.CDB32[2]);
		else
		v_lba = get_unaligned_be64(&mpi_request->CDB.CDB32[2]);

		io_size = scsi_bufflen(scmd) >> raid_device->block_exponent;

		if (v_lba + io_size - 1 > raid_device->max_lba)
		return;

		stripe_sz = raid_device->stripe_sz;
		stripe_exp = raid_device->stripe_exponent;
		stripe_off = v_lba & (stripe_sz - 1);

		/* Return unless IO falls within a stripe */
		if (stripe_off + io_size > stripe_sz)
		return;

		num_pds = raid_device->num_pds;
		p_lba = v_lba >> stripe_exp;
		stripe_unit = p_lba / num_pds;
		column = p_lba % num_pds;
		p_lba = (stripe_unit << stripe_exp) + stripe_off;
		mpi_request->DevHandle = cpu_to_le16(raid_device->pd_handle[column]);

		if (cmd == READ_10 \|\| cmd == WRITE_10)
		put_unaligned_be32(lower_32_bits(p_lba),
		&mpi_request->CDB.CDB32[2]);
		else
		put_unaligned_be64(p_lba, &mpi_request->CDB.CDB32[2]);

		_scsih_scsi_direct_io_set(ioc, smid, 1);
		}

drivers/scsi/mpt3sas/mpt3sas_base.c

+61 −7

Original line number	Diff line number	Diff line
		@@ -593,6 +593,7 @@ _base_display_event_data(struct MPT3SAS_ADAPTER *ioc,
		desc = "Device Status Change";
		break;
		case MPI2_EVENT_IR_OPERATION_STATUS:
		if (!ioc->hide_ir_msg)
		desc = "IR Operation Status";
		break;
		case MPI2_EVENT_SAS_DISCOVERY:
		@@ -624,15 +625,19 @@ _base_display_event_data(struct MPT3SAS_ADAPTER *ioc,
		desc = "SAS Enclosure Device Status Change";
		break;
		case MPI2_EVENT_IR_VOLUME:
		if (!ioc->hide_ir_msg)
		desc = "IR Volume";
		break;
		case MPI2_EVENT_IR_PHYSICAL_DISK:
		if (!ioc->hide_ir_msg)
		desc = "IR Physical Disk";
		break;
		case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
		if (!ioc->hide_ir_msg)
		desc = "IR Configuration Change List";
		break;
		case MPI2_EVENT_LOG_ENTRY_ADDED:
		if (!ioc->hide_ir_msg)
		desc = "Log Entry Added";
		break;
		case MPI2_EVENT_TEMP_THRESHOLD:
		@@ -689,7 +694,10 @@ _base_sas_log_info(struct MPT3SAS_ADAPTER *ioc , u32 log_info)
		originator_str = "PL";
		break;
		case 2:
		if (!ioc->hide_ir_msg)
		originator_str = "IR";
		else
		originator_str = "WarpDrive";
		break;
		}

		@@ -1023,6 +1031,12 @@ _base_interrupt(int irq, void *bus_id)
		}

		wmb();
		if (ioc->is_warpdrive) {
		writel(reply_q->reply_post_host_index,
		ioc->reply_post_host_index[msix_index]);
		atomic_dec(&reply_q->busy);
		return IRQ_HANDLED;
		}

		/* Update Reply Post Host Index.
		* For those HBA's which support combined reply queue feature
		@@ -2333,6 +2347,7 @@ mpt3sas_base_free_smid(struct MPT3SAS_ADAPTER *ioc, u16 smid)
		}
		ioc->scsi_lookup[i].cb_idx = 0xFF;
		ioc->scsi_lookup[i].scmd = NULL;
		ioc->scsi_lookup[i].direct_io = 0;
		list_add(&ioc->scsi_lookup[i].tracker_list, &ioc->free_list);
		spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);

		@@ -2683,11 +2698,13 @@ _base_display_ioc_capabilities(struct MPT3SAS_ADAPTER *ioc)
		pr_info("), ");
		pr_info("Capabilities=(");

		if (!ioc->hide_ir_msg) {
		if (ioc->facts.IOCCapabilities &
		MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {
		pr_info("Raid");
		i++;
		}
		}

		if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR) {
		pr_info("%sTLR", i ? "," : "");
		@@ -4834,6 +4851,7 @@ _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc, int sleep_flag)
		u32 reply_address;
		u16 smid;
		struct _tr_list delayed_tr, delayed_tr_next;
		u8 hide_flag;
		struct adapter_reply_queue *reply_q;
		long reply_post_free;
		u32 reply_post_free_sz, index = 0;
		@@ -4864,6 +4882,7 @@ _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc, int sleep_flag)
		ioc->scsi_lookup[i].cb_idx = 0xFF;
		ioc->scsi_lookup[i].smid = smid;
		ioc->scsi_lookup[i].scmd = NULL;
		ioc->scsi_lookup[i].direct_io = 0;
		list_add_tail(&ioc->scsi_lookup[i].tracker_list,
		&ioc->free_list);
		}
		@@ -4966,6 +4985,16 @@ _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc, int sleep_flag)


		if (ioc->is_driver_loading) {

		if (ioc->is_warpdrive && ioc->manu_pg10.OEMIdentifier
		== 0x80) {
		hide_flag = (u8) (
		le32_to_cpu(ioc->manu_pg10.OEMSpecificFlags0) &
		MFG_PAGE10_HIDE_SSDS_MASK);
		if (hide_flag != MFG_PAGE10_HIDE_SSDS_MASK)
		ioc->mfg_pg10_hide_flag = hide_flag;
		}

		ioc->wait_for_discovery_to_complete =
		_base_determine_wait_on_discovery(ioc);

		@@ -5032,12 +5061,33 @@ mpt3sas_base_attach(struct MPT3SAS_ADAPTER *ioc)
		goto out_free_resources;
		}

		if (ioc->is_warpdrive) {
		ioc->reply_post_host_index = kcalloc(ioc->cpu_msix_table_sz,
		sizeof(resource_size_t *), GFP_KERNEL);
		if (!ioc->reply_post_host_index) {
		dfailprintk(ioc, pr_info(MPT3SAS_FMT "allocation "
		"for cpu_msix_table failed!!!\n", ioc->name));
		r = -ENOMEM;
		goto out_free_resources;
		}
		}

		ioc->rdpq_array_enable_assigned = 0;
		ioc->dma_mask = 0;
		r = mpt3sas_base_map_resources(ioc);
		if (r)
		goto out_free_resources;

		if (ioc->is_warpdrive) {
		ioc->reply_post_host_index[0] = (resource_size_t __iomem *)
		&ioc->chip->ReplyPostHostIndex;

		for (i = 1; i < ioc->cpu_msix_table_sz; i++)
		ioc->reply_post_host_index[i] =
		(resource_size_t __iomem *)
		((u8 __iomem *)&ioc->chip->Doorbell + (0x4000 + ((i - 1)
		* 4)));
		}

		pci_set_drvdata(ioc->pdev, ioc->shost);
		r = _base_get_ioc_facts(ioc, CAN_SLEEP);
		@@ -5189,6 +5239,8 @@ mpt3sas_base_attach(struct MPT3SAS_ADAPTER *ioc)
		_base_release_memory_pools(ioc);
		pci_set_drvdata(ioc->pdev, NULL);
		kfree(ioc->cpu_msix_table);
		if (ioc->is_warpdrive)
		kfree(ioc->reply_post_host_index);
		kfree(ioc->pd_handles);
		kfree(ioc->blocking_handles);
		kfree(ioc->tm_cmds.reply);
		@@ -5228,6 +5280,8 @@ mpt3sas_base_detach(struct MPT3SAS_ADAPTER *ioc)
		_base_release_memory_pools(ioc);
		pci_set_drvdata(ioc->pdev, NULL);
		kfree(ioc->cpu_msix_table);
		if (ioc->is_warpdrive)
		kfree(ioc->reply_post_host_index);
		kfree(ioc->pd_handles);
		kfree(ioc->blocking_handles);
		kfree(ioc->pfacts);

drivers/scsi/mpt3sas/mpt3sas_base.h

+39 −0

Original line number	Diff line number	Diff line
		@@ -134,6 +134,16 @@
		*/
		#define MPT3SAS_FMT "%s: "

		/*
		* WarpDrive Specific Log codes
		*/

		#define MPT2_WARPDRIVE_LOGENTRY (0x8002)
		#define MPT2_WARPDRIVE_LC_SSDT (0x41)
		#define MPT2_WARPDRIVE_LC_SSDLW (0x43)
		#define MPT2_WARPDRIVE_LC_SSDLF (0x44)
		#define MPT2_WARPDRIVE_LC_BRMF (0x4D)

		/*
		* per target private data
		*/
		@@ -257,6 +267,7 @@ struct Mpi2ManufacturingPage11_t {
		* struct MPT3SAS_TARGET - starget private hostdata
		* @starget: starget object
		* @sas_address: target sas address
		* @raid_device: raid_device pointer to access volume data
		* @handle: device handle
		* @num_luns: number luns
		* @flags: MPT_TARGET_FLAGS_XXX flags
		@@ -266,6 +277,7 @@ struct Mpi2ManufacturingPage11_t {
		struct MPT3SAS_TARGET {
		struct scsi_target *starget;
		u64 sas_address;
		struct _raid_device *raid_device;
		u16 handle;
		int num_luns;
		u32 flags;
		@@ -280,6 +292,11 @@ struct MPT3SAS_TARGET {
		#define MPT_DEVICE_FLAGS_INIT 0x01
		#define MPT_DEVICE_TLR_ON 0x02

		#define MFG_PAGE10_HIDE_SSDS_MASK (0x00000003)
		#define MFG_PAGE10_HIDE_ALL_DISKS (0x00)
		#define MFG_PAGE10_EXPOSE_ALL_DISKS (0x01)
		#define MFG_PAGE10_HIDE_IF_VOL_PRESENT (0x02)

		/**
		* struct MPT3SAS_DEVICE - sdev private hostdata
		* @sas_target: starget private hostdata
		@@ -381,6 +398,7 @@ struct _sas_device {
		* @sdev: scsi device struct (volumes are single lun)
		* @wwid: unique identifier for the volume
		* @handle: device handle
		* @block_size: Block size of the volume
		* @id: target id
		* @channel: target channel
		* @volume_type: the raid level
		@@ -388,6 +406,13 @@ struct _sas_device {
		* @num_pds: number of hidden raid components
		* @responding: used in _scsih_raid_device_mark_responding
		* @percent_complete: resync percent complete
		* @direct_io_enabled: Whether direct io to PDs are allowed or not
		* @stripe_exponent: X where 2powX is the stripe sz in blocks
		* @block_exponent: X where 2powX is the block sz in bytes
		* @max_lba: Maximum number of LBA in the volume
		* @stripe_sz: Stripe Size of the volume
		* @device_info: Device info of the volume member disk
		* @pd_handle: Array of handles of the physical drives for direct I/O in le16
		*/
		#define MPT_MAX_WARPDRIVE_PDS 8
		struct _raid_device {
		@@ -396,13 +421,20 @@ struct _raid_device {
		struct scsi_device *sdev;
		u64 wwid;
		u16 handle;
		u16 block_sz;
		int id;
		int channel;
		u8 volume_type;
		u8 num_pds;
		u8 responding;
		u8 percent_complete;
		u8 direct_io_enabled;
		u8 stripe_exponent;
		u8 block_exponent;
		u64 max_lba;
		u32 stripe_sz;
		u32 device_info;
		u16 pd_handle[MPT_MAX_WARPDRIVE_PDS];
		};

		/**
		@@ -511,12 +543,14 @@ struct chain_tracker {
		* @smid: system message id
		* @scmd: scsi request pointer
		* @cb_idx: callback index
		* @direct_io: To indicate whether I/O is direct (WARPDRIVE)
		* @tracker_list: list of free request (ioc->free_list)
		*/
		struct scsiio_tracker {
		u16 smid;
		struct scsi_cmnd *scmd;
		u8 cb_idx;
		u8 direct_io;
		struct list_head chain_list;
		struct list_head tracker_list;
		};
		@@ -843,6 +877,7 @@ struct MPT3SAS_ADAPTER {
		u16 msix_vector_count;
		u8 *cpu_msix_table;
		u16 cpu_msix_table_sz;
		resource_size_t __iomem **reply_post_host_index;
		u32 ioc_reset_count;
		MPT3SAS_FLUSH_RUNNING_CMDS schedule_dead_ioc_flush_running_cmds;
		u32 non_operational_loop;
		@@ -1014,6 +1049,10 @@ struct MPT3SAS_ADAPTER {
		u32 diagnostic_flags[MPI2_DIAG_BUF_TYPE_COUNT];
		u32 ring_buffer_offset;
		u32 ring_buffer_sz;
		u8 is_warpdrive;
		u8 hide_ir_msg;
		u8 mfg_pg10_hide_flag;
		u8 hide_drives;
		spinlock_t diag_trigger_lock;
		u8 diag_trigger_active;
		struct SL_WH_MASTER_TRIGGER_T diag_trigger_master;

drivers/scsi/mpt3sas/mpt3sas_ctl.c

+4 −1

Original line number	Diff line number	Diff line
		@@ -1030,6 +1030,9 @@ _ctl_getiocinfo(struct MPT3SAS_ADAPTER ioc, void __user arg)
		strcat(karg.driver_version, "-");
		switch (ioc->hba_mpi_version_belonged) {
		case MPI2_VERSION:
		if (ioc->is_warpdrive)
		karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2_SSS6200;
		else
		karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
		strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION);
		break;

drivers/scsi/mpt3sas/mpt3sas_ctl.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -141,6 +141,7 @@ struct mpt3_ioctl_pci_info {
		#define MPT2_IOCTL_INTERFACE_FC_IP (0x02)
		#define MPT2_IOCTL_INTERFACE_SAS (0x03)
		#define MPT2_IOCTL_INTERFACE_SAS2 (0x04)
		#define MPT2_IOCTL_INTERFACE_SAS2_SSS6200 (0x05)
		#define MPT3_IOCTL_INTERFACE_SAS3 (0x06)
		#define MPT2_IOCTL_VERSION_LENGTH (32)

Admin message