--- /dev/null
+Subject: Update MPT Fusion driver to v4.00.43.00
+From: Hannes Reinecke <hare@suse.de>
+Date: Tue Sep 30 13:38:53 2008 +0200:
+Git: a958ec0d1685af04282982f2e53b66c947fc7426
+
+References: bnc#425660
+
+This patch updates the MPT fusion drivers to v4.00.43.00.
+
+Signed-off-by: Sathya Prakash <Sathya.Prakash@lsi.com>
+Signed-off-by: Hannes Reinecke <hare@suse.de>
+
+---
+ drivers/message/fusion/Kconfig | 16
+ drivers/message/fusion/Makefile | 13
+ drivers/message/fusion/csmi/csmisas.c | 5888 ++++++++++++++++++
+ drivers/message/fusion/csmi/csmisas.h | 1854 +++++
+ drivers/message/fusion/lsi/mpi.h | 7
+ drivers/message/fusion/lsi/mpi_cnfg.h | 47
+ drivers/message/fusion/lsi/mpi_fc.h | 2
+ drivers/message/fusion/lsi/mpi_history.txt | 86
+ drivers/message/fusion/lsi/mpi_init.h | 2
+ drivers/message/fusion/lsi/mpi_ioc.h | 22
+ drivers/message/fusion/lsi/mpi_lan.h | 2
+ drivers/message/fusion/lsi/mpi_log_fc.h | 2
+ drivers/message/fusion/lsi/mpi_log_sas.h | 31
+ drivers/message/fusion/lsi/mpi_raid.h | 11
+ drivers/message/fusion/lsi/mpi_sas.h | 18
+ drivers/message/fusion/lsi/mpi_targ.h | 2
+ drivers/message/fusion/lsi/mpi_tool.h | 2
+ drivers/message/fusion/lsi/mpi_type.h | 19
+ drivers/message/fusion/mptbase.c | 2700 +++++---
+ drivers/message/fusion/mptbase.h | 291
+ drivers/message/fusion/mptctl.c | 1020 +--
+ drivers/message/fusion/mptctl.h | 5
+ drivers/message/fusion/mptdebug.h | 12
+ drivers/message/fusion/mptfc.c | 189
+ drivers/message/fusion/mptlan.c | 56
+ drivers/message/fusion/mptlan.h | 3
+ drivers/message/fusion/mptsas.c | 5921 ++++++++++++-------
+ drivers/message/fusion/mptsas.h | 71
+ drivers/message/fusion/mptscsih.c | 2252 +++----
+ drivers/message/fusion/mptscsih.h | 13
+ drivers/message/fusion/mptspi.c | 265
+ drivers/message/fusion/rejected_ioctls/diag_buffer.c | 667 ++
+ drivers/message/fusion/rejected_ioctls/diag_buffer.h | 101
+ 33 files changed, 16615 insertions(+), 4975 deletions(-)
+
+--- /dev/null
++++ b/drivers/message/fusion/csmi/csmisas.c
+@@ -0,0 +1,5888 @@
++/*
++ * linux/drivers/message/fusion/csmi/csmisas.c
++ * For use with LSI PCI chip/adapter(s)
++ * running LSI Fusion MPT (Message Passing Technology) firmware.
++ *
++ * Copyright (c) 1999-2008 LSI Corporation
++ * (mailto:DL-MPTFusionLinux@lsi.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; version 2 of the License.
++
++ 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; if not, write to the Free Software
++ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++*/
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++
++#define MPT_CSMI_DESCRIPTION "LSI Corporation: Fusion MPT Driver "MPT_LINUX_VERSION_COMMON
++#define csmisas_is_this_sas_cntr(ioc) (ioc->bus_type == SAS) ? 1 : 0
++
++#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
++#define __user
++#include <asm/div64.h>
++#endif
++
++static int csmisas_do_raid(MPT_ADAPTER *ioc, u8 action, u8 PhysDiskNum, u8 VolumeBus,
++ u8 VolumeId, pMpiRaidActionReply_t reply);
++static u8 map_sas_status_to_csmi(u8 mpi_sas_status);
++
++/**
++ * reverse_byte_order64
++ *
++ * @data64
++ *
++ **/
++static u64
++reverse_byte_order64(u64 data64)
++{
++ int i;
++ u64 rc;
++ u8 *inWord = (u8*)&data64, *outWord = (u8*)&rc;
++
++ for (i = 0 ; i < 8 ; i++)
++ outWord[i] = inWord[7-i];
++
++ return rc;
++}
++
++/**
++ * csmisas_is_sata
++ *
++ * @phys_disk
++ *
++ **/
++static int
++csmisas_is_sata(RaidPhysDiskPage0_t *phys_disk)
++{
++ if ((phys_disk->ExtDiskIdentifier[0] == 'A') &&
++ (phys_disk->ExtDiskIdentifier[1] == 'T') &&
++ (phys_disk->ExtDiskIdentifier[2] == 'A'))
++ return 1;
++ else
++ return 0;
++}
++
++/**
++ * csmisas_is_end_device
++ *
++ * @attached
++ *
++ **/
++static inline int
++csmisas_is_end_device(struct mptsas_devinfo * attached)
++{
++ if ((attached->sas_address) &&
++ (attached->device_info &
++ MPI_SAS_DEVICE_INFO_END_DEVICE) &&
++ ((attached->device_info &
++ MPI_SAS_DEVICE_INFO_SSP_TARGET) |
++ (attached->device_info &
++ MPI_SAS_DEVICE_INFO_STP_TARGET) |
++ (attached->device_info &
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
++ return 1;
++ else
++ return 0;
++}
++
++/**
++ * csmisas_is_phys_disk
++ *
++ * returns (1) success (0) fail - not a phys disk
++ **/
++static int
++csmisas_is_phys_disk(MPT_ADAPTER *ioc, int channel, int id)
++{
++ struct inactive_raid_component_info *component_info;
++ int i;
++ int rc = 0;
++
++ if (!ioc->raid_data.pIocPg3)
++ goto out;
++ for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
++ if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
++ (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
++ rc = 1;
++ goto out;
++ }
++ }
++
++ /*
++ * Check inactive list for matching phys disks
++ */
++ if (list_empty(&ioc->raid_data.inactive_list))
++ goto out;
++
++ down(&ioc->raid_data.inactive_list_mutex);
++ list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
++ list) {
++ if ((component_info->d.PhysDiskID == id) &&
++ (component_info->d.PhysDiskBus == channel))
++ rc = 1;
++ }
++ up(&ioc->raid_data.inactive_list_mutex);
++
++ out:
++ return rc;
++}
++
++/**
++ * csmisas_raid_id_to_num
++ *
++ * Obtains the phys disk num for given H:C:T nexus
++ *
++ * input (channel/id)
++ * output (phys disk number - used by SCSI_IO_PASSTHRU to access hidden component)
++ *
++ * returns - signed return means failure
++ **/
++static s8
++csmisas_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
++{
++ struct inactive_raid_component_info *component_info;
++ int i;
++ s8 rc = -ENXIO;
++
++ if (!ioc->raid_data.pIocPg3)
++ goto out;
++ for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
++ if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
++ (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
++ rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
++ goto out;
++ }
++ }
++
++ /*
++ * Check inactive list for matching phys disks
++ */
++ if (list_empty(&ioc->raid_data.inactive_list))
++ goto out;
++
++ down(&ioc->raid_data.inactive_list_mutex);
++ list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
++ list) {
++ if ((component_info->d.PhysDiskID == id) &&
++ (component_info->d.PhysDiskBus == channel))
++ rc = component_info->d.PhysDiskNum;
++ }
++ up(&ioc->raid_data.inactive_list_mutex);
++
++ out:
++ return rc;
++}
++
++/**
++ * csmisas_get_device_component_by_os
++ *
++ * Obtain device component object by operating system mapping
++ *
++ * @ioc
++ * @channel
++ * @id
++ *
++ **/
++static struct sas_device_info *
++csmisas_get_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
++{
++ struct sas_device_info *sas_info, *p;
++
++ sas_info = NULL;
++
++ down(&ioc->sas_device_info_mutex);
++ list_for_each_entry(p, &ioc->sas_device_info_list, list) {
++ if (p->os.channel == channel && p->os.id == id) {
++ sas_info = p;
++ goto out;
++ }
++ }
++
++ out:
++ up(&ioc->sas_device_info_mutex);
++ return sas_info;
++}
++
++/**
++ * csmisas_get_device_component
++ *
++ * Obtain device component object by firmware system mapping
++ *
++ * @ioc
++ * @channel
++ * @id
++ *
++ **/
++static struct sas_device_info *
++csmisas_get_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
++{
++ struct sas_device_info *sas_info, *p;
++
++ sas_info = NULL;
++
++ down(&ioc->sas_device_info_mutex);
++ list_for_each_entry(p, &ioc->sas_device_info_list, list) {
++ if (p->fw.channel == channel && p->fw.id == id) {
++ sas_info = p;
++ goto out;
++ }
++ }
++
++ out:
++ up(&ioc->sas_device_info_mutex);
++ return sas_info;
++}
++
++
++/**
++ * csmisas_get_device_component_by_sas_addr
++ *
++ * Obtain device component object by sas address
++ *
++ * @ioc
++ * @channel
++ * @id
++ *
++ **/
++static struct sas_device_info *
++csmisas_get_device_component_by_sas_addr(MPT_ADAPTER *ioc, u64 sas_address)
++{
++ struct sas_device_info *sas_info, *p;
++
++ sas_info = NULL;
++
++ down(&ioc->sas_device_info_mutex);
++ list_for_each_entry(p, &ioc->sas_device_info_list, list) {
++ if (p->sas_address == sas_address) {
++ sas_info = p;
++ goto out;
++ }
++ }
++
++ out:
++ up(&ioc->sas_device_info_mutex);
++ return sas_info;
++}
++
++/**
++ * csmisas_send_command_wait
++ *
++ * Send mf to firmware
++ *
++ * @ioc
++ * @mf
++ * @timeout - timeout
++ *
++ * Return: 0 for success
++ * non-zero, failure
++ **/
++static int
++csmisas_send_command_wait(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, unsigned long timeout)
++{
++ int rc;
++ unsigned long timeleft;
++
++ timeout = max_t(unsigned long, MPT_IOCTL_DEFAULT_TIMEOUT, timeout);
++ rc = 0;
++ timeleft = 0;
++
++#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
++
++ INITIALIZE_IOCTL_STATUS(ioc->ioctl_cmds.status)
++ ioc->ioctl_cmds.wait_done = 0;
++ ioc->ioctl_cmds.timer.expires = jiffies + (MPT_JIFFY * timeout);
++ ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_TIMER_ACTIVE;
++ ADD_TIMER(&ioc->ioctl_cmds.timer);
++ mpt_put_msg_frame(mptctl_id, ioc, mf);
++ WAIT_EVENT(mptctl_wait, ioc->ioctl_cmds.wait_done);
++
++#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
++
++ INITIALIZE_IOCTL_STATUS(ioc->ioctl_cmds.status)
++ ioc->ioctl_cmds.wait_done = 0;
++ mpt_put_msg_frame(mptctl_id, ioc, mf);
++
++ if ((wait_event_timeout(mptctl_wait,
++ ioc->ioctl_cmds.wait_done == 1, HZ * timeout) <=0) &&
++ ioc->ioctl_cmds.wait_done != 1 ) {
++ mptctl_timeout_expired(ioc,mf);
++ mpt_free_msg_frame(ioc, mf);
++ rc = -1;
++ }
++
++#else
++
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
++ mf->u.hdr.MsgContext);
++ INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
++ mpt_put_msg_frame(mptctl_id, ioc, mf);
++ timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done, timeout*HZ);
++ if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ rc = -1;
++ printk("%s: failed\n", __FUNCTION__);
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(ioc, mf);
++ CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
++ return rc;
++ }
++ if (!timeleft)
++ mptctl_timeout_expired(ioc, mf);
++ }
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
++#endif
++ return rc;
++}
++
++/**
++ * csmisas_send_handshake_wait
++ *
++ * Handshake a mf to firmware
++ *
++ * @ioc
++ * @mf
++ * @mf_size
++ * @timeout - timeout
++ *
++ * Return: 0 for success
++ * non-zero, failure
++ **/
++static int
++csmisas_send_handshake_wait(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, unsigned long timeout)
++{
++ int rc;
++ unsigned long timeleft;
++
++ timeout = max_t(unsigned long, MPT_IOCTL_DEFAULT_TIMEOUT, timeout);
++ rc = 0;
++ timeleft = 0;
++
++#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
++
++ INITIALIZE_IOCTL_STATUS(ioc->taskmgmt_cmds.status)
++ ioc->taskmgmt_cmds.timer.expires = jiffies + (MPT_JIFFY*timeout);
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_TIMER_ACTIVE;
++ ioc->taskmgmt_cmds.wait_done = 0;
++ ADD_TIMER(&ioc->taskmgmt_cmds.timer);
++ rc = mpt_send_special_message(mptctl_taskmgmt_id, ioc,
++ sizeof(SCSITaskMgmt_t), (u32*)mf, timeout, CAN_SLEEP);
++ if (rc != 0)
++ return rc;
++ WAIT_EVENT(mptctl_taskmgmt_wait, ioc->taskmgmt_cmds.wait_done);
++
++#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
++
++ INITIALIZE_IOCTL_STATUS(ioc->taskmgmt_cmds.status)
++ ioc->taskmgmt_cmds.wait_done = 0;
++ rc = mpt_send_special_message(mptctl_taskmgmt_id, ioc,
++ sizeof(SCSITaskMgmt_t), (u32*)mf, timeout, CAN_SLEEP);
++ if (rc != 0)
++ return rc;
++ if ((wait_event_timeout(mptctl_taskmgmt_wait,
++ ioc->taskmgmt_cmds.wait_done == 1, HZ * timeout) <=0) &&
++ ioc->taskmgmt_cmds.wait_done != 1 ) {
++ mptctl_timeout_expired(ioc, mf);
++ mpt_free_msg_frame(ioc, mf);
++ rc = -1;
++ }
++
++#else
++ INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ mpt_put_msg_frame_hi_pri(mptctl_taskmgmt_id, ioc, mf);
++ timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
++ if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ rc = -1;
++ printk("%s: failed\n", __FUNCTION__);
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(ioc, mf);
++ CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ return rc;
++ }
++ if (!timeleft)
++ mptctl_timeout_expired(ioc, mf);
++ }
++#endif
++ return rc;
++}
++
++/**
++ * csmisas_get_number_hotspares - returns num hot spares in this ioc
++ * @ioc: Pointer to MPT_ADAPTER structure
++ *
++ * Return: number of hotspares
++ *
++ **/
++static int
++csmisas_get_number_hotspares(MPT_ADAPTER *ioc)
++{
++ ConfigPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ IOCPage5_t *buffer = NULL;
++ dma_addr_t dma_handle;
++ int data_sz;
++ int rc;
++
++ memset(&hdr, 0, sizeof(ConfigPageHeader_t));
++ memset(&cfg, 0, sizeof(CONFIGPARMS));
++
++ rc = 0;
++ data_sz = 0;
++ hdr.PageNumber = 5;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_IOC;
++ cfg.cfghdr.hdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if (mpt_config(ioc, &cfg) != 0)
++ goto get_ioc_pg5;
++
++ if (hdr.PageLength == 0)
++ goto get_ioc_pg5;
++
++ data_sz = hdr.PageLength * 4;
++ buffer = (IOCPage5_t *) pci_alloc_consistent(ioc->pcidev,
++ data_sz, &dma_handle);
++ if (!buffer)
++ goto get_ioc_pg5;
++
++ memset((u8 *)buffer, 0, data_sz);
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if (mpt_config(ioc, &cfg) != 0)
++ goto get_ioc_pg5;
++
++ rc = buffer->NumHotSpares;
++
++ get_ioc_pg5:
++
++ if (buffer)
++ pci_free_consistent(ioc->pcidev, data_sz,
++ (u8 *) buffer, dma_handle);
++
++ return rc;
++}
++
++
++/**
++ * csmisas_get_ioc_pg5 - ioc Page 5 hot spares
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @pIocPage5: ioc page 5
++ * @data_size: expected data size(units=bytes)
++ *
++ * Return: 0 for success
++ * -ENOMEM if no memory available
++ * -EPERM if not allowed due to ISR context
++ * -EAGAIN if no msg frames currently available
++ * -EFAULT for non-successful reply or no reply (timeout)
++ **/
++static int
++csmisas_get_ioc_pg5(MPT_ADAPTER *ioc, IOCPage5_t *iocPage5, int data_size)
++{
++ ConfigPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ IOCPage5_t *buffer = NULL;
++ dma_addr_t dma_handle;
++ int data_sz;
++ int rc;
++
++ memset(&hdr, 0, sizeof(ConfigPageHeader_t));
++ memset(&cfg, 0, sizeof(CONFIGPARMS));
++
++ rc = 0;
++ data_sz = 0;
++ hdr.PageNumber = 5;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_IOC;
++ cfg.cfghdr.hdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0)
++ goto get_ioc_pg5;
++
++ if (hdr.PageLength == 0) {
++ rc = -EFAULT;
++ goto get_ioc_pg5;
++ }
++
++ data_sz = hdr.PageLength * 4;
++ buffer = (IOCPage5_t *) pci_alloc_consistent(ioc->pcidev,
++ data_sz, &dma_handle);
++ if (!buffer) {
++ rc = -ENOMEM;
++ goto get_ioc_pg5;
++ }
++
++ memset((u8 *)buffer, 0, data_sz);
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0)
++ goto get_ioc_pg5;
++
++ memcpy(iocPage5, buffer, data_size);
++
++ get_ioc_pg5:
++
++ if (buffer)
++ pci_free_consistent(ioc->pcidev, data_sz,
++ (u8 *) buffer, dma_handle);
++
++ return rc;
++}
++
++/**
++ * csmisas_sas_device_pg0 - sas device page 0
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @mptsas_devinfo: structure found in mptsas.h
++ * @form, @form_specific - defines the Page Address field in the config page
++ * (pls refer to chapter 5.1 in the mpi spec)
++ *
++ * Return: 0 for success
++ * -ENOMEM if no memory available
++ * -EPERM if not allowed due to ISR context
++ * -EAGAIN if no msg frames currently available
++ * -EFAULT for non-successful reply or no reply (timeout)
++ **/
++static int
++csmisas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
++ u32 form, u32 form_specific)
++{
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ SasDevicePage0_t *buffer;
++ dma_addr_t dma_handle;
++ u64 sas_address;
++ int rc;
++
++ rc = 0;
++ hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 0;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.pageAddr = form + form_specific;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = 10;
++
++ memset(device_info, 0, sizeof(struct mptsas_devinfo));
++ if ((rc = mpt_config(ioc, &cfg)) != 0)
++ goto out;
++
++ if (!hdr.ExtPageLength) {
++ rc = -ENXIO;
++ goto out;
++ }
++
++ buffer = pci_alloc_consistent(ioc->pcidev,
++ hdr.ExtPageLength * 4, &dma_handle);
++ if (!buffer) {
++ rc = -ENOMEM;
++ goto out;
++ }
++
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0)
++ goto out_free_consistent;
++
++ device_info->handle = le16_to_cpu(buffer->DevHandle);
++ device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
++ device_info->handle_enclosure =
++ le16_to_cpu(buffer->EnclosureHandle);
++ device_info->slot = le16_to_cpu(buffer->Slot);
++ device_info->phy_id = buffer->PhyNum;
++ device_info->port_id = buffer->PhysicalPort;
++ device_info->id = buffer->TargetID;
++ device_info->channel = buffer->Bus;
++ memcpy(&sas_address, &buffer->SASAddress, sizeof(u64));
++ device_info->sas_address = le64_to_cpu(sas_address);
++ device_info->device_info =
++ le32_to_cpu(buffer->DeviceInfo);
++
++ out_free_consistent:
++ pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
++ buffer, dma_handle);
++ out:
++ return rc;
++}
++
++/**
++ * Routine for the CSMI Sas Get Driver Info command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_driver_info(unsigned long arg)
++{
++
++ CSMI_SAS_DRIVER_INFO_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_DRIVER_INFO_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_DRIVER_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in csmi_sas_get_driver_info_buffer struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Fill in the data and return the structure to the calling
++ * program
++ */
++ memcpy( karg.Information.szName, MPT_MISCDEV_BASENAME,
++ sizeof(MPT_MISCDEV_BASENAME));
++ memcpy( karg.Information.szDescription, MPT_CSMI_DESCRIPTION,
++ sizeof(MPT_CSMI_DESCRIPTION));
++
++ karg.Information.usMajorRevision = MPT_LINUX_MAJOR_VERSION;
++ karg.Information.usMinorRevision = MPT_LINUX_MINOR_VERSION;
++ karg.Information.usBuildRevision = MPT_LINUX_BUILD_VERSION;
++ karg.Information.usReleaseRevision = MPT_LINUX_RELEASE_VERSION;
++
++ karg.Information.usCSMIMajorRevision = CSMI_MAJOR_REVISION;
++ karg.Information.usCSMIMinorRevision = CSMI_MINOR_REVISION;
++
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_DRIVER_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to write out csmi_sas_get_driver_info_buffer @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI_SAS_GET_CNTLR_CONFIG command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_cntlr_config(unsigned long arg)
++{
++
++ CSMI_SAS_CNTLR_CONFIG_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_CNTLR_CONFIG_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ u64 mem_phys;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_CNTLR_CONFIG_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in csmi_sas_get_cntlr_config_buffer struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Clear the struct before filling in data. */
++ memset( &karg.Configuration, 0, sizeof(CSMI_SAS_CNTLR_CONFIG));
++
++ /* Fill in the data and return the structure to the calling
++ * program
++ */
++
++ karg.Configuration.uBaseIoAddress = ioc->pio_mem_phys;
++ karg.Configuration.BaseMemoryAddress.uLowPart = ioc->mem_phys;
++ if (sizeof(ioc->mem_phys) == sizeof(u64)) {
++ mem_phys = ioc->mem_phys;
++ karg.Configuration.BaseMemoryAddress.uHighPart =
++ (u32)(mem_phys >> 32);
++ }
++
++ karg.Configuration.uBoardID = (ioc->pcidev->subsystem_device << 16) |
++ (ioc->pcidev->subsystem_vendor);
++
++ karg.Configuration.usSlotNumber =
++ (ioc->pci_slot_number = 0xff) ?
++ SLOT_NUMBER_UNKNOWN : ioc->pci_slot_number;
++ karg.Configuration.bControllerClass = CSMI_SAS_CNTLR_CLASS_HBA;
++ karg.Configuration.bIoBusType = CSMI_SAS_BUS_TYPE_PCI;
++ karg.Configuration.BusAddress.PciAddress.bBusNumber =
++ ioc->pcidev->bus->number;
++ karg.Configuration.BusAddress.PciAddress.bDeviceNumber =
++ PCI_SLOT(ioc->pcidev->devfn);
++ karg.Configuration.BusAddress.PciAddress.bFunctionNumber =
++ PCI_FUNC(ioc->pcidev->devfn);
++ karg.Configuration.BusAddress.PciAddress.bReserved = 0;
++ memcpy( &karg.Configuration.szSerialNumber, ioc->board_tracer, 16 );
++ karg.Configuration.usMajorRevision = ioc->facts.FWVersion.Struct.Major;
++ karg.Configuration.usMinorRevision = ioc->facts.FWVersion.Struct.Minor;
++ karg.Configuration.usBuildRevision = ioc->facts.FWVersion.Struct.Unit;
++ karg.Configuration.usReleaseRevision = ioc->facts.FWVersion.Struct.Dev;
++ karg.Configuration.usBIOSMajorRevision =
++ (ioc->biosVersion & 0xFF000000) >> 24;
++ karg.Configuration.usBIOSMinorRevision =
++ (ioc->biosVersion & 0x00FF0000) >> 16;
++ karg.Configuration.usBIOSBuildRevision =
++ (ioc->biosVersion & 0x0000FF00) >> 8;
++ karg.Configuration.usBIOSReleaseRevision =
++ (ioc->biosVersion & 0x000000FF);
++ karg.Configuration.uControllerFlags = CSMI_SAS_CNTLR_SAS_HBA |
++ CSMI_SAS_CNTLR_FWD_SUPPORT | CSMI_SAS_CNTLR_FWD_ONLINE |
++ CSMI_SAS_CNTLR_FWD_SRESET ;
++
++ /*
++ * Enabling CSMI_SAS_CNTLR_SAS_RAID bit when IR fw detected
++ */
++ if (ioc->ir_firmware)
++ karg.Configuration.uControllerFlags |= CSMI_SAS_CNTLR_SAS_RAID;
++
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* All Rrom entries will be zero. Skip them. */
++ /* bReserved will also be zeros. */
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_DRIVER_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to write out csmi_sas_get_driver_info_buffer @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI Sas Get Controller Status command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_cntlr_status(unsigned long arg)
++{
++
++ CSMI_SAS_CNTLR_STATUS_BUFFER __user *uarg = (void __user *) arg;
++ MPT_ADAPTER *ioc = NULL;
++ CSMI_SAS_CNTLR_STATUS_BUFFER karg;
++ int iocnum;
++ int rc;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_CNTLR_STATUS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in csmi_sas_get_cntlr_status_buffer struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Fill in the data and return the structure to the calling
++ * program
++ */
++
++ rc = mpt_GetIocState(ioc, 1);
++ switch (rc) {
++ case MPI_IOC_STATE_OPERATIONAL:
++ karg.Status.uStatus = CSMI_SAS_CNTLR_STATUS_GOOD;
++ karg.Status.uOfflineReason = 0;
++ break;
++
++ case MPI_IOC_STATE_FAULT:
++ karg.Status.uStatus = CSMI_SAS_CNTLR_STATUS_FAILED;
++ karg.Status.uOfflineReason = 0;
++ break;
++
++ case MPI_IOC_STATE_RESET:
++ case MPI_IOC_STATE_READY:
++ default:
++ karg.Status.uStatus = CSMI_SAS_CNTLR_STATUS_OFFLINE;
++ karg.Status.uOfflineReason =
++ CSMI_SAS_OFFLINE_REASON_INITIALIZING;
++ break;
++ }
++
++ memset(&karg.Status.bReserved, 0, 28);
++
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_CNTLR_STATUS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to write out csmi_sas_get_cntlr_status @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI Sas Get Phy Info command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_phy_info(unsigned long arg)
++{
++ CSMI_SAS_PHY_INFO_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_PHY_INFO_BUFFER *karg;
++ MPT_ADAPTER *ioc = NULL;
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ SasIOUnitPage0_t *sasIoUnitPg0;
++ dma_addr_t sasIoUnitPg0_dma;
++ int sasIoUnitPg0_data_sz;
++ SasPhyPage0_t *sasPhyPg0;
++ dma_addr_t sasPhyPg0_dma;
++ int sasPhyPg0_data_sz;
++ u16 protocol;
++ int iocnum;
++ int rc;
++ int ii;
++ u64 sas_address;
++ struct mptsas_devinfo device_info;
++ int memory_pages;
++
++ sasIoUnitPg0=NULL;
++ sasPhyPg0=NULL;
++ sasIoUnitPg0_data_sz=0;
++ sasPhyPg0_data_sz=0;
++
++ memory_pages = get_order(sizeof(CSMI_SAS_PHY_INFO_BUFFER));
++ karg = (CSMI_SAS_PHY_INFO_BUFFER *)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!karg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc CSMI_SAS_PHY_INFO_BUFFER "
++ "malloc_data_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ (int)sizeof(CSMI_SAS_PHY_INFO_BUFFER), memory_pages);
++ return -ENOMEM;
++ }
++
++ memset(karg, 0, sizeof(*karg));
++
++ if (copy_from_user(karg, uarg, sizeof(CSMI_SAS_PHY_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in csmisas_get_phy_info_buffer struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Fill in the data and return the structure to the calling
++ * program
++ */
++
++ /* Issue a config request to get the number of phys
++ */
++ hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 0;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = 0;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASIOUNITPAGE0_PAGEVERSION: HEADER\n"));
++ dcsmisasprintk(ioc, printk(": rc=%x\n",rc));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto sas_get_phy_info_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto sas_get_phy_info_exit;
++ }
++
++ sasIoUnitPg0_data_sz = hdr.ExtPageLength * 4;
++ rc = -ENOMEM;
++
++ sasIoUnitPg0 = (SasIOUnitPage0_t *) pci_alloc_consistent(ioc->pcidev,
++ sasIoUnitPg0_data_sz, &sasIoUnitPg0_dma);
++
++ if (!sasIoUnitPg0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto sas_get_phy_info_exit;
++ }
++
++ memset((u8 *)sasIoUnitPg0, 0, sasIoUnitPg0_data_sz);
++ cfg.physAddr = sasIoUnitPg0_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASIOUNITPAGE0_PAGEVERSION: PAGE\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto sas_get_phy_info_exit;
++ }
++
++ /* Number of Phys. */
++ karg->Information.bNumberOfPhys = sasIoUnitPg0->NumPhys;
++
++ /* Fill in information for each phy. */
++ for (ii = 0; ii < karg->Information.bNumberOfPhys; ii++) {
++
++/* EDM : dump IO Unit Page 0 data*/
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "---- IO UNIT PAGE 0 ------------\n"));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n",
++ le16_to_cpu(sasIoUnitPg0->PhyData[ii].AttachedDeviceHandle)));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Controller Handle=0x%X\n",
++ le16_to_cpu(sasIoUnitPg0->PhyData[ii].ControllerDevHandle)));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Port=0x%X\n",
++ sasIoUnitPg0->PhyData[ii].Port));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Port Flags=0x%X\n",
++ sasIoUnitPg0->PhyData[ii].PortFlags));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "PHY Flags=0x%X\n",
++ sasIoUnitPg0->PhyData[ii].PhyFlags));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Negotiated Link Rate=0x%X\n",
++ sasIoUnitPg0->PhyData[ii].NegotiatedLinkRate));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Controller PHY Device Info=0x%X\n",
++ le32_to_cpu(sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo)));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "DiscoveryStatus=0x%X\n",
++ le32_to_cpu(sasIoUnitPg0->PhyData[ii].DiscoveryStatus)));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
++/* EDM : debug data */
++
++ /* PHY stuff. */
++ karg->Information.Phy[ii].bPortIdentifier =
++ sasIoUnitPg0->PhyData[ii].Port;
++
++ /* Get the negotiated link rate for the phy. */
++ switch (sasIoUnitPg0->PhyData[ii].NegotiatedLinkRate) {
++
++ case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
++ karg->Information.Phy[ii].bNegotiatedLinkRate =
++ CSMI_SAS_PHY_DISABLED;
++ break;
++
++ case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
++ karg->Information.Phy[ii].bNegotiatedLinkRate =
++ CSMI_SAS_LINK_RATE_FAILED;
++ break;
++
++ case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
++ break;
++
++ case MPI_SAS_IOUNIT0_RATE_1_5:
++ karg->Information.Phy[ii].bNegotiatedLinkRate =
++ CSMI_SAS_LINK_RATE_1_5_GBPS;
++ break;
++
++ case MPI_SAS_IOUNIT0_RATE_3_0:
++ karg->Information.Phy[ii].bNegotiatedLinkRate =
++ CSMI_SAS_LINK_RATE_3_0_GBPS;
++ break;
++
++ case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
++ default:
++ karg->Information.Phy[ii].bNegotiatedLinkRate =
++ CSMI_SAS_LINK_RATE_UNKNOWN;
++ break;
++ }
++
++ if (sasIoUnitPg0->PhyData[ii].PortFlags &
++ MPI_SAS_IOUNIT0_PORT_FLAGS_DISCOVERY_IN_PROGRESS) {
++ karg->Information.Phy[ii].bAutoDiscover =
++ CSMI_SAS_DISCOVER_IN_PROGRESS;
++ } else {
++ karg->Information.Phy[ii].bAutoDiscover =
++ CSMI_SAS_DISCOVER_COMPLETE;
++ }
++
++ /* Issue a config request to get
++ * phy information.
++ */
++ hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 0;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = ii;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASPHY0_PAGEVERSION: HEADER\n"));
++ dcsmisasprintk(ioc, printk(": rc=%x\n",rc));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto sas_get_phy_info_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto sas_get_phy_info_exit;
++ }
++
++ sasPhyPg0_data_sz = hdr.ExtPageLength * 4;
++ rc = -ENOMEM;
++
++ sasPhyPg0 = (SasPhyPage0_t *) pci_alloc_consistent(
++ ioc->pcidev, sasPhyPg0_data_sz, &sasPhyPg0_dma);
++
++ if (! sasPhyPg0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto sas_get_phy_info_exit;
++ }
++
++ memset((u8 *)sasPhyPg0, 0, sasPhyPg0_data_sz);
++ cfg.physAddr = sasPhyPg0_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASPHY0_PAGEVERSION: PAGE\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ pci_free_consistent(ioc->pcidev, sasPhyPg0_data_sz,
++ (u8 *) sasPhyPg0, sasPhyPg0_dma);
++ goto sas_get_phy_info_exit;
++ }
++
++/* EDM : dump PHY Page 0 data*/
++ memcpy(&sas_address, &sasPhyPg0->SASAddress, sizeof(u64));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 0 ------------\n"));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n",
++ le16_to_cpu(sasPhyPg0->AttachedDevHandle)));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n",
++ (unsigned long long)sas_address));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Attached PHY Identifier=0x%X\n",
++ sasPhyPg0->AttachedPhyIdentifier));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Attached Device Info=0x%X\n",
++ le32_to_cpu(sasPhyPg0->AttachedDeviceInfo)));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Programmed Link Rate=0x%X\n",
++ sasPhyPg0->ProgrammedLinkRate));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Hardware Link Rate=0x%X\n",
++ sasPhyPg0->HwLinkRate));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Change Count=0x%X\n",
++ sasPhyPg0->ChangeCount));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "PHY Info=0x%X\n",
++ le32_to_cpu(sasPhyPg0->PhyInfo)));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
++/* EDM : debug data */
++
++ /* save the data */
++
++ /* Set Max hardware link rate.
++ * This value is hard coded
++ * because the HW link rate
++ * is currently being
++ * overwritten in FW.
++ */
++
++ /* Set Max hardware link rate. */
++ switch (sasPhyPg0->HwLinkRate &
++ MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
++
++ case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
++ karg->Information.Phy[ii].bMaximumLinkRate =
++ CSMI_SAS_LINK_RATE_1_5_GBPS;
++ break;
++
++ case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
++ karg->Information.Phy[ii].bMaximumLinkRate =
++ CSMI_SAS_LINK_RATE_3_0_GBPS;
++ break;
++ default:
++ break;
++ }
++
++ /* Set Max programmed link rate. */
++ switch (sasPhyPg0->ProgrammedLinkRate &
++ MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
++
++ case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
++ karg->Information.Phy[ii].bMaximumLinkRate |=
++ (CSMI_SAS_PROGRAMMED_LINK_RATE_1_5_GBPS << 4);
++ break;
++
++ case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
++ karg->Information.Phy[ii].bMaximumLinkRate |=
++ (CSMI_SAS_PROGRAMMED_LINK_RATE_3_0_GBPS << 4);
++ break;
++ default:
++ break;
++ }
++
++ /* Set Min hardware link rate. */
++ switch (sasPhyPg0->HwLinkRate &
++ MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
++
++ case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
++ karg->Information.Phy[ii].bMinimumLinkRate =
++ CSMI_SAS_LINK_RATE_1_5_GBPS;
++ break;
++
++ case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
++ karg->Information.Phy[ii].bMinimumLinkRate =
++ CSMI_SAS_LINK_RATE_3_0_GBPS;
++ break;
++ default:
++ break;
++ }
++
++ /* Set Min programmed link rate. */
++ switch (sasPhyPg0->ProgrammedLinkRate &
++ MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
++
++ case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
++ karg->Information.Phy[ii].bMinimumLinkRate |=
++ (CSMI_SAS_PROGRAMMED_LINK_RATE_1_5_GBPS << 4);
++ break;
++
++ case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
++ karg->Information.Phy[ii].bMinimumLinkRate |=
++ (CSMI_SAS_PROGRAMMED_LINK_RATE_3_0_GBPS << 4);
++ break;
++ default:
++ break;
++ }
++
++ karg->Information.Phy[ii].bPhyChangeCount = sasPhyPg0->ChangeCount;
++ if( sasPhyPg0->PhyInfo & MPI_SAS_PHY0_PHYINFO_VIRTUAL_PHY )
++ karg->Information.Phy[ii].bPhyFeatures = CSMI_SAS_PHY_VIRTUAL_SMP;
++
++ /* Fill in Attached Device
++ * Initiator Port Protocol.
++ * Bits 6:3
++ * More than one bit can be set.
++ */
++ protocol = le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) & 0x78;
++ karg->Information.Phy[ii].Attached.bInitiatorPortProtocol = 0;
++ if (protocol & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
++ karg->Information.Phy[ii].Attached.bInitiatorPortProtocol =
++ CSMI_SAS_PROTOCOL_SSP;
++ if (protocol & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
++ karg->Information.Phy[ii].Attached.bInitiatorPortProtocol |=
++ CSMI_SAS_PROTOCOL_STP;
++ if (protocol & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
++ karg->Information.Phy[ii].Attached.bInitiatorPortProtocol |=
++ CSMI_SAS_PROTOCOL_SMP;
++ if (protocol & MPI_SAS_DEVICE_INFO_SATA_HOST)
++ karg->Information.Phy[ii].Attached.bInitiatorPortProtocol |=
++ CSMI_SAS_PROTOCOL_SATA;
++
++ /* Fill in Phy Target Port
++ * Protocol. Bits 10:7
++ * More than one bit can be set.
++ */
++ protocol = le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) & 0x780;
++ karg->Information.Phy[ii].Attached.bTargetPortProtocol = 0;
++ if (protocol & MPI_SAS_DEVICE_INFO_SSP_TARGET)
++ karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_SSP;
++ if (protocol & MPI_SAS_DEVICE_INFO_STP_TARGET)
++ karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_STP;
++ if (protocol & MPI_SAS_DEVICE_INFO_SMP_TARGET)
++ karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_SMP;
++ if (protocol & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
++ karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_SATA;
++
++
++ /* Fill in Attached device type */
++ switch (le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) &
++ MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
++
++ case MPI_SAS_DEVICE_INFO_NO_DEVICE:
++ karg->Information.Phy[ii].Attached.bDeviceType =
++ CSMI_SAS_NO_DEVICE_ATTACHED;
++ break;
++
++ case MPI_SAS_DEVICE_INFO_END_DEVICE:
++ karg->Information.Phy[ii].Attached.bDeviceType =
++ CSMI_SAS_END_DEVICE;
++ break;
++
++ case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
++ karg->Information.Phy[ii].Attached.bDeviceType =
++ CSMI_SAS_EDGE_EXPANDER_DEVICE;
++ break;
++
++ case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
++ karg->Information.Phy[ii].Attached.bDeviceType =
++ CSMI_SAS_FANOUT_EXPANDER_DEVICE;
++ break;
++ }
++
++ /* Identify Info. */
++ switch (le32_to_cpu(sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo) &
++ MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
++
++ case MPI_SAS_DEVICE_INFO_NO_DEVICE:
++ karg->Information.Phy[ii].Identify.bDeviceType =
++ CSMI_SAS_NO_DEVICE_ATTACHED;
++ break;
++
++ case MPI_SAS_DEVICE_INFO_END_DEVICE:
++ karg->Information.Phy[ii].Identify.bDeviceType =
++ CSMI_SAS_END_DEVICE;
++ break;
++
++ case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
++ karg->Information.Phy[ii].Identify.bDeviceType =
++ CSMI_SAS_EDGE_EXPANDER_DEVICE;
++ break;
++
++ case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
++ karg->Information.Phy[ii].Identify.bDeviceType =
++ CSMI_SAS_FANOUT_EXPANDER_DEVICE;
++ break;
++ }
++
++ /* Fill in Phy Initiator Port Protocol. Bits 6:3
++ * More than one bit can be set, fall through cases.
++ */
++ protocol = le32_to_cpu(
++ sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo) & 0x78;
++ karg->Information.Phy[ii].Identify.bInitiatorPortProtocol = 0;
++ if( protocol & MPI_SAS_DEVICE_INFO_SSP_INITIATOR )
++ karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
++ CSMI_SAS_PROTOCOL_SSP;
++ if( protocol & MPI_SAS_DEVICE_INFO_STP_INITIATOR )
++ karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
++ CSMI_SAS_PROTOCOL_STP;
++ if( protocol & MPI_SAS_DEVICE_INFO_SMP_INITIATOR )
++ karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
++ CSMI_SAS_PROTOCOL_SMP;
++ if( protocol & MPI_SAS_DEVICE_INFO_SATA_HOST )
++ karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
++ CSMI_SAS_PROTOCOL_SATA;
++
++ /* Fill in Phy Target Port Protocol. Bits 10:7
++ * More than one bit can be set, fall through cases.
++ */
++ protocol = le32_to_cpu(
++ sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo) & 0x780;
++ karg->Information.Phy[ii].Identify.bTargetPortProtocol = 0;
++ if( protocol & MPI_SAS_DEVICE_INFO_SSP_TARGET )
++ karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_SSP;
++ if( protocol & MPI_SAS_DEVICE_INFO_STP_TARGET )
++ karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_STP;
++ if( protocol & MPI_SAS_DEVICE_INFO_SMP_TARGET )
++ karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_SMP;
++ if( protocol & MPI_SAS_DEVICE_INFO_SATA_DEVICE )
++ karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
++ CSMI_SAS_PROTOCOL_SATA;
++
++ /* Setup SAS Address for the attached device */
++ if (sasPhyPg0->AttachedDevHandle) {
++ sas_address = reverse_byte_order64(sas_address);
++ memcpy(karg->Information.Phy[ii].Attached.bSASAddress,
++ &sas_address, sizeof(u64));
++ karg->Information.Phy[ii].Attached.bPhyIdentifier =
++ sasPhyPg0->AttachedPhyIdentifier;
++ }
++
++ /* Setup SAS Address for the parent device */
++ csmisas_sas_device_pg0(ioc, &device_info,
++ (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ sasIoUnitPg0->PhyData[ii].ControllerDevHandle);
++ sas_address = reverse_byte_order64(device_info.sas_address);
++ memcpy(karg->Information.Phy[ii].Identify.bSASAddress,
++ &sas_address, sizeof(u64));
++ karg->Information.Phy[ii].Identify.bPhyIdentifier = ii;
++
++ pci_free_consistent(ioc->pcidev, sasPhyPg0_data_sz,
++ (u8 *) sasPhyPg0, sasPhyPg0_dma);
++ }
++
++sas_get_phy_info_exit:
++
++ if (sasIoUnitPg0)
++ pci_free_consistent(ioc->pcidev, sasIoUnitPg0_data_sz,
++ (u8 *) sasIoUnitPg0, sasIoUnitPg0_dma);
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, karg,
++ sizeof(CSMI_SAS_PHY_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to write out csmisas_get_phy_info_buffer @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ free_pages((unsigned long)karg, memory_pages);
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Set PHY Info command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_set_phy_info(unsigned long arg)
++{
++ CSMI_SAS_SET_PHY_INFO_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_SET_PHY_INFO_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_SET_PHY_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_set_phy_info struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++/* TODO - implement IOCTL here */
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_BAD_CNTL_CODE;
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": not implemented\n"));
++
++// cim_set_phy_info_exit:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_SET_PHY_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_set_phy_info @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++
++}
++
++/**
++ * Prototype Routine for the CSMI Sas Get SCSI Address command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_scsi_address(unsigned long arg)
++{
++ CSMI_SAS_GET_SCSI_ADDRESS_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_GET_SCSI_ADDRESS_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ u64 sas_address;
++ struct sas_device_info *sas_info;
++
++ if (copy_from_user(&karg, uarg,
++ sizeof(CSMI_SAS_GET_SCSI_ADDRESS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_get_scsi_address struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* reverse byte order the sas address */
++ memcpy(&sas_address, karg.bSASAddress, sizeof(u64));
++ sas_address = reverse_byte_order64(sas_address);
++
++ /* Search the list for the matching SAS address. */
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_NO_SCSI_ADDRESS;
++ karg.bPathId = 0;
++ karg.bTargetId = 0;
++ karg.bLun = 0;
++
++ sas_info = csmisas_get_device_component_by_sas_addr(ioc, sas_address);
++ if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume)
++ goto csmisas_get_scsi_address_exit;
++
++ karg.bPathId = sas_info->os.channel;
++ karg.bTargetId = sas_info->os.id;
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ csmisas_get_scsi_address_exit:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_GET_SCSI_ADDRESS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_get_scsi_address @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI Sas Get SCSI Address command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_sata_signature(unsigned long arg)
++{
++ CSMI_SAS_SATA_SIGNATURE_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_SATA_SIGNATURE_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ int rc, jj;
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ SasPhyPage0_t *sasPhyPg0;
++ dma_addr_t sasPhyPg0_dma;
++ int sasPhyPg0_data_sz;
++ SasDevicePage1_t *sasDevicePg1;
++ dma_addr_t sasDevicePg1_dma;
++ int sasDevicePg1_data_sz;
++ u8 phyId;
++ u64 sas_address;
++
++ sasPhyPg0=NULL;
++ sasPhyPg0_data_sz=0;
++ sasDevicePg1=NULL;
++ sasDevicePg1_data_sz=0;
++
++ if (copy_from_user(&karg, uarg,
++ sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_sata_signature struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++ phyId = karg.Signature.bPhyIdentifier;
++ if (phyId >= ioc->num_ports) {
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_PHY_DOES_NOT_EXIST;
++ dcsmisasprintk(ioc, printk(KERN_WARNING ": phyId >= ioc->num_ports\n"));
++ goto cim_sata_signature_exit;
++ }
++
++ /* Default to success.*/
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* Issue a config request to get the devHandle of the attached device
++ */
++
++ /* Issue a config request to get phy information. */
++ hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 0;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = phyId;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASPHY0_PAGEVERSION: HEADER\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++
++ sasPhyPg0_data_sz = hdr.ExtPageLength * 4;
++ rc = -ENOMEM;
++
++ sasPhyPg0 = (SasPhyPage0_t *) pci_alloc_consistent(ioc->pcidev,
++ sasPhyPg0_data_sz, &sasPhyPg0_dma);
++
++ if (! sasPhyPg0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++ memset((u8 *)sasPhyPg0, 0, sasPhyPg0_data_sz);
++ cfg.physAddr = sasPhyPg0_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASPHY0_PAGEVERSION: PAGE\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++ /* Make sure a SATA device is attached. */
++ if ((le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) &
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE) == 0) {
++ dcsmisasprintk(ioc, printk(KERN_WARNING ": NOT A SATA DEVICE\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_NO_SATA_DEVICE;
++ goto cim_sata_signature_exit;
++ }
++
++ /* Get device page 1 for FIS signature. */
++ hdr.PageVersion = MPI_SASDEVICE1_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 1 /* page number 1 */;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++
++ cfg.pageAddr = ((MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT) |
++ le16_to_cpu(sasPhyPg0->AttachedDevHandle));
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASDEVICE1_PAGEVERSION: HEADER\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++ sasDevicePg1_data_sz = hdr.ExtPageLength * 4;
++ rc = -ENOMEM;
++
++ sasDevicePg1 = (SasDevicePage1_t *) pci_alloc_consistent
++ (ioc->pcidev, sasDevicePg1_data_sz, &sasDevicePg1_dma);
++
++ if (! sasDevicePg1) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++ memset((u8 *)sasDevicePg1, 0, sasDevicePg1_data_sz);
++ cfg.physAddr = sasDevicePg1_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASDEVICE1_PAGEVERSION: PAGE\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sata_signature_exit;
++ }
++
++/* EDM : dump Device Page 1 data*/
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "---- SAS DEVICE PAGE 1 ---------\n"));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Handle=0x%x\n",sasDevicePg1->DevHandle));
++ memcpy(&sas_address, &sasDevicePg1->SASAddress, sizeof(u64));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n",
++ (unsigned long long)sas_address));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Target ID=0x%x\n",sasDevicePg1->TargetID));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Bus=0x%x\n",sasDevicePg1->Bus));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Initial Reg Device FIS="));
++ for(jj=0;jj<20;jj++)
++ dcsmisasprintk(ioc, printk("%02x ",
++ ((u8 *)&sasDevicePg1->InitialRegDeviceFIS)[jj]));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\n\n"));
++/* EDM : debug data */
++
++ memcpy(karg.Signature.bSignatureFIS,
++ sasDevicePg1->InitialRegDeviceFIS,20);
++
++ cim_sata_signature_exit:
++
++ if (sasPhyPg0)
++ pci_free_consistent(ioc->pcidev, sasPhyPg0_data_sz,
++ (u8 *) sasPhyPg0, sasPhyPg0_dma);
++
++ if (sasDevicePg1)
++ pci_free_consistent(ioc->pcidev, sasDevicePg1_data_sz,
++ (u8 *) sasDevicePg1, sasDevicePg1_dma);
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_sata_signature @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI Sas Get SCSI Address command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_device_address(unsigned long arg)
++{
++ CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ struct sas_device_info *sas_info;
++ u64 sas_address;
++
++ if (copy_from_user(&karg, uarg,
++ sizeof(CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_get_device_address_buffer struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_NO_DEVICE_ADDRESS;
++ memset(karg.bSASAddress, 0, sizeof(u64));
++ memset(karg.bSASLun, 0, sizeof(karg.bSASLun));
++
++ /* Search the list for the matching SAS address. */
++ sas_info = csmisas_get_device_component_by_os(ioc, karg.bPathId,
++ karg.bTargetId);
++ if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume)
++ goto csmisas_get_device_address_exit;
++
++ sas_address = reverse_byte_order64(sas_info->sas_address);
++ memcpy(karg.bSASAddress, &sas_address, sizeof(u64));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ csmisas_get_device_address_exit:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_get_device_address_buffer @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI Sas Get Link Errors command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_link_errors(unsigned long arg)
++{
++ CSMI_SAS_LINK_ERRORS_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_LINK_ERRORS_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ MPT_FRAME_HDR *mf = NULL;
++ MPIHeader_t *mpi_hdr;
++ int iocnum;
++ int rc;
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ SasPhyPage1_t *sasPhyPage1;
++ dma_addr_t sasPhyPage1_dma;
++ int sasPhyPage1_data_sz;
++ SasIoUnitControlRequest_t *sasIoUnitCntrReq;
++ SasIoUnitControlReply_t *sasIoUnitCntrReply;
++ u8 phyId;
++ u16 ioc_status;
++ u32 MsgContext;
++
++ sasPhyPage1=NULL;
++ sasPhyPage1_data_sz=0;
++
++ if (copy_from_user(&karg, uarg,
++ sizeof(CSMI_SAS_LINK_ERRORS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmisas_get_link_errors struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++ phyId = karg.Information.bPhyIdentifier;
++ if (phyId >= ioc->num_ports) {
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_PHY_DOES_NOT_EXIST;
++ dcsmisasprintk(ioc, printk(KERN_WARNING ": phyId >= ioc->num_ports\n"));
++ goto cim_get_link_errors_exit;
++ }
++
++ /* Default to success.*/
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* Issue a config request to get the devHandle of the attached device
++ */
++
++ /* Issue a config request to get phy information. */
++ hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 1 /* page number 1*/;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = phyId;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: MPI_SASPHY1_PAGEVERSION: HEADER\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_link_errors_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_link_errors_exit;
++ }
++
++
++ sasPhyPage1_data_sz = hdr.ExtPageLength * 4;
++ rc = -ENOMEM;
++
++ sasPhyPage1 = (SasPhyPage1_t *) pci_alloc_consistent(ioc->pcidev,
++ sasPhyPage1_data_sz, &sasPhyPage1_dma);
++
++ if (! sasPhyPage1) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_link_errors_exit;
++ }
++
++ memset((u8 *)sasPhyPage1, 0, sasPhyPage1_data_sz);
++ cfg.physAddr = sasPhyPage1_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ /* Don't check if this failed. Already in a
++ * failure case.
++ */
++ dcsmisasprintk(ioc, printk(KERN_ERR ": FAILED: MPI_SASPHY1_PAGEVERSION: PAGE\n"));
++ dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_link_errors_exit;
++ }
++
++/* EDM : dump PHY Page 1 data*/
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 1 ------------\n"));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Invalid Dword Count=0x%x\n",
++ sasPhyPage1->InvalidDwordCount));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Running Disparity Error Count=0x%x\n",
++ sasPhyPage1->RunningDisparityErrorCount));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "Loss Dword Synch Count=0x%x\n",
++ sasPhyPage1->LossDwordSynchCount));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "PHY Reset Problem Count=0x%x\n",
++ sasPhyPage1->PhyResetProblemCount));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\n\n"));
++/* EDM : debug data */
++
++ karg.Information.uInvalidDwordCount =
++ le32_to_cpu(sasPhyPage1->InvalidDwordCount);
++ karg.Information.uRunningDisparityErrorCount =
++ le32_to_cpu(sasPhyPage1->RunningDisparityErrorCount);
++ karg.Information.uLossOfDwordSyncCount =
++ le32_to_cpu(sasPhyPage1->LossDwordSynchCount);
++ karg.Information.uPhyResetProblemCount =
++ le32_to_cpu(sasPhyPage1->PhyResetProblemCount);
++
++ if (karg.Information.bResetCounts ==
++ CSMI_SAS_LINK_ERROR_DONT_RESET_COUNTS ) {
++ goto cim_get_link_errors_exit;
++ }
++
++ /* Clear Error log
++ *
++ * Issue IOUNIT Control Reqeust Message
++ */
++
++ /* Get a MF for this command.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_link_errors_exit;
++ }
++
++ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
++ sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
++ memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
++ sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
++ sasIoUnitCntrReq->MsgContext = MsgContext;
++ sasIoUnitCntrReq->PhyNum = phyId;
++ sasIoUnitCntrReq->Operation = MPI_SAS_OP_PHY_CLEAR_ERROR_LOG;
++
++ if (csmisas_send_command_wait(ioc, mf, karg.IoctlHeader.Timeout) != 0) {
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_link_errors_exit;
++ }
++
++ /* process the completed Reply Message Frame */
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
++
++ sasIoUnitCntrReply =
++ (SasIoUnitControlReply_t *)ioc->ioctl_cmds.reply;
++ ioc_status = le16_to_cpu(sasIoUnitCntrReply->IOCStatus)
++ & MPI_IOCSTATUS_MASK;
++
++ if (ioc_status != MPI_IOCSTATUS_SUCCESS) {
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": SAS IO Unit Control: "));
++ dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X\n",
++ sasIoUnitCntrReply->IOCStatus,
++ sasIoUnitCntrReply->IOCLogInfo));
++ }
++ }
++
++ cim_get_link_errors_exit:
++
++ if (sasPhyPage1)
++ pci_free_consistent(ioc->pcidev, sasPhyPage1_data_sz,
++ (u8 *) sasPhyPage1, sasPhyPage1_dma);
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_LINK_ERRORS_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmisas_get_link_errors @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++
++}
++
++/**
++ * Prototype Routine for the CSMI SAS SMP Passthru command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_smp_passthru(unsigned long arg)
++{
++ CSMI_SAS_SMP_PASSTHRU_BUFFER __user *uarg = (void __user *) arg;
++ MPT_ADAPTER *ioc;
++ CSMI_SAS_SMP_PASSTHRU_BUFFER *karg;
++ pSmpPassthroughRequest_t smpReq;
++ pSmpPassthroughReply_t smpReply;
++ MPT_FRAME_HDR *mf = NULL;
++ MPIHeader_t *mpi_hdr;
++ char *psge;
++ int iocnum, flagsLength;
++ void * request_data;
++ dma_addr_t request_data_dma;
++ u32 request_data_sz;
++ void * response_data;
++ dma_addr_t response_data_dma;
++ u32 response_data_sz;
++ u16 ioc_status;
++ u64 sas_address;
++ u32 MsgContext;
++ int malloc_data_sz;
++ int memory_pages;
++
++ malloc_data_sz = sizeof(CSMI_SAS_SMP_PASSTHRU_BUFFER);
++ memory_pages = get_order(malloc_data_sz);
++ karg = (CSMI_SAS_SMP_PASSTHRU_BUFFER *)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!karg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc CSMI_SAS_SMP_PASSTHRU_BUFFER "
++ "malloc_data_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ malloc_data_sz, memory_pages);
++ return -ENOMEM;
++ }
++
++ if (copy_from_user(karg, uarg, sizeof(CSMI_SAS_SMP_PASSTHRU_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_smp_passthru struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ request_data = NULL;
++ response_data = NULL;
++ response_data_sz = sizeof(CSMI_SAS_SMP_RESPONSE);
++ request_data_sz = karg->Parameters.uRequestLength;
++
++ if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (ioc->ioc_reset_in_progress) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Busy with IOC Reset \n",
++ __FILE__, __LINE__,__FUNCTION__);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EBUSY;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Default to success.*/
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* Do some error checking on the request. */
++ if (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_SELECT_PHY_OR_PORT;
++ goto cim_smp_passthru_exit;
++ }
++
++ if ((request_data_sz > 0xFFFF) || (!request_data_sz)) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_smp_passthru_exit;
++ }
++
++ /* Get a free request frame and save the message context.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_smp_passthru_exit;
++ }
++
++ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
++ smpReq = (pSmpPassthroughRequest_t ) mf;
++
++ memset(smpReq,0,ioc->req_sz);
++
++ memcpy(&sas_address, karg->Parameters.bDestinationSASAddress,
++ sizeof(u64));
++ sas_address = cpu_to_le64(reverse_byte_order64(sas_address));
++ memcpy(&smpReq->SASAddress, &sas_address, sizeof(u64));
++
++ /* Fill in smp request. */
++ smpReq->PhysicalPort = karg->Parameters.bPortIdentifier;
++ smpReq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
++ smpReq->RequestDataLength = cpu_to_le16(request_data_sz);
++ smpReq->ConnectionRate = karg->Parameters.bConnectionRate;
++ smpReq->MsgContext = MsgContext;
++ smpReq->Reserved2 = 0;
++ smpReq->Reserved3 = 0;
++
++ /*
++ * Prepare the necessary pointers to run
++ * through the SGL generation
++ */
++
++ psge = (char *)&smpReq->SGL;
++
++ /* setup the *Request* payload SGE */
++ flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
++ MPI_SGE_FLAGS_SYSTEM_ADDRESS |
++ MPI_SGE_FLAGS_HOST_TO_IOC |
++ MPI_SGE_FLAGS_END_OF_BUFFER;
++
++ flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
++ flagsLength |= request_data_sz;
++
++ request_data = pci_alloc_consistent(
++ ioc->pcidev, request_data_sz, &request_data_dma);
++
++ if (!request_data) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ mpt_free_msg_frame(ioc, mf);
++ goto cim_smp_passthru_exit;
++ }
++
++ ioc->add_sge(psge, flagsLength, request_data_dma);
++ psge += ioc->SGE_size;
++
++ memcpy(request_data, &karg->Parameters.Request, request_data_sz);
++
++ /* setup the *Response* payload SGE */
++ response_data = pci_alloc_consistent(
++ ioc->pcidev, response_data_sz, &response_data_dma);
++
++ if (!response_data) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ mpt_free_msg_frame(ioc, mf);
++ goto cim_smp_passthru_exit;
++ }
++
++ flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
++ MPI_SGE_FLAGS_SYSTEM_ADDRESS |
++ MPI_SGE_FLAGS_IOC_TO_HOST |
++ MPI_SGE_FLAGS_END_OF_BUFFER;
++
++ flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
++ flagsLength |= response_data_sz;
++
++ ioc->add_sge(psge, flagsLength, response_data_dma);
++
++ if (csmisas_send_command_wait(ioc, mf, karg->IoctlHeader.Timeout) != 0) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_smp_passthru_exit;
++ }
++
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": SMP Passthru: oh no, there is no reply!!"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_smp_passthru_exit;
++ }
++
++ /* process the completed Reply Message Frame */
++ smpReply = (pSmpPassthroughReply_t )ioc->ioctl_cmds.reply;
++ ioc_status = le16_to_cpu(smpReply->IOCStatus) & MPI_IOCSTATUS_MASK;
++
++ if ((ioc_status != MPI_IOCSTATUS_SUCCESS) &&
++ (ioc_status != MPI_IOCSTATUS_SCSI_DATA_UNDERRUN)) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": SMP Passthru: "));
++ dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X SASStatus=0x%X\n",
++ le16_to_cpu(smpReply->IOCStatus),
++ le32_to_cpu(smpReply->IOCLogInfo),
++ smpReply->SASStatus));
++ goto cim_smp_passthru_exit;
++ }
++
++ karg->Parameters.bConnectionStatus =
++ map_sas_status_to_csmi(smpReply->SASStatus);
++
++
++ if (le16_to_cpu(smpReply->ResponseDataLength)) {
++ karg->Parameters.uResponseBytes = le16_to_cpu(smpReply->ResponseDataLength);
++ memcpy(&karg->Parameters.Response,
++ response_data, le16_to_cpu(smpReply->ResponseDataLength));
++ }
++
++ cim_smp_passthru_exit:
++
++ if (request_data)
++ pci_free_consistent(ioc->pcidev, request_data_sz,
++ (u8 *)request_data, request_data_dma);
++
++ if (response_data)
++ pci_free_consistent(ioc->pcidev, response_data_sz,
++ (u8 *)response_data, response_data_dma);
++
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, karg,
++ sizeof(CSMI_SAS_SMP_PASSTHRU_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_smp_passthru @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ free_pages((unsigned long)karg, memory_pages);
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": %s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS SSP Passthru command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int csmisas_ssp_passthru(unsigned long arg)
++{
++ CSMI_SAS_SSP_PASSTHRU_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_SSP_PASSTHRU_BUFFER karg_hdr, * karg;
++ MPT_ADAPTER *ioc = NULL;
++ pSCSIIORequest_t pScsiRequest;
++ pSCSIIOReply_t pScsiReply;
++ MPT_FRAME_HDR *mf = NULL;
++ MPIHeader_t *mpi_hdr;
++ int iocnum,ii;
++ u64 sas_address;
++ u16 req_idx;
++ char *psge;
++ int flagsLength;
++ void * request_data;
++ dma_addr_t request_data_dma;
++ u32 request_data_sz;
++ int malloc_data_sz;
++ int memory_pages;
++ u16 ioc_status;
++ u8 volume_id;
++ u8 volume_bus;
++ u8 is_hidden_raid_component;
++ u8 channel;
++ u8 id;
++ struct sas_device_info *sas_info;
++ u8 skey, asc, ascq;
++ u32 MsgContext;
++
++ if (copy_from_user(&karg_hdr, uarg, sizeof(CSMI_SAS_SSP_PASSTHRU_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_ssp_passthru struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ request_data = NULL;
++ request_data_sz = karg_hdr.Parameters.uDataLength;
++ channel = 0;
++ id = 0;
++ volume_id = 0;
++ volume_bus = 0;
++ is_hidden_raid_component = 0;
++
++ malloc_data_sz = (request_data_sz +
++ offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER, bDataBuffer));
++ memory_pages = get_order(malloc_data_sz);
++ karg = (CSMI_SAS_SSP_PASSTHRU_BUFFER *)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!karg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc SAS_SSP_PASSTHRU_BUFFER "
++ "malloc_data_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ malloc_data_sz, memory_pages);
++ return -ENOMEM;
++ }
++
++ memset(karg, 0, sizeof(*karg));
++
++ if (copy_from_user(karg, uarg, request_data_sz +
++ offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER,bDataBuffer))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_ssp_passthru struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ /*
++ * some checks of the incoming frame
++ */
++ if ( offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER,bDataBuffer) +
++ request_data_sz - sizeof(IOCTL_HEADER) >
++ karg->IoctlHeader.Length ) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ "%s::%s()"
++ " @%d - expected datalen incorrect!\n",
++ __FILE__, __FUNCTION__, __LINE__));
++ goto cim_ssp_passthru_exit;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ goto cim_ssp_passthru_exit;
++ }
++
++ if (ioc->ioc_reset_in_progress) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Busy with IOC Reset \n",
++ __FILE__, __LINE__,__FUNCTION__);
++ return -EBUSY;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
++ printk(KERN_ERR "%s::%s()@%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ goto cim_ssp_passthru_exit;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Default to success.
++ */
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* Neither a phy nor a port has been selected.
++ */
++ if ((karg->Parameters.bPhyIdentifier == CSMI_SAS_USE_PORT_IDENTIFIER) &&
++ (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT)) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_SELECT_PHY_OR_PORT;
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ "%s::%s()"
++ " @%d - incorrect bPhyIdentifier and bPortIdentifier!\n",
++ __FILE__, __FUNCTION__, __LINE__));
++ goto cim_ssp_passthru_exit;
++ }
++
++ /* A phy has been selected. Verify that it's valid.
++ */
++ if (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT) {
++
++ /* Is the phy in range? */
++ if (karg->Parameters.bPhyIdentifier >= ioc->num_ports) {
++ dcsmisasprintk(ioc, printk(KERN_WARNING ": phyId >= ioc->num_ports (%d %d)\n",
++ karg->Parameters.bPhyIdentifier,
++ ioc->num_ports));
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_PHY_DOES_NOT_EXIST;
++ goto cim_ssp_passthru_exit;
++ }
++ }
++
++ if(karg->Parameters.bAdditionalCDBLength) {
++ /* TODO - SCSI IO (32) Request Message support
++ */
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": greater than 16-byte cdb "
++ "is not supported!\n"));
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ goto cim_ssp_passthru_exit;
++ }
++
++ /* we will use SAS address to resolve the scsi adddressing
++ */
++ memcpy(&sas_address, karg->Parameters.bDestinationSASAddress,
++ sizeof(u64));
++ sas_address = reverse_byte_order64(sas_address);
++
++ /* Search the list for the matching SAS address.
++ */
++ sas_info = csmisas_get_device_component_by_sas_addr(ioc, sas_address);
++ if (!sas_info || sas_info->is_cached) {
++ /*
++ *Invalid SAS address
++ */
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ "%s::%s() @%d - couldn't find associated "
++ "SASAddress=%llX!\n", __FILE__, __FUNCTION__, __LINE__,
++ (unsigned long long)sas_address));
++ goto cim_ssp_passthru_exit;
++ }
++
++ id = sas_info->fw.id;
++ channel = sas_info->fw.channel;
++
++ if (csmisas_is_phys_disk(ioc, channel, id)) {
++ id = csmisas_raid_id_to_num(ioc, channel, id);
++ channel = 0;
++ is_hidden_raid_component = 1;
++ }
++
++ /* Get a free request frame and save the message context.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_ssp_passthru_exit;
++ }
++
++ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
++ pScsiRequest = (pSCSIIORequest_t) mf;
++ req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
++
++ memset(pScsiRequest,0,sizeof(SCSIIORequest_t));
++
++ /* Fill in SCSI IO (16) request.
++ */
++
++ pScsiRequest->Function = (is_hidden_raid_component == 1) ?
++ MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH : MPI_FUNCTION_SCSI_IO_REQUEST;
++ pScsiRequest->TargetID = id;
++ pScsiRequest->Bus = channel;
++ memcpy(pScsiRequest->LUN, &karg->Parameters.bLun, 8);
++ pScsiRequest->CDBLength = karg->Parameters.bCDBLength;
++ pScsiRequest->DataLength = cpu_to_le32(request_data_sz);
++ pScsiRequest->MsgContext = MsgContext;
++ memcpy(pScsiRequest->CDB, karg->Parameters.bCDB,
++ pScsiRequest->CDBLength);
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\tchannel = %d id = %d ",
++ sas_info->fw.channel, sas_info->fw.id));
++ dcsmisasprintk(ioc, if(is_hidden_raid_component)
++ printk(KERN_DEBUG "num_id = %d ", id));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\tcdb_len = %d request_len = %d\n",
++ pScsiRequest->CDBLength, request_data_sz));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\t"));
++ dcsmisasprintk(ioc, for (ii = 0; ii < pScsiRequest->CDBLength; ++ii)
++ printk(" %02x", pScsiRequest->CDB[ii]));
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
++
++ /* direction
++ */
++ if (karg->Parameters.uFlags & CSMI_SAS_SSP_READ) {
++ pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_READ);
++ } else if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE) {
++ pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_WRITE);
++ } else if ((karg->Parameters.uFlags & CSMI_SAS_SSP_UNSPECIFIED) &&
++ (!karg->Parameters.uDataLength)) {
++ /* no data transfer
++ */
++ pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_NODATATRANSFER);
++ } else {
++ /* no direction specified
++ */
++ pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_READ);
++ pScsiRequest->MsgFlags =
++ MPI_SCSIIO_MSGFLGS_CMD_DETERMINES_DATA_DIR;
++ }
++
++ pScsiRequest->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
++ if (ioc->sg_addr_size == sizeof(u64))
++ pScsiRequest->MsgFlags |= MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64;
++
++ /* task attributes
++ */
++ if((karg->Parameters.uFlags && 0xFF) == 0) {
++ pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_SIMPLEQ);
++ } else if (karg->Parameters.uFlags &
++ CSMI_SAS_SSP_TASK_ATTRIBUTE_HEAD_OF_QUEUE) {
++ pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_HEADOFQ);
++ } else if (karg->Parameters.uFlags &
++ CSMI_SAS_SSP_TASK_ATTRIBUTE_ORDERED) {
++ pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_ORDEREDQ);
++ } else if (karg->Parameters.uFlags &
++ CSMI_SAS_SSP_TASK_ATTRIBUTE_ACA) {
++ pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_ACAQ);
++ } else {
++ pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_UNTAGGED);
++ }
++
++ /* setup sense
++ */
++ pScsiRequest->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
++ pScsiRequest->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma +
++ (req_idx * MPT_SENSE_BUFFER_ALLOC));
++
++ /* setup databuffer sg, assuming we fit everything one contiguous buffer
++ */
++ psge = (char *)&pScsiRequest->SGL;
++
++ if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE) {
++ flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
++ } else if (karg->Parameters.uFlags & CSMI_SAS_SSP_READ) {
++ flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
++ }else {
++ flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
++ MPI_SGE_FLAGS_DIRECTION )
++ << MPI_SGE_FLAGS_SHIFT;
++ }
++ flagsLength |= request_data_sz;
++
++ if ( request_data_sz > 0) {
++ request_data = pci_alloc_consistent(
++ ioc->pcidev, request_data_sz, &request_data_dma);
++
++ if (request_data == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED "
++ "request_data_sz=%d\n", request_data_sz));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ mpt_free_msg_frame(ioc, mf);
++ goto cim_ssp_passthru_exit;
++ }
++
++ ioc->add_sge(psge, flagsLength, request_data_dma);
++ if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE)
++ memcpy(request_data, karg->bDataBuffer, request_data_sz);
++ } else {
++ ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
++ }
++
++ if (csmisas_send_command_wait(ioc, mf, karg->IoctlHeader.Timeout) != 0) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_ssp_passthru_exit;
++ }
++
++ memset(&karg->Status,0,sizeof(CSMI_SAS_SSP_PASSTHRU_STATUS));
++ karg->Status.bConnectionStatus = CSMI_SAS_OPEN_ACCEPT;
++ karg->Status.bDataPresent = CSMI_SAS_SSP_NO_DATA_PRESENT;
++ karg->Status.bStatus = GOOD;
++ karg->Status.bResponseLength[0] = 0;
++ karg->Status.bResponseLength[1] = 0;
++ karg->Status.uDataBytes = request_data_sz;
++
++ /* process the completed Reply Message Frame */
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
++
++ pScsiReply = (pSCSIIOReply_t ) ioc->ioctl_cmds.reply;
++ karg->Status.bStatus = pScsiReply->SCSIStatus;
++ karg->Status.uDataBytes = min(le32_to_cpu(pScsiReply->TransferCount),
++ request_data_sz);
++ ioc_status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
++
++ if (pScsiReply->SCSIState ==
++ MPI_SCSI_STATE_AUTOSENSE_VALID) {
++ karg->Status.bConnectionStatus =
++ CSMI_SAS_SSP_SENSE_DATA_PRESENT;
++ karg->Status.bResponseLength[0] =
++ (u8)le32_to_cpu(pScsiReply->SenseCount) & 0xFF;
++ memcpy(karg->Status.bResponse,
++ ioc->ioctl_cmds.sense, le32_to_cpu(pScsiReply->SenseCount));
++
++ skey = ioc->ioctl_cmds.sense[2] & 0x0F;
++ asc = ioc->ioctl_cmds.sense[12];
++ ascq = ioc->ioctl_cmds.sense[13];
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "\t [sense_key,asc,ascq]: "
++ "[0x%02x,0x%02x,0x%02x]\n",
++ skey, asc, ascq));
++
++ } else if(pScsiReply->SCSIState ==
++ MPI_SCSI_STATE_RESPONSE_INFO_VALID) {
++ karg->Status.bDataPresent =
++ CSMI_SAS_SSP_RESPONSE_DATA_PRESENT;
++ karg->Status.bResponseLength[0] =
++ sizeof(pScsiReply->ResponseInfo);
++ for (ii=0;ii<sizeof(pScsiReply->ResponseInfo);ii++) {
++ karg->Status.bResponse[ii] =
++ ((u8*)&pScsiReply->ResponseInfo)[
++ (sizeof(pScsiReply->ResponseInfo)-1)-ii];
++ }
++ } else if ((ioc_status != MPI_IOCSTATUS_SUCCESS) &&
++ (ioc_status != MPI_IOCSTATUS_SCSI_RECOVERED_ERROR) &&
++ (ioc_status != MPI_IOCSTATUS_SCSI_DATA_UNDERRUN)) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": SCSI IO : "));
++ dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X\n",
++ pScsiReply->IOCStatus,
++ pScsiReply->IOCLogInfo));
++ }
++ }
++
++ if ((karg->Status.uDataBytes) && (request_data) &&
++ (karg->Parameters.uFlags & CSMI_SAS_SSP_READ)) {
++ if (copy_to_user((void __user *)uarg->bDataBuffer,
++ request_data, karg->Status.uDataBytes)) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to write data to user %p\n",
++ __FILE__, __LINE__,__FUNCTION__,
++ (void*)karg->bDataBuffer);
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ }
++ }
++
++ cim_ssp_passthru_exit:
++
++
++ if (request_data)
++ pci_free_consistent(ioc->pcidev, request_data_sz,
++ (u8 *)request_data, request_data_dma);
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, karg,
++ offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER, bDataBuffer))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_ssp_passthru @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ free_pages((unsigned long)karg, memory_pages);
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS STP Passthru command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_stp_passthru(unsigned long arg)
++{
++ CSMI_SAS_STP_PASSTHRU_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_STP_PASSTHRU_BUFFER karg_hdr, *karg;
++ MPT_ADAPTER *ioc = NULL;
++ pSataPassthroughRequest_t pSataRequest;
++ pSataPassthroughReply_t pSataReply;
++ MPT_FRAME_HDR *mf = NULL;
++ MPIHeader_t *mpi_hdr;
++ int iocnum;
++ u32 data_sz;
++ u64 sas_address;
++ u16 req_idx;
++ char *psge;
++ int flagsLength;
++ void * request_data;
++ dma_addr_t request_data_dma;
++ u32 request_data_sz;
++ int malloc_data_sz;
++ int memory_pages;
++ u8 channel;
++ u8 id;
++ u8 volume_id;
++ u8 volume_bus;
++ struct sas_device_info *sas_info;
++ u16 ioc_status;
++ u32 MsgContext;
++
++ if (copy_from_user(&karg_hdr, uarg, sizeof(CSMI_SAS_STP_PASSTHRU_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ request_data=NULL;
++ request_data_sz = karg_hdr.Parameters.uDataLength;
++ volume_id = 0;
++ volume_bus = 0;
++ channel = 0;
++ id = 0;
++
++ malloc_data_sz = (request_data_sz +
++ offsetof(CSMI_SAS_STP_PASSTHRU_BUFFER, bDataBuffer));
++ memory_pages = get_order(malloc_data_sz);
++ karg = (CSMI_SAS_STP_PASSTHRU_BUFFER *)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!karg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc CSMI_SAS_STP_PASSTHRU_BUFFER "
++ "malloc_data_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ malloc_data_sz, memory_pages);
++ return -ENOMEM;
++ }
++
++ memset(karg, 0, sizeof(*karg));
++
++ if (copy_from_user(karg, uarg, malloc_data_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_ssp_passthru struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (ioc->ioc_reset_in_progress) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Busy with IOC Reset \n",
++ __FILE__, __LINE__,__FUNCTION__);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EBUSY;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Default to success.
++ */
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* Neither a phy nor a port has been selected.
++ */
++ if ((karg->Parameters.bPhyIdentifier == CSMI_SAS_USE_PORT_IDENTIFIER) &&
++ (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT)) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_SELECT_PHY_OR_PORT;
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ "%s::%s() @%d - incorrect bPhyIdentifier and bPortIdentifier!\n",
++ __FILE__,__FUNCTION__, __LINE__));
++ goto cim_stp_passthru_exit;
++ }
++
++ /* A phy has been selected. Verify that it's valid.
++ */
++ if (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT) {
++
++ /* Is the phy in range? */
++ if (karg->Parameters.bPhyIdentifier >= ioc->num_ports) {
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_PHY_DOES_NOT_EXIST;
++ goto cim_stp_passthru_exit;
++ }
++ }
++
++ data_sz = sizeof(CSMI_SAS_STP_PASSTHRU_BUFFER) -
++ sizeof(IOCTL_HEADER) - sizeof(u8*) +
++ request_data_sz;
++
++ if ( data_sz > karg->IoctlHeader.Length ) {
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ "%s::%s() @%d - expected datalen incorrect!\n",
++ __FILE__, __FUNCTION__,__LINE__));
++ goto cim_stp_passthru_exit;
++ }
++
++
++ /* we will use SAS address to resolve the scsi adddressing
++ */
++ memcpy(&sas_address, karg->Parameters.bDestinationSASAddress,
++ sizeof(u64));
++ sas_address = reverse_byte_order64(sas_address);
++
++ /* Search the list for the matching SAS address.
++ */
++ sas_info = csmisas_get_device_component_by_sas_addr(ioc, sas_address);
++ if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume) {
++ /*
++ *Invalid SAS address
++ */
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ "%s::%s() @%d - couldn't find associated "
++ "SASAddress=%llX!\n", __FILE__, __FUNCTION__, __LINE__,
++ (unsigned long long)sas_address));
++ goto cim_stp_passthru_exit;
++ }
++
++ id = sas_info->fw.id;
++ channel = sas_info->fw.channel;
++
++ /* check that this is an STP or SATA target device
++ */
++ if ( !(sas_info->device_info & MPI_SAS_DEVICE_INFO_STP_TARGET ) &&
++ !(sas_info->device_info & MPI_SAS_DEVICE_INFO_SATA_DEVICE )) {
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ goto cim_stp_passthru_exit;
++ }
++
++ /* Get a free request frame and save the message context.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_stp_passthru_exit;
++ }
++
++ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
++ pSataRequest = (pSataPassthroughRequest_t) mf;
++ req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
++
++ memset(pSataRequest,0,sizeof(pSataPassthroughRequest_t));
++
++ pSataRequest->TargetID = id;
++ pSataRequest->Bus = channel;
++ pSataRequest->Function = MPI_FUNCTION_SATA_PASSTHROUGH;
++ pSataRequest->PassthroughFlags = cpu_to_le16(karg->Parameters.uFlags);
++ pSataRequest->ConnectionRate = karg->Parameters.bConnectionRate;
++ pSataRequest->MsgContext = MsgContext;
++ pSataRequest->DataLength = cpu_to_le32(request_data_sz);
++ pSataRequest->MsgFlags = 0;
++ memcpy( pSataRequest->CommandFIS,karg->Parameters.bCommandFIS, 20);
++
++ psge = (char *)&pSataRequest->SGL;
++ if (karg->Parameters.uFlags & CSMI_SAS_STP_WRITE) {
++ flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
++ } else if (karg->Parameters.uFlags & CSMI_SAS_STP_READ) {
++ flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
++ }else {
++ flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
++ MPI_SGE_FLAGS_DIRECTION )
++ << MPI_SGE_FLAGS_SHIFT;
++ }
++
++ flagsLength |= request_data_sz;
++ if (request_data_sz > 0) {
++ request_data = pci_alloc_consistent(
++ ioc->pcidev, request_data_sz, &request_data_dma);
++
++ if (request_data == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ mpt_free_msg_frame(ioc, mf);
++ goto cim_stp_passthru_exit;
++ }
++
++ ioc->add_sge(psge, flagsLength, request_data_dma);
++ if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE)
++ memcpy(request_data, karg->bDataBuffer, request_data_sz);
++ } else {
++ ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
++ }
++
++ if (csmisas_send_command_wait(ioc, mf, karg->IoctlHeader.Timeout) != 0) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_stp_passthru_exit;
++ }
++
++ memset(&karg->Status,0,sizeof(CSMI_SAS_STP_PASSTHRU_STATUS));
++
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": STP Passthru: oh no, there is no reply!!"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_stp_passthru_exit;
++ }
++
++ /* process the completed Reply Message Frame */
++ pSataReply = (pSataPassthroughReply_t ) ioc->ioctl_cmds.reply;
++ ioc_status = le16_to_cpu(pSataReply->IOCStatus) & MPI_IOCSTATUS_MASK;
++
++ if (ioc_status != MPI_IOCSTATUS_SUCCESS &&
++ ioc_status != MPI_IOCSTATUS_SCSI_DATA_UNDERRUN) {
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": STP Passthru: "));
++ dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X SASStatus=0x%X\n",
++ le16_to_cpu(pSataReply->IOCStatus),
++ le32_to_cpu(pSataReply->IOCLogInfo),
++ pSataReply->SASStatus));
++ }
++
++ karg->Status.bConnectionStatus =
++ map_sas_status_to_csmi(pSataReply->SASStatus);
++
++ memcpy(karg->Status.bStatusFIS,pSataReply->StatusFIS, 20);
++
++ /*
++ * for now, just zero out uSCR array,
++ * then copy the one dword returned
++ * in the reply frame into uSCR[0]
++ */
++ memset( karg->Status.uSCR, 0, 64);
++ karg->Status.uSCR[0] = le32_to_cpu(pSataReply->StatusControlRegisters);
++
++ if((le32_to_cpu(pSataReply->TransferCount)) && (request_data) &&
++ (karg->Parameters.uFlags & CSMI_SAS_STP_READ)) {
++ karg->Status.uDataBytes =
++ min(le32_to_cpu(pSataReply->TransferCount),request_data_sz);
++ if (copy_to_user((void __user *)uarg->bDataBuffer,
++ request_data, karg->Status.uDataBytes)) {
++ printk(KERN_ERR "%s::%s() @%d - "
++ "Unable to write data to user %p\n",
++ __FILE__, __FUNCTION__, __LINE__,
++ (void*)karg->bDataBuffer);
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ }
++ }
++
++ cim_stp_passthru_exit:
++
++ if (request_data)
++ pci_free_consistent(ioc->pcidev, request_data_sz,
++ (u8 *)request_data, request_data_dma);
++
++ /* Copy th data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, karg,
++ offsetof(CSMI_SAS_STP_PASSTHRU_BUFFER, bDataBuffer))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_ssp_passthru @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ free_pages((unsigned long)karg, memory_pages);
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": %s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Firmware Download command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_firmware_download(unsigned long arg)
++{
++ CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ pMpiFwHeader_t pFwHeader=NULL;
++
++ if (copy_from_user(&karg, uarg,
++ sizeof(CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_firmware_download struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ /* Default to success.*/
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++ karg.Information.usStatus = CSMI_SAS_FWD_SUCCESS;
++ karg.Information.usSeverity = CSMI_SAS_FWD_INFORMATION;
++
++ /* some checks of the incoming frame */
++ if ((karg.Information.uBufferLength +
++ sizeof(CSMI_SAS_FIRMWARE_DOWNLOAD)) >
++ karg.IoctlHeader.Length) {
++ karg.IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ karg.Information.usStatus = CSMI_SAS_FWD_FAILED;
++ goto cim_firmware_download_exit;
++ }
++
++ if ( karg.Information.uDownloadFlags &
++ (CSMI_SAS_FWD_SOFT_RESET | CSMI_SAS_FWD_VALIDATE)) {
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ karg.Information.usStatus = CSMI_SAS_FWD_REJECT;
++ karg.Information.usSeverity = CSMI_SAS_FWD_ERROR;
++ goto cim_firmware_download_exit;
++ }
++
++ /* now we need to alloc memory so we can pull in the
++ * fw image attached to end of incoming packet.
++ */
++ pFwHeader = kmalloc(karg.Information.uBufferLength, GFP_KERNEL);
++ if (!pFwHeader){
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ karg.Information.usStatus = CSMI_SAS_FWD_REJECT;
++ karg.Information.usSeverity = CSMI_SAS_FWD_ERROR;
++ goto cim_firmware_download_exit;
++ }
++ memset(pFwHeader, 0, sizeof(*pFwHeader));
++
++ if (copy_from_user(pFwHeader, uarg->bDataBuffer,
++ karg.Information.uBufferLength)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in pFwHeader @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if ( !((pFwHeader->Signature0 == MPI_FW_HEADER_SIGNATURE_0) &&
++ (pFwHeader->Signature1 == MPI_FW_HEADER_SIGNATURE_1) &&
++ (pFwHeader->Signature2 == MPI_FW_HEADER_SIGNATURE_2))) {
++ // the signature check failed
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ karg.Information.usStatus = CSMI_SAS_FWD_REJECT;
++ karg.Information.usSeverity = CSMI_SAS_FWD_ERROR;
++ goto cim_firmware_download_exit;
++ }
++
++ if ( mptctl_do_fw_download(karg.IoctlHeader.IOControllerNumber,
++ uarg->bDataBuffer, karg.Information.uBufferLength)
++ != 0) {
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ karg.Information.usStatus = CSMI_SAS_FWD_FAILED;
++ karg.Information.usSeverity = CSMI_SAS_FWD_FATAL;
++ goto cim_firmware_download_exit;
++ }
++
++ if((karg.Information.uDownloadFlags & CSMI_SAS_FWD_SOFT_RESET) ||
++ (karg.Information.uDownloadFlags & CSMI_SAS_FWD_HARD_RESET)) {
++ if (mpt_HardResetHandler(ioc, CAN_SLEEP) != 0) {
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ karg.Information.usStatus = CSMI_SAS_FWD_FAILED;
++ karg.Information.usSeverity = CSMI_SAS_FWD_FATAL;
++ }
++ }
++
++ cim_firmware_download_exit:
++
++ if(pFwHeader)
++ kfree(pFwHeader);
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_firmware_download @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Get RAID Info command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_raid_info(unsigned long arg)
++{
++ CSMI_SAS_RAID_INFO_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_RAID_INFO_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ u32 raidFlags;
++ u8 maxRaidTypes;
++ u8 maxDrivesPerSet;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_RAID_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_get_raid_info struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ if (!ioc->raid_data.pIocPg2)
++ goto csmisas_get_raid_info_out;
++ karg.Information.uNumRaidSets =
++ ioc->raid_data.pIocPg2->NumActiveVolumes;
++ karg.Information.uMaxRaidSets = ioc->raid_data.pIocPg2->MaxVolumes;
++ if( ioc->raid_data.pIocPg6 ) {
++ // get absolute maximum for all RAID sets
++ maxDrivesPerSet = ioc->raid_data.pIocPg6->MaxDrivesIS;
++ maxDrivesPerSet = max(ioc->raid_data.pIocPg6->MaxDrivesIM,
++ maxDrivesPerSet);
++ maxDrivesPerSet = max(ioc->raid_data.pIocPg6->MaxDrivesIME,
++ maxDrivesPerSet);
++ karg.Information.uMaxDrivesPerSet = maxDrivesPerSet;
++ }
++ else
++ karg.Information.uMaxDrivesPerSet = 8;
++ // For bMaxRaidSets, count bits set in bits 0-6 of CapabilitiesFlags
++ raidFlags = ioc->raid_data.pIocPg2->CapabilitiesFlags & 0x0000007F;
++ for( maxRaidTypes=0; raidFlags; maxRaidTypes++ )
++ raidFlags &= raidFlags - 1;
++ karg.Information.bMaxRaidTypes = maxRaidTypes;
++ // ulMinRaidSetBlocks hard coded to 1MB until available from config page
++ karg.Information.ulMinRaidSetBlocks.uLowPart = 2048;
++ karg.Information.ulMinRaidSetBlocks.uHighPart = 0;
++ karg.Information.ulMaxRaidSetBlocks.uLowPart = 0xffffffff;
++ if( ioc->raid_data.pIocPg2->CapabilitiesFlags &
++ MPI_IOCPAGE2_CAP_FLAGS_RAID_64_BIT_ADDRESSING )
++ karg.Information.ulMaxRaidSetBlocks.uHighPart = 0xffffffff;
++ else
++ karg.Information.ulMaxRaidSetBlocks.uHighPart = 0;
++ karg.Information.uMaxPhysicalDrives =
++ ioc->raid_data.pIocPg2->MaxPhysDisks;
++ karg.Information.uMaxExtents = 1;
++ karg.Information.uMaxModules = 0;
++ karg.Information.uMaxTransformationMemory = 0;
++ karg.Information.uChangeCount = ioc->csmi_change_count;
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++csmisas_get_raid_info_out:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_RAID_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_get_raid_info @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * csmisas_do_raid - Format and Issue a RAID volume request message.
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @action: What do be done.
++ * @PhysDiskNum: Logical target id.
++ * @VolumeBus: Target locations bus.
++ * @VolumeId: Volume id
++ *
++ * Returns: < 0 on a fatal error
++ * 0 on success
++ *
++ * Remark: Wait to return until reply processed by the ISR.
++ **/
++static int
++csmisas_do_raid(MPT_ADAPTER *ioc, u8 action, u8 PhysDiskNum, u8 VolumeBus, u8 VolumeId, pMpiRaidActionReply_t reply)
++{
++ MpiRaidActionRequest_t *pReq;
++ MpiRaidActionReply_t *pReply;
++ MPT_FRAME_HDR *mf;
++
++ /* Get and Populate a free Frame
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++ return -EAGAIN;
++ }
++ pReq = (MpiRaidActionRequest_t *)mf;
++ pReq->Action = action;
++ pReq->Reserved1 = 0;
++ pReq->ChainOffset = 0;
++ pReq->Function = MPI_FUNCTION_RAID_ACTION;
++ pReq->VolumeID = VolumeId;
++ pReq->VolumeBus = VolumeBus;
++ pReq->PhysDiskNum = PhysDiskNum;
++ pReq->MsgFlags = 0;
++ pReq->Reserved2 = 0;
++ pReq->ActionDataWord = 0; /* Reserved for this action */
++ //pReq->ActionDataSGE = 0;
++
++ ioc->add_sge((char *)&pReq->ActionDataSGE,
++ MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
++
++ if (csmisas_send_command_wait(ioc, mf, MPT_IOCTL_DEFAULT_TIMEOUT) != 0)
++ return -ENODATA;
++
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) &&
++ (reply != NULL)){
++ pReply = (MpiRaidActionReply_t *)&(ioc->ioctl_cmds.reply);
++ memcpy(reply, pReply,
++ min(ioc->reply_sz,
++ 4*pReply->MsgLength));
++ }
++
++ return 0;
++}
++
++/**
++ * csmisas_raid_inq
++ * @ioc = per host instance
++ * @opcode = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH or
++ * MPI_FUNCTION_SCSI_IO_REQUEST
++ * @id = target id
++ * @bus = target bus
++ * @inq_vpd = inquiry data, returned
++ * @inq_vpd_sz = maximum size of inquiry data
++ *
++ * Return = 0(sucess), non-zero(failure)
++ **/
++static int
++csmisas_raid_inq(MPT_ADAPTER *ioc, u8 opcode, u8 bus, u8 id, u8 inq_vpd_page,
++ u8 * inq_vpd, u32 inq_vpd_sz)
++{
++ MPT_FRAME_HDR *mf = NULL;
++ MPIHeader_t *mpi_hdr;
++ pSCSIIORequest_t pScsiRequest;
++ u16 req_idx;
++ char *psge;
++ u8 inq_vpd_cdb[6];
++ u8 *request_data=NULL;
++ dma_addr_t request_data_dma;
++ u32 request_data_sz;
++ int rc = 0;
++ u32 MsgContext;
++
++ request_data_sz = inq_vpd_sz;
++
++ /* fill-in cdb */
++ memset(inq_vpd_cdb, 0, sizeof(inq_vpd_cdb));
++ inq_vpd_cdb[0] = 0x12;
++ if (inq_vpd_page) {
++ inq_vpd_cdb[1] = 0x01; /* evpd bit */
++ inq_vpd_cdb[2] = inq_vpd_page;
++ }
++ inq_vpd_cdb[3] = (u8)(request_data_sz >> 8);
++ inq_vpd_cdb[4] = (u8)request_data_sz;
++
++ /* Get a free request frame and save the message context.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++ goto csmisas_raid_inq_exit;
++ }
++
++ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
++ pScsiRequest = (pSCSIIORequest_t) mf;
++ req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
++
++ memset(pScsiRequest,0,sizeof(SCSIIORequest_t));
++ pScsiRequest->Function = opcode;
++ pScsiRequest->TargetID = id;
++ pScsiRequest->Bus = bus;
++ pScsiRequest->CDBLength = 6;
++ pScsiRequest->DataLength = cpu_to_le32(request_data_sz);
++ pScsiRequest->MsgContext = MsgContext;
++ memcpy(pScsiRequest->CDB,inq_vpd_cdb,pScsiRequest->CDBLength);
++ pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_READ);
++ pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_SIMPLEQ);
++ pScsiRequest->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
++ if (ioc->sg_addr_size == sizeof(u64))
++ pScsiRequest->MsgFlags |= MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64;
++
++ /* setup sense
++ */
++ pScsiRequest->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
++ pScsiRequest->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma +
++ (req_idx * MPT_SENSE_BUFFER_ALLOC));
++
++ request_data = pci_alloc_consistent(
++ ioc->pcidev, request_data_sz, &request_data_dma);
++
++ if (request_data == NULL) {
++ mpt_free_msg_frame(ioc, mf);
++ rc=-1;
++ goto csmisas_raid_inq_exit;
++ }
++
++ memset(request_data,0,request_data_sz);
++ psge = (char *)&pScsiRequest->SGL;
++ ioc->add_sge(psge, (MPT_SGE_FLAGS_SSIMPLE_READ | 0xFC) ,
++ request_data_dma);
++
++ if (csmisas_send_command_wait(ioc, mf, MPT_IOCTL_DEFAULT_TIMEOUT) != 0) {
++ rc=-1;
++ goto csmisas_raid_inq_exit;
++ }
++
++ /* copy the request_data */
++ memcpy(inq_vpd, request_data, request_data_sz);
++
++ csmisas_raid_inq_exit:
++
++ if (request_data)
++ pci_free_consistent(ioc->pcidev, request_data_sz,
++ request_data, request_data_dma);
++
++ return rc;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Get RAID Config command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_raid_config(unsigned long arg)
++{
++ CSMI_SAS_RAID_CONFIG_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_RAID_CONFIG_BUFFER karg,*pKarg=NULL;
++ CONFIGPARMS cfg;
++ ConfigPageHeader_t header;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ u8 volumeID, VolumeBus;
++ u8 physDiskNum, physDiskNumMax;
++ int volumepage0sz = 0;
++ int physdiskpage0sz = 0, ioc_page5_sz = 0;
++ dma_addr_t volume0_dma, physdisk0_dma;
++ dma_addr_t ioc_page5_dma = 0;
++ pRaidVolumePage0_t pVolume0 = NULL;
++ pRaidPhysDiskPage0_t pPhysDisk0 = NULL;
++ pMpiRaidActionReply_t pRaidActionReply = NULL;
++ u32 device_info = 0;
++ pIOCPage5_t pIocPage5 = NULL;
++ int i, idx, csmi_sas_raid_config_buffer_sz;
++ int memory_pages;
++ int copy_buffer_sz = 0;
++ u64 totalMaxLBA, tmpTotalMaxLBA;
++ u64 sas_address;
++ struct sas_device_info *sas_info;
++
++ if (copy_from_user(&karg, uarg, sizeof(IOCTL_HEADER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmisas_get_raid_config struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ csmi_sas_raid_config_buffer_sz = karg.IoctlHeader.Length;
++ memory_pages = get_order(csmi_sas_raid_config_buffer_sz);
++ pKarg = (CSMI_SAS_RAID_CONFIG_BUFFER *)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!pKarg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc RAID_CONFIG_BUFFER "
++ "csmi_sas_raid_config_buffer_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ csmi_sas_raid_config_buffer_sz, memory_pages);
++ return -ENOMEM;
++ }
++ memset(pKarg, 0, sizeof(*pKarg));
++
++ if (copy_from_user(pKarg, uarg, csmi_sas_raid_config_buffer_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmisas_get_raid_config struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(pKarg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ if (pKarg->Configuration.uChangeCount != 0 &&
++ pKarg->Configuration.uChangeCount != ioc->csmi_change_count ) {
++ pKarg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ pKarg->Configuration.uFailureCode =
++ CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID;
++ goto cim_get_raid_config_exit;
++ }
++
++ if (!ioc->raid_data.pIocPg2) {
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ /*
++ * Check to see if the input uRaidSetIndex is
++ * greater than the number of RAID sets
++ */
++ if (pKarg->Configuration.uRaidSetIndex >=
++ ioc->raid_data.pIocPg2->NumActiveVolumes) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_RAID_SET_OUT_OF_RANGE;
++ goto cim_get_raid_config_exit;
++ }
++
++ /*
++ * get RAID Volume Page 0
++ */
++ volumeID = ioc->raid_data.pIocPg2->RaidVolume[pKarg->Configuration.uRaidSetIndex].VolumeID;
++ VolumeBus = ioc->raid_data.pIocPg2->RaidVolume[pKarg->Configuration.uRaidSetIndex].VolumeBus;
++
++ header.PageVersion = 0;
++ header.PageLength = 0;
++ header.PageNumber = 0;
++ header.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
++ cfg.cfghdr.hdr = &header;
++ cfg.physAddr = -1;
++ cfg.pageAddr = (VolumeBus << 8) + volumeID;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0;
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++ if (mpt_config(ioc, &cfg) != 0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ if (header.PageLength == 0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ volumepage0sz = header.PageLength * 4;
++ pVolume0 = pci_alloc_consistent(ioc->pcidev, volumepage0sz,
++ &volume0_dma);
++ if (!pVolume0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.physAddr = volume0_dma;
++ if (mpt_config(ioc, &cfg) != 0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ totalMaxLBA = (u64)le32_to_cpu(pVolume0->MaxLBA) |
++ ((u64)le32_to_cpu(pVolume0->MaxLBAHigh)) << 32;
++ tmpTotalMaxLBA = totalMaxLBA + 1;
++ do_div(tmpTotalMaxLBA, 2048);
++ pKarg->Configuration.bDriveCount = 0;
++ pKarg->Configuration.uCapacity = tmpTotalMaxLBA;
++ pKarg->Configuration.uStripeSize =
++ le32_to_cpu(pVolume0->StripeSize)/2;
++
++ switch(pVolume0->VolumeType) {
++ case MPI_RAID_VOL_TYPE_IS:
++ pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_0;
++ break;
++ case MPI_RAID_VOL_TYPE_IME:
++ pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_10;
++ break;
++ case MPI_RAID_VOL_TYPE_IM:
++ pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_1;
++ break;
++ default:
++ pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_OTHER;
++ break;
++ }
++
++ switch (pVolume0->VolumeStatus.State) {
++ case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
++ pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_OK;
++ break;
++ case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
++ /* Volume is degraded, check if Resyncing or Inactive */
++ pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_DEGRADED;
++ break;
++ case MPI_RAIDVOL0_STATUS_STATE_FAILED:
++ pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_FAILED;
++ break;
++ }
++
++ /* check flags */
++ if (pVolume0->VolumeStatus.Flags &
++ MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE)
++ pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_OFFLINE;
++ else if (pVolume0->VolumeStatus.Flags &
++ MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS)
++ pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_REBUILDING;
++
++ pKarg->Configuration.bInformation = 0; /* default */
++ if(pVolume0->VolumeStatus.Flags &
++ MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS ) {
++
++ uint64_t * ptrUint64;
++ uint64_t totalBlocks64, blocksRemaining64;
++ uint32_t totalBlocks32, blocksRemaining32;
++
++ /* get percentage complete */
++ pRaidActionReply = kmalloc( sizeof(MPI_RAID_VOL_INDICATOR) +
++ offsetof(MSG_RAID_ACTION_REPLY,ActionData),
++ GFP_KERNEL);
++
++ if (!pRaidActionReply){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__,pKarg);
++ goto cim_get_raid_config_exit;
++ }
++ memset(pRaidActionReply, 0, sizeof(*pRaidActionReply));
++
++ csmisas_do_raid(ioc,
++ MPI_RAID_ACTION_INDICATOR_STRUCT,
++ 0, VolumeBus, volumeID, pRaidActionReply);
++
++ ptrUint64 = (uint64_t *)&pRaidActionReply->ActionData;
++ totalBlocks64 = *ptrUint64;
++ ptrUint64++;
++ blocksRemaining64 = *ptrUint64;
++ while(totalBlocks64 > 0xFFFFFFFFUL){
++ totalBlocks64 = totalBlocks64 >> 1;
++ blocksRemaining64 = blocksRemaining64 >> 1;
++ }
++ totalBlocks32 = (uint32_t)totalBlocks64;
++ blocksRemaining32 = (uint32_t)blocksRemaining64;
++
++ if(totalBlocks32)
++ pKarg->Configuration.bInformation =
++ (totalBlocks32 - blocksRemaining32) /
++ (totalBlocks32 / 100);
++
++ kfree(pRaidActionReply);
++ }
++
++ /* fill-in more information depending on data type */
++ if (pKarg->Configuration.bDataType ==
++ CSMI_SAS_RAID_DATA_ADDITIONAL_DATA) {
++ pKarg->Configuration.Data->bLabel[0] = '\0';
++ pKarg->Configuration.Data->bRaidSetLun[1] = 0;
++ pKarg->Configuration.Data->bWriteProtection =
++ CSMI_SAS_RAID_SET_WRITE_PROTECT_UNKNOWN;
++ pKarg->Configuration.Data->bCacheSetting =
++ CSMI_SAS_RAID_SET_CACHE_UNKNOWN;
++ pKarg->Configuration.Data->bCacheRatio = 0;
++ pKarg->Configuration.Data->usBlockSize = 512;
++ pKarg->Configuration.Data->ulRaidSetExtentOffset.uLowPart = 0;
++ pKarg->Configuration.Data->ulRaidSetExtentOffset.uHighPart = 0;
++ pKarg->Configuration.Data->ulRaidSetBlocks.uLowPart =
++ le32_to_cpu(pVolume0->MaxLBA);
++ pKarg->Configuration.Data->ulRaidSetBlocks.uHighPart =
++ le32_to_cpu(pVolume0->MaxLBAHigh);
++ if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IS ||
++ pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IME ) {
++ pKarg->Configuration.Data->uStripeSizeInBlocks =
++ le32_to_cpu(pVolume0->StripeSize);
++ } else {
++ pKarg->Configuration.Data->uStripeSizeInBlocks = 0;
++ }
++ pKarg->Configuration.Data->uSectorsPerTrack = 128;
++ for (i=0; i<16; i++) {
++ // unsupported
++ pKarg->Configuration.Data->bApplicationScratchPad[i] =
++ 0xFF;
++ }
++ pKarg->Configuration.Data->uNumberOfHeads = 16;
++
++ tmpTotalMaxLBA = totalMaxLBA;
++ do_div(tmpTotalMaxLBA,
++ (pKarg->Configuration.Data->uNumberOfHeads *
++ pKarg->Configuration.Data->uSectorsPerTrack));
++ pKarg->Configuration.Data->uNumberOfTracks = tmpTotalMaxLBA;
++ } else if ( pKarg->Configuration.bDataType ==
++ CSMI_SAS_RAID_DATA_DEVICE_ID ) {
++ /* Send inquiry to get VPD Page 0x83 */
++ u32 vpd_page_sz;
++ vpd_page_sz = csmi_sas_raid_config_buffer_sz -
++ offsetof(CSMI_SAS_RAID_CONFIG,DeviceId);
++ if (csmisas_raid_inq(ioc, MPI_FUNCTION_SCSI_IO_REQUEST,
++ VolumeBus, volumeID, 0x83,
++ (u8*)&pKarg->Configuration.DeviceId->bDeviceIdentificationVPDPage,
++ vpd_page_sz) != 0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++ } else {
++ /* suppress drive information */
++ if (pKarg->Configuration.bDriveCount ==
++ CSMI_SAS_RAID_DRIVE_COUNT_SUPRESSED) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++ goto cim_get_raid_config_exit;
++ }
++ }
++
++ /* get hotspare info, used later in this function */
++ if (pVolume0->VolumeSettings.HotSparePool) {
++ /* Read and save IOC Page 5
++ */
++ header.PageVersion = 0;
++ header.PageLength = 0;
++ header.PageNumber = 5;
++ header.PageType = MPI_CONFIG_PAGETYPE_IOC;
++ cfg.cfghdr.hdr = &header;
++ cfg.physAddr = -1;
++ cfg.pageAddr = 0;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0;
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++ if ((mpt_config(ioc, &cfg) == 0) && (header.PageLength)) {
++ ioc_page5_sz = header.PageLength * 4;
++ pIocPage5 = pci_alloc_consistent(ioc->pcidev,
++ ioc_page5_sz,
++ &ioc_page5_dma);
++ memset(pIocPage5,0,ioc_page5_sz);
++ if (ioc_page5_dma) {
++ cfg.physAddr = ioc_page5_dma;
++ cfg.action =
++ MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ mpt_config(ioc, &cfg);
++ }
++ }
++ }
++
++ /*
++ * get RAID Physical Disk Page 0
++ */
++ header.PageVersion = 0;
++ header.PageLength = 0;
++ header.PageNumber = 0;
++ header.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
++ cfg.cfghdr.hdr = &header;
++ cfg.physAddr = -1;
++ cfg.pageAddr = 0;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0;
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++ if (mpt_config(ioc, &cfg) != 0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ if (header.PageLength == 0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ physdiskpage0sz = header.PageLength * 4;
++ pPhysDisk0 = pci_alloc_consistent(ioc->pcidev, physdiskpage0sz,
++ &physdisk0_dma);
++ if (!pPhysDisk0) {
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++ cfg.physAddr = physdisk0_dma;
++
++ physDiskNumMax = (csmi_sas_raid_config_buffer_sz -
++ offsetof(CSMI_SAS_RAID_CONFIG,Drives))
++ / sizeof(CSMI_SAS_RAID_DRIVES);
++
++ tmpTotalMaxLBA = totalMaxLBA;
++ if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IS) {
++ do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks);
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "IS Volume tmpTotalMaxLBA=%llX\n",
++ (unsigned long long)tmpTotalMaxLBA));
++ }
++ else if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IME) {
++ do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks * 2);
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "IME Volume tmpTotalMaxLBA=%llX\n",
++ (unsigned long long)tmpTotalMaxLBA));
++ } else {
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "IM Volume tmpTotalMaxLBA=%llX\n",
++ (unsigned long long)tmpTotalMaxLBA));
++ }
++
++ for (i=0; i< min(pVolume0->NumPhysDisks, physDiskNumMax); i++) {
++
++ physDiskNum = pVolume0->PhysDisk[i].PhysDiskNum;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = physDiskNum;
++ if (mpt_config(ioc, &cfg) != 0){
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_raid_config_exit;
++ }
++
++ pKarg->Configuration.bDriveCount++;
++ if (pKarg->Configuration.bDataType != CSMI_SAS_RAID_DATA_DRIVES)
++ continue;
++
++ /* Search the list for the matching SAS address. */
++ sas_info = csmisas_get_device_component_by_fw(ioc, pPhysDisk0->PhysDiskBus,
++ pPhysDisk0->PhysDiskID);
++ if (sas_info) {
++ sas_address = reverse_byte_order64(sas_info->sas_address);
++ memcpy(pKarg->Configuration.Drives[i].bSASAddress,
++ &sas_address,sizeof(u64));
++ if (!device_info)
++ device_info = sas_info->device_info;
++ }
++
++ memcpy(pKarg->Configuration.Drives[i].bModel,
++ pPhysDisk0->InquiryData.VendorID,
++ offsetof(RAID_PHYS_DISK0_INQUIRY_DATA,ProductRevLevel));
++ memcpy(pKarg->Configuration.Drives[i].bFirmware,
++ pPhysDisk0->InquiryData.ProductRevLevel,
++ sizeof(pPhysDisk0->InquiryData.ProductRevLevel));
++ if (csmisas_is_sata(pPhysDisk0)) {
++ memcpy(&pKarg->Configuration.Drives[i].bSerialNumber,
++ &pPhysDisk0->ExtDiskIdentifier[4],
++ 4);
++ memcpy(&pKarg->Configuration.Drives[i].bSerialNumber[4],
++ &pPhysDisk0->DiskIdentifier,
++ sizeof(pPhysDisk0->DiskIdentifier));
++ } else {
++ memcpy(pKarg->Configuration.Drives[i].bSerialNumber,
++ pPhysDisk0->DiskIdentifier,
++ sizeof(pPhysDisk0->DiskIdentifier));
++ }
++
++ pKarg->Configuration.Drives[i].bDriveUsage =
++ (pPhysDisk0->PhysDiskStatus.Flags &
++ MPI_PHYSDISK0_STATUS_FLAG_INACTIVE_VOLUME) ?
++ CSMI_SAS_DRIVE_CONFIG_NOT_USED :
++ CSMI_SAS_DRIVE_CONFIG_MEMBER;
++
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_OK;
++ if (pPhysDisk0->PhysDiskStatus.State ==
++ MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED) {
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_OFFLINE;
++ } else if(pPhysDisk0->PhysDiskStatus.State) {
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_FAILED;
++ if(pKarg->Configuration.bStatus ==
++ CSMI_SAS_RAID_SET_STATUS_DEGRADED)
++ pKarg->Configuration.bInformation = i;
++ } else if((pVolume0->VolumeStatus.Flags &
++ MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) &&
++ (pPhysDisk0->PhysDiskStatus.Flags &
++ MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC))
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_REBUILDING;
++ else if(pPhysDisk0->ErrorData.SmartCount ||
++ (pPhysDisk0->PhysDiskStatus.Flags &
++ MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC))
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_DEGRADED;
++
++ memset(pKarg->Configuration.Drives[i].bSASLun,
++ 0, sizeof(pKarg->Configuration.Drives[i].bSASLun));
++ if (csmisas_is_sata(pPhysDisk0)) {
++ pKarg->Configuration.Drives[i].bDriveType =
++ CSMI_SAS_DRIVE_TYPE_SATA;
++ } else { /* drive in a volume can only be SAS/SATA */
++ pKarg->Configuration.Drives[i].bDriveType =
++ CSMI_SAS_DRIVE_TYPE_SINGLE_PORT_SAS;
++ if (mpt_raid_phys_disk_get_num_paths(ioc,
++ pVolume0->PhysDisk[i].PhysDiskNum) > 1)
++ pKarg->Configuration.Drives[i].bDriveType =
++ CSMI_SAS_DRIVE_TYPE_DUAL_PORT_SAS;
++ }
++
++ pKarg->Configuration.Drives[i].usBlockSize = 512;
++ pKarg->Configuration.Drives[i].uDriveIndex =
++ pPhysDisk0->PhysDiskNum;
++ pKarg->Configuration.Drives[i].ulTotalUserBlocks.uLowPart =
++ (u32)tmpTotalMaxLBA;
++ pKarg->Configuration.Drives[i].ulTotalUserBlocks.uHighPart =
++ (u32)(tmpTotalMaxLBA >> 32);
++ }
++
++ /* adding hot spare info at the end */
++ if ((pVolume0->VolumeSettings.HotSparePool) && (pIocPage5) &&
++ (pVolume0->VolumeType != MPI_RAID_VOL_TYPE_IS)) {
++ for (idx = 0, i = pVolume0->NumPhysDisks ;
++ idx < pIocPage5->NumHotSpares ; idx++) {
++ if (i >= physDiskNumMax)
++ break;
++ if ((pVolume0->VolumeSettings.HotSparePool &
++ pIocPage5->HotSpare[idx].HotSparePool) == 0)
++ continue;
++ if(pIocPage5->HotSpare[idx].Flags !=
++ MPI_IOC_PAGE_5_HOT_SPARE_ACTIVE)
++ continue;
++ physDiskNum = pIocPage5->HotSpare[idx].PhysDiskNum;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = physDiskNum;
++ if (mpt_config(ioc, &cfg) != 0)
++ continue;
++
++ /* don't mix SSP hot spare
++ * in SATA volume
++ */
++ if (!csmisas_is_sata(pPhysDisk0) &&
++ (device_info &
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE))
++ continue;
++
++ /* don't mix SATA hot spare
++ * in SSP volume
++ */
++ if (csmisas_is_sata(pPhysDisk0) &&
++ (device_info &
++ MPI_SAS_DEVICE_INFO_SSP_TARGET))
++ continue;
++
++ /* capacity check for IM volumes*/
++ if ((pVolume0->VolumeType ==
++ MPI_RAID_VOL_TYPE_IM) &&
++ (totalMaxLBA +
++ (64*2*1024) /* metadata = 64MB*/ >
++ le32_to_cpu(pPhysDisk0->MaxLBA)))
++ continue;
++
++ tmpTotalMaxLBA = totalMaxLBA;
++ do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks);
++ /* capacity check for IME volumes*/
++ if ((pVolume0->VolumeType ==
++ MPI_RAID_VOL_TYPE_IME) &&
++ (((totalMaxLBA +
++ pVolume0->NumPhysDisks) * 2) +
++ (64*2*1024 ) /*metadata = 64MB*/ >
++ le32_to_cpu(pPhysDisk0->MaxLBA)))
++ continue;
++
++ pKarg->Configuration.bDriveCount++;
++ if (pKarg->Configuration.bDataType !=
++ CSMI_SAS_RAID_DATA_DRIVES) {
++ i++;
++ continue;
++ }
++
++ /* Search the list for the matching SAS address. */
++ sas_info = csmisas_get_device_component_by_fw(ioc,
++ pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID);
++ if (sas_info) {
++ sas_address = reverse_byte_order64(sas_info->sas_address);
++ memcpy(pKarg->Configuration.Drives[i].bSASAddress,
++ &sas_address,sizeof(u64));
++ }
++
++ memcpy(pKarg->Configuration.Drives[i].bModel,
++ pPhysDisk0->InquiryData.VendorID,
++ offsetof(RAID_PHYS_DISK0_INQUIRY_DATA,ProductRevLevel));
++ memcpy(pKarg->Configuration.Drives[i].bFirmware,
++ pPhysDisk0->InquiryData.ProductRevLevel,
++ sizeof(pPhysDisk0->InquiryData.ProductRevLevel));
++ if (csmisas_is_sata(pPhysDisk0)) {
++ memcpy(&pKarg->Configuration.Drives[i].bSerialNumber,
++ &pPhysDisk0->ExtDiskIdentifier[4],
++ 4);
++ memcpy(&pKarg->Configuration.Drives[i].bSerialNumber[4],
++ &pPhysDisk0->DiskIdentifier,
++ sizeof(pPhysDisk0->DiskIdentifier));
++ } else {
++ memcpy(pKarg->Configuration.Drives[i].bSerialNumber,
++ pPhysDisk0->DiskIdentifier,
++ sizeof(pPhysDisk0->DiskIdentifier));
++ }
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_OK;
++ if(pPhysDisk0->PhysDiskStatus.State)
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_FAILED;
++ else if(pPhysDisk0->ErrorData.SmartCount)
++ pKarg->Configuration.Drives[i].bDriveStatus =
++ CSMI_SAS_DRIVE_STATUS_DEGRADED;
++ pKarg->Configuration.Drives[i].bDriveUsage =
++ CSMI_SAS_DRIVE_CONFIG_SPARE;
++ pKarg->Configuration.Drives[i].usBlockSize = 512;
++ pKarg->Configuration.Drives[i].uDriveIndex =
++ pPhysDisk0->PhysDiskNum;
++ if (csmisas_is_sata(pPhysDisk0)) {
++ pKarg->Configuration.Drives[i].bDriveType =
++ CSMI_SAS_DRIVE_TYPE_SATA;
++ } else { /* drive in a volume can only be SAS/SATA */
++ pKarg->Configuration.Drives[i].bDriveType =
++ CSMI_SAS_DRIVE_TYPE_SINGLE_PORT_SAS;
++ if (mpt_raid_phys_disk_get_num_paths(ioc,
++ pVolume0->PhysDisk[i].PhysDiskNum) > 1)
++ pKarg->Configuration.Drives[i].bDriveType =
++ CSMI_SAS_DRIVE_TYPE_DUAL_PORT_SAS;
++ }
++ i++;
++ }
++ }
++
++ // Only return data on the first 240 drives
++ if( pKarg->Configuration.bDriveCount > 0xF0 )
++ pKarg->Configuration.bDriveCount =
++ CSMI_SAS_RAID_DRIVE_COUNT_TOO_BIG;
++
++ pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ cim_get_raid_config_exit:
++
++ if (pVolume0 != NULL)
++ pci_free_consistent(ioc->pcidev, volumepage0sz, pVolume0,
++ volume0_dma);
++
++ if(pPhysDisk0 != NULL)
++ pci_free_consistent(ioc->pcidev, physdiskpage0sz, pPhysDisk0,
++ physdisk0_dma);
++
++ if(pIocPage5 != NULL)
++ pci_free_consistent(ioc->pcidev, ioc_page5_sz, pIocPage5,
++ ioc_page5_dma);
++
++ /* Copy the data from kernel memory to user memory
++ */
++
++ /* find the buffer size to copy depending on how much is filled-in */
++ switch (pKarg->Configuration.bDataType) {
++ case CSMI_SAS_RAID_DATA_ADDITIONAL_DATA:
++ copy_buffer_sz = sizeof(IOCTL_HEADER) +
++ offsetof(CSMI_SAS_RAID_CONFIG,Data) +
++ sizeof(CSMI_SAS_RAID_SET_ADDITIONAL_DATA);
++ break;
++ case CSMI_SAS_RAID_DATA_DRIVES:
++ if (pKarg->Configuration.bDriveCount ==
++ CSMI_SAS_RAID_DRIVE_COUNT_SUPRESSED)
++ copy_buffer_sz = sizeof(IOCTL_HEADER) +
++ offsetof(CSMI_SAS_RAID_CONFIG,Drives);
++ else
++ copy_buffer_sz = sizeof(IOCTL_HEADER) +
++ offsetof(CSMI_SAS_RAID_CONFIG,Drives) +
++ (pKarg->Configuration.bDriveCount *
++ sizeof(CSMI_SAS_RAID_DRIVES));
++ break;
++ case CSMI_SAS_RAID_DATA_DEVICE_ID:
++ copy_buffer_sz = csmi_sas_raid_config_buffer_sz;
++ break;
++ }
++
++ if (copy_to_user(uarg, pKarg, copy_buffer_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_get_raid_config @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ free_pages((unsigned long)pKarg, memory_pages);
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Get RAID Features command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_raid_features(unsigned long arg)
++{
++ CSMI_SAS_RAID_FEATURES_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_RAID_FEATURES_BUFFER karg, *pKarg=NULL;
++ int csmi_sas_raid_features_buffer_sz, iocnum;
++ int memory_pages;
++ MPT_ADAPTER *ioc = NULL;
++
++ if (copy_from_user(&karg, uarg, sizeof(IOCTL_HEADER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_get_raid_features struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ csmi_sas_raid_features_buffer_sz = karg.IoctlHeader.Length;
++ memory_pages = get_order(csmi_sas_raid_features_buffer_sz);
++ pKarg = (CSMI_SAS_RAID_FEATURES_BUFFER *)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!pKarg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc RAID_FEATURES_BUFFER "
++ "csmi_sas_raid_features_buffer_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ csmi_sas_raid_features_buffer_sz, memory_pages);
++ return -ENOMEM;
++ }
++ memset(pKarg, 0, sizeof(*pKarg));
++
++ if (copy_from_user(pKarg, uarg, csmi_sas_raid_features_buffer_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_get_raid_features struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(pKarg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ if (pKarg->Information.uChangeCount != 0 &&
++ pKarg->Information.uChangeCount != ioc->csmi_change_count ) {
++ pKarg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ pKarg->Information.uFailureCode =
++ CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID;
++ goto cim_get_raid_features_exit;
++ }
++
++ pKarg->Information.uFeatures = CSMI_SAS_RAID_FEATURE_REBUILD |
++ CSMI_SAS_RAID_FEATURE_SURFACE_SCAN |
++ CSMI_SAS_RAID_FEATURE_SPARES_SHARED;
++ pKarg->Information.bDefaultTransformPriority =
++ CSMI_SAS_PRIORITY_UNKNOWN;
++ pKarg->Information.bTransformPriority = CSMI_SAS_PRIORITY_UNKNOWN;
++ pKarg->Information.bDefaultRebuildPriority = CSMI_SAS_PRIORITY_UNKNOWN;
++ pKarg->Information.bRebuildPriority =
++ pKarg->Information.bDefaultRebuildPriority;
++ pKarg->Information.bDefaultSurfaceScanPriority =
++ CSMI_SAS_PRIORITY_UNKNOWN;
++ pKarg->Information.bSurfaceScanPriority = CSMI_SAS_PRIORITY_UNKNOWN;
++ pKarg->Information.uRaidSetTransformationRules = 0;
++
++ /* IS */
++ pKarg->Information.RaidType[0].bRaidType = CSMI_SAS_RAID_TYPE_0;
++ pKarg->Information.RaidType[0].uSupportedStripeSizeMap = 0x80;
++
++ /* IM */
++ pKarg->Information.RaidType[1].bRaidType = CSMI_SAS_RAID_TYPE_1;
++ pKarg->Information.RaidType[1].uSupportedStripeSizeMap = 0;
++
++ /* IME */
++ pKarg->Information.RaidType[2].bRaidType = CSMI_SAS_RAID_TYPE_1E;
++ pKarg->Information.RaidType[2].uSupportedStripeSizeMap = 0x80;
++
++ pKarg->Information.RaidType[3].bRaidType = CSMI_SAS_RAID_TYPE_END;
++ pKarg->Information.bCacheRatiosSupported[0] =
++ CSMI_SAS_RAID_CACHE_RATIO_END;
++
++ cim_get_raid_features_exit:
++
++ /*
++ * Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, pKarg,
++ sizeof(CSMI_SAS_RAID_FEATURES_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_get_raid_features @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ free_pages((unsigned long)pKarg, memory_pages);
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Set RAID Control command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_set_raid_control(unsigned long arg)
++{
++ CSMI_SAS_RAID_CONTROL_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_RAID_CONTROL_BUFFER karg, *pKarg=NULL;
++ int csmi_sas_raid_control_buffer_sz, iocnum;
++ int memory_pages;
++ MPT_ADAPTER *ioc = NULL;
++
++ if (copy_from_user(&karg, uarg, sizeof(IOCTL_HEADER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_set_raid_control struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ csmi_sas_raid_control_buffer_sz = karg.IoctlHeader.Length;
++ memory_pages = get_order(csmi_sas_raid_control_buffer_sz);
++ pKarg = (CSMI_SAS_RAID_CONTROL_BUFFER *)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!pKarg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc RAID_CONTROL_BUFFER "
++ "csmi_sas_raid_control_buffer_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ csmi_sas_raid_control_buffer_sz, memory_pages);
++ return -ENOMEM;
++ }
++ memset(pKarg, 0, sizeof(*pKarg));
++
++ if (copy_from_user(pKarg, uarg, csmi_sas_raid_control_buffer_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_set_raid_control struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(pKarg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ if (pKarg->Information.uChangeCount != 0 &&
++ pKarg->Information.uChangeCount != ioc->csmi_change_count ) {
++ pKarg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ pKarg->Information.uFailureCode =
++ CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID;
++ goto cim_set_raid_control_exit;
++ }
++
++ if (pKarg->Information.bTransformPriority !=
++ CSMI_SAS_PRIORITY_UNCHANGED) {
++ pKarg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ pKarg->Information.uFailureCode =
++ CSMI_SAS_FAIL_CODE_TRANSFORM_PRIORITY_INVALID;
++ goto cim_set_raid_control_exit;
++ }
++
++ if (pKarg->Information.bRebuildPriority !=
++ CSMI_SAS_PRIORITY_AUTO &&
++ pKarg->Information.bRebuildPriority !=
++ CSMI_SAS_PRIORITY_UNCHANGED) {
++ pKarg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ pKarg->Information.uFailureCode =
++ CSMI_SAS_FAIL_CODE_REBUILD_PRIORITY_INVALID;
++ goto cim_set_raid_control_exit;
++ }
++
++ if (pKarg->Information.bCacheRatioFlag ==
++ CSMI_SAS_RAID_CACHE_RATIO_DISABLE) {
++ pKarg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ pKarg->Information.uFailureCode =
++ CSMI_SAS_FAIL_CODE_CACHE_RATIO_INVALID;
++ goto cim_set_raid_control_exit;
++ }
++
++ if( !strcmp(pKarg->Information.bClearConfiguration,
++ CSMI_SAS_RAID_CLEAR_CONFIGURATION_SIGNATURE) ) {
++ pKarg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ pKarg->Information.uFailureCode =
++ CSMI_SAS_FAIL_CODE_CLEAR_CONFIGURATION_INVALID;
++ goto cim_set_raid_control_exit;
++ }
++
++ pKarg->Information.bFailureDescription[0] = '\0';
++
++ cim_set_raid_control_exit:
++
++ /*
++ * Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, pKarg,
++ sizeof(CSMI_SAS_RAID_CONTROL_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_set_raid_control @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)pKarg, memory_pages);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ free_pages((unsigned long)pKarg, memory_pages);
++ return 0;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Get Raid Element.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_raid_element(unsigned long arg)
++{
++ CSMI_SAS_RAID_ELEMENT_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_RAID_ELEMENT_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_RAID_ELEMENT_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmisas_get_raid_element struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++/* TODO - implement IOCTL here */
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_BAD_CNTL_CODE;
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": not implemented\n"));
++
++// csmisas_get_raid_element_exit:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_RAID_ELEMENT_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmisas_get_raid_element @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Set Raid Operation
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_set_raid_operation(unsigned long arg)
++{
++ CSMI_SAS_RAID_SET_OPERATION_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_RAID_SET_OPERATION_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_RAID_SET_OPERATION_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_set_raid_operation struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++/* TODO - implement IOCTL here */
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_BAD_CNTL_CODE;
++ dcsmisasprintk(ioc, printk(KERN_DEBUG ": not implemented\n"));
++
++// cim_set_raid_operation:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_RAID_SET_OPERATION_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_set_raid_operation @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++
++}
++
++
++/**
++ * Prototype Routine for the CSMI SAS Task Managment Config command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_task_managment(unsigned long arg)
++{
++ CSMI_SAS_SSP_TASK_IU_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_SSP_TASK_IU_BUFFER karg;
++ pSCSITaskMgmt_t pScsiTm;
++ pSCSITaskMgmtReply_t pScsiTmReply;
++ MPT_ADAPTER *ioc = NULL;
++ MPT_SCSI_HOST *hd;
++ MPT_FRAME_HDR *mf = NULL;
++ MPIHeader_t *mpi_hdr;
++ int iocnum;
++ u8 taskType;
++ u8 channel;
++ u8 id;
++ u8 queueTag;
++ u32 TaskMsgContext = 0;
++ int i;
++ u8 found_qtag;
++ struct sas_device_info *sas_info;
++ u16 ioc_status;
++ u32 MsgContext;
++
++ if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_SSP_TASK_IU_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_task_managment struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
++
++ sas_info = csmisas_get_device_component_by_os(ioc,
++ karg.Parameters.bPathId, karg.Parameters.bTargetId);
++ if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume)
++ goto cim_get_task_managment_exit;
++
++ channel = sas_info->fw.channel;
++ id = sas_info->fw.id;
++ queueTag = (u8)karg.Parameters.uQueueTag & 0xFF;
++ hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
++
++ /* try to catch an error
++ */
++ if ((karg.Parameters.uFlags & CSMI_SAS_TASK_IU) &&
++ (karg.Parameters.uFlags & CSMI_SAS_HARD_RESET_SEQUENCE))
++ goto cim_get_task_managment_exit;
++
++ if (karg.Parameters.uFlags & CSMI_SAS_TASK_IU) {
++ switch (karg.Parameters.bTaskManagementFunction) {
++
++ case CSMI_SAS_SSP_ABORT_TASK:
++ taskType = MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK;
++ break;
++ case CSMI_SAS_SSP_ABORT_TASK_SET:
++ taskType = MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET;
++ break;
++ case CSMI_SAS_SSP_CLEAR_TASK_SET:
++ taskType = MPI_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET;
++ break;
++ case CSMI_SAS_SSP_LOGICAL_UNIT_RESET:
++ taskType = MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET;
++ break;
++ case CSMI_SAS_SSP_CLEAR_ACA:
++ case CSMI_SAS_SSP_QUERY_TASK:
++ default:
++ goto cim_get_task_managment_exit;
++ }
++ } else if (karg.Parameters.uFlags & CSMI_SAS_HARD_RESET_SEQUENCE)
++ taskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
++ else
++ goto cim_get_task_managment_exit;
++
++ switch (karg.Parameters.uInformation) {
++ case CSMI_SAS_SSP_TEST:
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request for test purposes\n"));
++ break;
++ case CSMI_SAS_SSP_EXCEEDED:
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request due to timeout\n"));
++ break;
++ case CSMI_SAS_SSP_DEMAND:
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request demanded by app\n"));
++ break;
++ case CSMI_SAS_SSP_TRIGGER:
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request sent to trigger event\n"));
++ break;
++ }
++
++ switch (taskType) {
++
++ case MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
++ /*
++ * look up qtag in the ScsiLookup[] table
++ */
++ for (i = 0, found_qtag = 0; i < hd->ioc->req_depth; i++) {
++ if ((ioc->ScsiLookup[i]) &&
++ (ioc->ScsiLookup[i]->tag == queueTag)) {
++ mf = MPT_INDEX_2_MFPTR(hd->ioc, i);
++ TaskMsgContext =
++ mf->u.frame.hwhdr.msgctxu.MsgContext;
++ found_qtag=1;
++ break;
++ }
++ }
++
++ if(!found_qtag)
++ goto cim_get_task_managment_exit;
++
++ case MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
++ case MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
++ case MPI_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET:
++ /* for now, this should work
++ */
++ case MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
++
++ /* Single threading ....
++ */
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
++ mutex_lock(&ioc->taskmgmt_cmds.mutex);
++ if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ karg.IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_FAILED;
++ goto cim_get_task_managment_exit;
++ }
++#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
++ if (mptctl_set_tm_flags(hd) != 0) {
++ karg.IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_FAILED;
++ goto cim_get_task_managment_exit;
++ }
++#endif
++ /* Send request
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
++ mptctl_free_tm_flags(ioc);
++#endif
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_task_managment_exit;
++ }
++
++ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
++ pScsiTm = (pSCSITaskMgmt_t ) mf;
++
++ memset(pScsiTm,0,sizeof(SCSITaskMgmt_t));
++ pScsiTm->TaskType = taskType;
++ pScsiTm->Bus = channel;
++ pScsiTm->TargetID = id;
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
++ int_to_scsilun(karg.Parameters.bLun,
++ (struct scsi_lun *)pScsiTm->LUN);
++#else
++ pScsiTm->LUN[1] = karg.Parameters.bLun;
++#endif
++ pScsiTm->MsgContext = MsgContext;
++ pScsiTm->TaskMsgContext = TaskMsgContext;
++ pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
++
++ if (csmisas_send_handshake_wait(ioc, mf,
++ karg.IoctlHeader.Timeout) != 0) {
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++#endif
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_get_task_managment_exit;
++ }
++
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
++
++ pScsiTmReply =
++ (pSCSITaskMgmtReply_t ) ioc->ioctl_cmds.reply;
++
++ ioc_status = le16_to_cpu(pScsiTmReply->IOCStatus)
++ & MPI_IOCSTATUS_MASK;
++
++ memset(&karg.Status,0,
++ sizeof(CSMI_SAS_SSP_PASSTHRU_STATUS));
++
++ if(ioc_status == MPI_IOCSTATUS_SUCCESS) {
++ karg.IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_SUCCESS;
++ karg.Status.bSSPStatus =
++ CSMI_SAS_SSP_STATUS_COMPLETED;
++ }else if(ioc_status == MPI_IOCSTATUS_INSUFFICIENT_RESOURCES) {
++ karg.IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_SUCCESS;
++ karg.Status.bSSPStatus =
++ CSMI_SAS_SSP_STATUS_RETRY;
++ }else {
++ karg.IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_FAILED;
++ karg.Status.bSSPStatus =
++ CSMI_SAS_SSP_STATUS_FATAL_ERROR;
++ }
++ } else
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++
++ break;
++
++ default:
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
++ break;
++ }
++
++#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++#endif
++
++ cim_get_task_managment_exit:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_SSP_TASK_IU_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_task_managment @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * map_sas_status_to_csmi - Conversion for Connection Status
++ * @mpi_sas_status: Sas status returned by the firmware
++ *
++ * Returns converted connection status
++ *
++ **/
++static u8
++map_sas_status_to_csmi(u8 mpi_sas_status)
++{
++ u8 csmi_connect_status;
++
++ switch (mpi_sas_status) {
++
++ case MPI_SASSTATUS_SUCCESS:
++ csmi_connect_status = CSMI_SAS_OPEN_ACCEPT;
++ break;
++
++ case MPI_SASSTATUS_UTC_BAD_DEST:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_BAD_DESTINATION;
++ break;
++
++ case MPI_SASSTATUS_UTC_CONNECT_RATE_NOT_SUPPORTED:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_RATE_NOT_SUPPORTED;
++ break;
++
++ case MPI_SASSTATUS_UTC_PROTOCOL_NOT_SUPPORTED:
++ csmi_connect_status =
++ CSMI_SAS_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED;
++ break;
++
++ case MPI_SASSTATUS_UTC_STP_RESOURCES_BUSY:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_STP_RESOURCES_BUSY;
++ break;
++
++ case MPI_SASSTATUS_UTC_WRONG_DESTINATION:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_WRONG_DESTINATION;
++ break;
++
++ case MPI_SASSTATUS_SDSF_NAK_RECEIVED:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_RETRY;
++ break;
++
++ case MPI_SASSTATUS_SDSF_CONNECTION_FAILED:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_PATHWAY_BLOCKED;
++ break;
++
++ case MPI_SASSTATUS_INITIATOR_RESPONSE_TIMEOUT:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_NO_DESTINATION;
++ break;
++
++ case MPI_SASSTATUS_UNKNOWN_ERROR:
++ case MPI_SASSTATUS_INVALID_FRAME:
++ case MPI_SASSTATUS_UTC_BREAK_RECEIVED:
++ case MPI_SASSTATUS_UTC_PORT_LAYER_REQUEST:
++ case MPI_SASSTATUS_SHORT_INFORMATION_UNIT:
++ case MPI_SASSTATUS_LONG_INFORMATION_UNIT:
++ case MPI_SASSTATUS_XFER_RDY_INCORRECT_WRITE_DATA:
++ case MPI_SASSTATUS_XFER_RDY_REQUEST_OFFSET_ERROR:
++ case MPI_SASSTATUS_XFER_RDY_NOT_EXPECTED:
++ case MPI_SASSTATUS_DATA_INCORRECT_DATA_LENGTH:
++ case MPI_SASSTATUS_DATA_TOO_MUCH_READ_DATA:
++ case MPI_SASSTATUS_DATA_OFFSET_ERROR:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_RESERVE_STOP;
++ break;
++
++ default:
++ csmi_connect_status = CSMI_SAS_OPEN_REJECT_RESERVE_STOP;
++ break;
++ }
++
++ return csmi_connect_status;
++}
++
++/**
++ * csmisas_phy_reset
++ * Issues a phy link reset or phy hard reset
++ *
++ * @ioc - Pointer to MPT_ADAPTER structure
++ * @PhyNum - phy number
++ * @opcode - {MPI_SAS_OP_PHY_LINK_RESET,MPI_SAS_OP_PHY_HARD_RESET}
++ *
++ * Returns: 0 for success, non-zero error
++ **/
++static int
++csmisas_phy_reset(MPT_ADAPTER *ioc, u8 PhyNum, u8 opcode)
++{
++ SasIoUnitControlRequest_t *sasIoUnitCntrReq;
++ SasIoUnitControlReply_t *sasIoUnitCntrReply;
++ MPT_FRAME_HDR *mf = NULL;
++ MPIHeader_t *mpi_hdr;
++ u16 ioc_status;
++ u32 MsgContext;
++
++ if ((opcode != MPI_SAS_OP_PHY_LINK_RESET) &&
++ (opcode != MPI_SAS_OP_PHY_HARD_RESET))
++ return -1;
++
++ /* Get a MF for this command.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
++ return -1;
++ }
++
++ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
++ sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
++ memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
++ sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
++ sasIoUnitCntrReq->MsgContext = MsgContext;
++ sasIoUnitCntrReq->Operation = opcode;
++ sasIoUnitCntrReq->PhyNum = PhyNum;
++
++ if (csmisas_send_command_wait(ioc, mf, MPT_IOCTL_DEFAULT_TIMEOUT) != 0)
++ return -1;
++
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0)
++ return -1;
++
++ /* process the completed Reply Message Frame */
++ sasIoUnitCntrReply = (SasIoUnitControlReply_t *)ioc->ioctl_cmds.reply;
++ ioc_status = le16_to_cpu(sasIoUnitCntrReply->IOCStatus)
++ & MPI_IOCSTATUS_MASK;
++ if (ioc_status != MPI_IOCSTATUS_SUCCESS) {
++ printk(KERN_DEBUG "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
++ __FUNCTION__,
++ sasIoUnitCntrReply->IOCStatus,
++ sasIoUnitCntrReply->IOCLogInfo);
++ return -1;
++ }
++ return 0;
++}
++
++/** Prototype Routine for the CSMI SAS Phy Control command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_phy_control(unsigned long arg)
++{
++ CSMI_SAS_PHY_CONTROL_BUFFER __user *uarg = (void __user *) arg;
++ IOCTL_HEADER ioctl_header;
++ PCSMI_SAS_PHY_CONTROL_BUFFER karg;
++ SasIOUnitPage0_t *sasIoUnitPg0=NULL;
++ dma_addr_t sasIoUnitPg0_dma;
++ int sasIoUnitPg0_data_sz=0;
++ SasIOUnitPage1_t *sasIoUnitPg1=NULL;
++ dma_addr_t sasIoUnitPg1_dma;
++ int sasIoUnitPg1_data_sz=0;
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum;
++ int csmi_sas_phy_control_buffer_sz;
++ int memory_pages;
++
++ if (copy_from_user(&ioctl_header, uarg, sizeof(IOCTL_HEADER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in IOCTL_HEADER"
++ "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ csmi_sas_phy_control_buffer_sz = ioctl_header.Length;
++ memory_pages = get_order(csmi_sas_phy_control_buffer_sz);
++ karg = (PCSMI_SAS_PHY_CONTROL_BUFFER)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!karg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc SAS_PHY_CONTROL_BUFFER "
++ "csmi_sas_phy_control_buffer_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ csmi_sas_phy_control_buffer_sz, memory_pages);
++ return -ENOMEM;
++ }
++ memset(karg, 0, sizeof(*karg));
++
++ if (copy_from_user(karg, uarg, csmi_sas_phy_control_buffer_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_phy_control_buffer "
++ "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(ioctl_header.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ if (karg->bPhyIdentifier >= ioc->num_ports) {
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ goto cim_sas_phy_control_exit;
++ }
++
++ /*
++ * Retreive SAS IOUNIT PAGE 0
++ */
++
++ hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 0;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = 0;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: READ MPI_SASIOUNITPAGE0: HEADER\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ sasIoUnitPg0_data_sz = hdr.ExtPageLength * 4;
++ sasIoUnitPg0 = (SasIOUnitPage0_t *) pci_alloc_consistent(ioc->pcidev,
++ sasIoUnitPg0_data_sz, &sasIoUnitPg0_dma);
++
++ if (!sasIoUnitPg0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ memset((u8 *)sasIoUnitPg0, 0, sasIoUnitPg0_data_sz);
++ cfg.physAddr = sasIoUnitPg0_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: READ MPI_SASIOUNITPAGE0: CURRENT\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ /*
++ * Retreive SAS IOUNIT PAGE 1
++ */
++
++ hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 1;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = 0;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: READ MPI_SASIOUNITPAGE1: HEADER\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ sasIoUnitPg1_data_sz = hdr.ExtPageLength * 4;
++ sasIoUnitPg1 = (SasIOUnitPage1_t *) pci_alloc_consistent(ioc->pcidev,
++ sasIoUnitPg1_data_sz, &sasIoUnitPg1_dma);
++
++ if (!sasIoUnitPg1) {
++ dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ memset((u8 *)sasIoUnitPg1, 0, sasIoUnitPg1_data_sz);
++ cfg.physAddr = sasIoUnitPg1_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: READ MPI_SASIOUNITPAGE1: CURRENT\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++
++ switch (karg->uFunction) {
++
++ case CSMI_SAS_PC_LINK_RESET:
++ case CSMI_SAS_PC_HARD_RESET:
++ {
++ u8 opcode = (karg->uFunction==CSMI_SAS_PC_LINK_RESET) ?
++ MPI_SAS_OP_PHY_LINK_RESET : MPI_SAS_OP_PHY_HARD_RESET;
++
++ if((karg->uLinkFlags & CSMI_SAS_PHY_ACTIVATE_CONTROL) &&
++ (karg->usLengthOfControl >= sizeof(CSMI_SAS_PHY_CONTROL)) &&
++ (karg->bNumberOfControls > 0)){
++ if(karg->Control[0].bRate ==
++ CSMI_SAS_LINK_RATE_1_5_GBPS) {
++ sasIoUnitPg1->PhyData[karg->bPhyIdentifier].MaxMinLinkRate =
++ MPI_SAS_IOUNIT1_MAX_RATE_1_5 |
++ MPI_SAS_IOUNIT1_MIN_RATE_1_5;
++ }
++ else if(karg->Control[0].bRate ==
++ CSMI_SAS_LINK_RATE_3_0_GBPS) {
++ sasIoUnitPg1->PhyData[karg->bPhyIdentifier].MaxMinLinkRate =
++ MPI_SAS_IOUNIT1_MAX_RATE_3_0 |
++ MPI_SAS_IOUNIT1_MIN_RATE_3_0;
++ }
++ sasIoUnitPg1->PhyData[karg->bPhyIdentifier].PhyFlags &=
++ ~MPI_SAS_IOUNIT1_PHY_FLAGS_PHY_DISABLE;
++ cfg.dir = 1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: WRITE MPI_SASIOUNITPAGE1 NVRAM\n"));
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++ cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: WRITE MPI_SASIOUNITPAGE1 CURRENT\n"));
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++ }
++ if (csmisas_phy_reset(ioc,
++ karg->bPhyIdentifier, opcode) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: csmisas_phy_reset\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++ break;
++
++ }
++ case CSMI_SAS_PC_PHY_DISABLE:
++ if(karg->usLengthOfControl || karg->bNumberOfControls) {
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ break;
++ }
++ sasIoUnitPg1->PhyData[karg->bPhyIdentifier].PhyFlags |=
++ MPI_SAS_IOUNIT1_PHY_FLAGS_PHY_DISABLE;
++ cfg.dir = 1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: WRITE MPI_SASIOUNITPAGE1 NVRAM\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++ cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
++ if (mpt_config(ioc, &cfg) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: WRITE MPI_SASIOUNITPAGE1 CURRENT\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++ if (csmisas_phy_reset(ioc,
++ karg->bPhyIdentifier, MPI_SAS_OP_PHY_HARD_RESET) != 0) {
++ dcsmisasprintk(ioc, printk(KERN_ERR
++ ": FAILED: csmisas_phy_reset\n"));
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_phy_control_exit;
++ }
++ break;
++
++ case CSMI_SAS_PC_GET_PHY_SETTINGS:
++ if(karg->usLengthOfControl || karg->bNumberOfControls) {
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ break;
++ }
++ if(csmi_sas_phy_control_buffer_sz <
++ offsetof(CSMI_SAS_PHY_CONTROL_BUFFER,Control) +
++ (4* sizeof(CSMI_SAS_PHY_CONTROL))) {
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_INVALID_PARAMETER;
++ break;
++ }
++ karg->usLengthOfControl = sizeof(CSMI_SAS_PHY_CONTROL);
++ karg->bNumberOfControls = 4;
++ karg->Control[0].bType = CSMI_SAS_SAS;
++ karg->Control[0].bRate = CSMI_SAS_LINK_RATE_1_5_GBPS;
++ karg->Control[1].bType = CSMI_SAS_SAS;
++ karg->Control[1].bRate = CSMI_SAS_LINK_RATE_3_0_GBPS;
++ karg->Control[2].bType = CSMI_SAS_SATA;
++ karg->Control[2].bRate = CSMI_SAS_LINK_RATE_1_5_GBPS;
++ karg->Control[3].bType = CSMI_SAS_SATA;
++ karg->Control[3].bRate = CSMI_SAS_LINK_RATE_3_0_GBPS;
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++ break;
++ default:
++ break;
++ }
++
++ cim_sas_phy_control_exit:
++
++ if (sasIoUnitPg0)
++ pci_free_consistent(ioc->pcidev, sasIoUnitPg0_data_sz,
++ (u8 *) sasIoUnitPg0, sasIoUnitPg0_dma);
++
++ if (sasIoUnitPg1)
++ pci_free_consistent(ioc->pcidev, sasIoUnitPg1_data_sz,
++ (u8 *) sasIoUnitPg1, sasIoUnitPg1_dma);
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, karg,csmi_sas_phy_control_buffer_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_phy_control_buffer @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ free_pages((unsigned long)karg, memory_pages);
++ return 0;
++}
++
++/**
++ * csmisas_get_manuf_pg_7 - Fetch Manufacturing config Page7.
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @mfgpage7_buffer: pointer to ManufacturingPage7_t that returns config
++ * page data
++ * @mfg_size - max size of buffer
++ *
++ * Return: 0 for success
++ * -ENOMEM if no memory available
++ * -EPERM if not allowed due to ISR context
++ * -EAGAIN if no msg frames currently available
++ * -EFAULT for non-successful reply or no reply (timeout)
++ **/
++static int
++csmisas_get_manuf_pg_7(MPT_ADAPTER *ioc, ManufacturingPage7_t *mfgpage7_buffer, int mfg_size)
++{
++ ConfigPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ ManufacturingPage7_t *mfgPage7 = NULL;
++ dma_addr_t mfgPage7_dma;
++ int data_sz = 0;
++ int rc;
++
++ /* Get Manufacturing Page 7 header */
++ hdr.PageVersion = MPI_MANUFACTURING0_PAGEVERSION;
++ hdr.PageLength = 0;
++ hdr.PageNumber = 7;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
++ cfg.cfghdr.hdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0;
++ cfg.pageAddr = 0;
++ cfg.timeout = 0;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0)
++ goto csmisas_get_manuf_pg_7_exit;
++
++ if (hdr.PageLength == 0) {
++ rc = -EFAULT;
++ goto csmisas_get_manuf_pg_7_exit;
++ }
++
++ data_sz = hdr.PageLength * 4;
++ mfgPage7 = pci_alloc_consistent(ioc->pcidev, data_sz, &mfgPage7_dma);
++ if (!mfgPage7) {
++ rc = -ENOMEM;
++ goto csmisas_get_manuf_pg_7_exit;
++ }
++
++ memset((u8 *)mfgPage7, 0, data_sz);
++ cfg.physAddr = mfgPage7_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0)
++ goto csmisas_get_manuf_pg_7_exit;
++
++ /* copy buffer back to user */
++ memcpy(mfgpage7_buffer, mfgPage7, min(data_sz, mfg_size));
++
++ csmisas_get_manuf_pg_7_exit:
++
++ if (mfgPage7)
++ pci_free_consistent(ioc->pcidev, data_sz, (u8 *)mfgPage7,
++ mfgPage7_dma);
++
++ return rc;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Get Connector info command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ **/
++static int
++csmisas_get_connector_info(unsigned long arg)
++{
++ CSMI_SAS_CONNECTOR_INFO_BUFFER __user *uarg = (void __user *) arg;
++ CSMI_SAS_CONNECTOR_INFO_BUFFER karg;
++ MPT_ADAPTER *ioc = NULL;
++ ManufacturingPage7_t *mfgPg7 = NULL;
++ int mfgPg7_sz;
++ int iocnum;
++ int i;
++
++ if (copy_from_user(&karg, uarg,
++ sizeof(CSMI_SAS_CONNECTOR_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_connector_info_buffer"
++ " struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++
++ /* `32` is the sizeof MPI_MANPAGE7_CONNECTOR_INFO */
++ for (i = 0; i < 32; i++) {
++ karg.Reference[i].uPinout = CSMI_SAS_CON_UNKNOWN;
++ strcpy(karg.Reference[i].bConnector,"");
++ karg.Reference[i].bLocation = CSMI_SAS_CON_UNKNOWN;
++ }
++
++ mfgPg7_sz = offsetof(CONFIG_PAGE_MANUFACTURING_7,ConnectorInfo) +
++ (ioc->num_ports * sizeof(MPI_MANPAGE7_CONNECTOR_INFO));
++ mfgPg7 = kmalloc(mfgPg7_sz, GFP_KERNEL);
++ if (!mfgPg7){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, mfgPg7);
++ return -EFAULT;
++ }
++ memset(mfgPg7, 0, mfgPg7_sz);
++
++ if (!csmisas_get_manuf_pg_7(ioc, mfgPg7, mfgPg7_sz)) {
++ for (i = 0; i < ioc->num_ports; i++) {
++ karg.Reference[i].uPinout =
++ le32_to_cpu(mfgPg7->ConnectorInfo[i].Pinout);
++ /*endian conversion , this is u8 * 16 ?? */
++ strncpy(karg.Reference[i].bConnector,
++ mfgPg7->ConnectorInfo[i].Connector, 16);
++ karg.Reference[i].bLocation =
++ mfgPg7->ConnectorInfo[i].Location;
++ }
++ }
++
++ kfree(mfgPg7);
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, &karg,
++ sizeof(CSMI_SAS_CONNECTOR_INFO_BUFFER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_connector_info_buffer @"
++ "%p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return 0;
++}
++
++/**
++ * csmisas_fill_location_data
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ **/
++static int
++csmisas_fill_location_data(MPT_ADAPTER *ioc, u8 bus, u8 id, u8 opcode,
++ CSMI_SAS_LOCATION_IDENTIFIER * location_ident)
++{
++
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ int rc;
++ SasDevicePage0_t *sasDevicePg0=NULL;
++ SasEnclosurePage0_t *sasEnclosurePg0=NULL;
++ dma_addr_t sasDevicePg0_dma,sasEnclosurePg0_dma;
++ int sasDevicePg0_data_sz=0;
++ int sasEnclosurePg0_data_sz=0;
++ u64 sas_address;
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++ memset (location_ident, 0, sizeof(*location_ident));
++
++ /* SAS Device Page 0 */
++ hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 0;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ rc=-1;
++ goto fill_location_data_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ rc=-1;
++ goto fill_location_data_exit;
++ }
++
++ sasDevicePg0_data_sz = hdr.ExtPageLength * 4;
++ sasDevicePg0 = (SasDevicePage0_t *) pci_alloc_consistent(
++ ioc->pcidev, sasDevicePg0_data_sz, &sasDevicePg0_dma);
++ if (!sasDevicePg0) {
++ rc=-1;
++ goto fill_location_data_exit;
++ }
++
++ memset((u8 *)sasDevicePg0, 0, sasDevicePg0_data_sz);
++ cfg.physAddr = sasDevicePg0_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = (bus << 8) + id
++ + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT);
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ rc=-1;
++ goto fill_location_data_exit;
++ }
++
++ location_ident->bLocationFlags |= CSMI_SAS_LOCATE_SAS_ADDRESS_VALID;
++ memcpy(&sas_address, &sasDevicePg0->SASAddress, sizeof(u64));
++ sas_address = reverse_byte_order64(sas_address);
++ memcpy(location_ident->bSASAddress, &sas_address, sizeof(u64));
++
++ location_ident->bLocationFlags |= CSMI_SAS_LOCATE_SAS_LUN_VALID;
++ memset(location_ident->bSASLun, 0, sizeof(location_ident->bSASLun));
++
++ /* SAS Enclosure Page 0 */
++ hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 0;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ rc=0;
++ goto fill_location_data_exit;
++ }
++
++ if (hdr.ExtPageLength == 0) {
++ rc=0;
++ goto fill_location_data_exit;
++ }
++
++ sasEnclosurePg0_data_sz = hdr.ExtPageLength * 4;
++ sasEnclosurePg0 = (SasEnclosurePage0_t *) pci_alloc_consistent(
++ ioc->pcidev, sasEnclosurePg0_data_sz, &sasEnclosurePg0_dma);
++ if (!sasEnclosurePg0) {
++ rc=0;
++ goto fill_location_data_exit;
++ }
++ cfg.physAddr = sasEnclosurePg0_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = sasDevicePg0->EnclosureHandle
++ + (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << MPI_SAS_ENCLOS_PGAD_FORM_SHIFT);
++
++ if ((rc = mpt_config(ioc, &cfg)) != 0) {
++ rc=0;
++ goto fill_location_data_exit;
++ }
++
++ location_ident->bLocationFlags |= CSMI_SAS_LOCATE_ENCLOSURE_IDENTIFIER_VALID;
++ memcpy(&sas_address, &sasEnclosurePg0->EnclosureLogicalID, sizeof(u64));
++ sas_address = reverse_byte_order64(sas_address);
++ if (sas_address)
++ memcpy(location_ident->bEnclosureIdentifier, &sas_address, sizeof(u64));
++ else
++ strcpy(location_ident->bEnclosureIdentifier,"Internal");
++
++// bBayPrefix - not supported
++
++// TODO - We need to look at sasEnclosurePg0-.Flags , to determine
++// whether SEP BUS/TargetID is valid. Ifs its a SES device, then
++// issue internal inquiry to (bus/id) to gather the Enclosure name.
++// If the device is SMP, then issue SMP_MANUFACTURING to get enclosure name
++// If its direct attached, there is no enclosure name
++ location_ident->bLocationFlags |= CSMI_SAS_LOCATE_ENCLOSURE_NAME_VALID;
++ strcpy(location_ident->bEnclosureName,"Not Supported");
++
++ location_ident->bLocationFlags |= CSMI_SAS_LOCATE_LOCATION_STATE_VALID;
++ location_ident->bLocationState = CSMI_SAS_LOCATE_UNKNOWN;
++
++ location_ident->bLocationFlags |= CSMI_SAS_LOCATE_BAY_IDENTIFIER_VALID;
++ location_ident->bBayIdentifier = le16_to_cpu(sasDevicePg0->Slot);
++
++
++// TODO - illuminating LEDs,
++// karg->bIdentify = CSMI_SAS_LOCATE_FORCE_OFF, CSMI_SAS_LOCATE_FORCE_ON
++// We can enable/disable LEDs by SCSI Enclosure Processor MPI request message
++// printk("Flags=0x%x\n",sasEnclosurePg0->Flags);
++
++/* check sasEnclosurePg0->Flags -
++ * to validate whether we need to send the SEPRequest
++ * bit:5 should be set
++ * bit:3-0 any bit should be set. If zero, then SEPRequest will fail
++*/
++
++/* MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR
++ * Look in mpi_init.h
++ * SEPRequest_t = structure
++ *
++ * SEPRequest_t->Action should be set to MPI_SEP_REQ_ACTION_WRITE_STATUS
++ *
++ * SEPRequest_t->Flags should be set to
++ * MPI_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS, to pass along enclosure/slot ids
++ *
++ * SEPRequest_t->SlotStatus |= MPI_SEP_REQ_SLOTSTATUS_IDENTIFY_REQUEST - this
++ * will illuminate the LEDs
++ */
++
++fill_location_data_exit:
++
++ if (sasDevicePg0 != NULL)
++ pci_free_consistent(ioc->pcidev, sasDevicePg0_data_sz,
++ sasDevicePg0, sasDevicePg0_dma);
++
++ if (sasEnclosurePg0 != NULL)
++ pci_free_consistent(ioc->pcidev, sasEnclosurePg0_data_sz,
++ sasEnclosurePg0, sasEnclosurePg0_dma);
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ return rc;
++}
++
++static int
++csmisas_fill_location_data_raid(MPT_ADAPTER *ioc, PCSMI_SAS_GET_LOCATION_BUFFER karg, u8 VolumeBus,
++ u8 volumeID)
++{
++ pRaidVolumePage0_t pVolume0 = NULL;
++ pRaidPhysDiskPage0_t pPhysDisk0 = NULL;
++ CONFIGPARMS cfg;
++ ConfigPageHeader_t header;
++ u8 physDiskNumMax;
++ int volumepage0sz = 0, physdiskpage0sz = 0;
++ dma_addr_t volume0_dma, physdisk0_dma;
++ int csmi_sas_get_location_sz;
++ int rc = 0, i, idx;
++ int num_hotpares;
++ u64 totalMaxLBA, tmpTotalMaxLBA;
++ IOCPage5_t *iocPage5 = NULL;
++ u32 device_info = 0;
++ struct sas_device_info *sas_info;
++
++ int sz;
++
++ csmi_sas_get_location_sz = karg->IoctlHeader.Length;
++ physDiskNumMax = (csmi_sas_get_location_sz -
++ offsetof(CSMI_SAS_GET_LOCATION_BUFFER,Location))
++ / sizeof(CSMI_SAS_LOCATION_IDENTIFIER);
++ karg->bNumberOfLocationIdentifiers=0;
++
++ /*
++ * get RAID Volume Page 0
++ */
++
++ header.PageVersion = 0;
++ header.PageLength = 0;
++ header.PageNumber = 0;
++ header.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
++ cfg.cfghdr.hdr = &header;
++ cfg.physAddr = -1;
++ cfg.pageAddr = (VolumeBus << 8) + volumeID;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0;
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++ if (mpt_config(ioc, &cfg) != 0) {
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++
++ if (header.PageLength == 0) {
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++
++ volumepage0sz = header.PageLength * 4;
++ pVolume0 = pci_alloc_consistent(ioc->pcidev, volumepage0sz,
++ &volume0_dma);
++ if (!pVolume0) {
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.physAddr = volume0_dma;
++ if (mpt_config(ioc, &cfg) != 0){
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++
++ totalMaxLBA = (u64)le32_to_cpu(pVolume0->MaxLBA) |
++ ((u64)le32_to_cpu(pVolume0->MaxLBAHigh)) << 32;
++
++ /*
++ * get RAID Physical Disk Page 0
++ */
++ header.PageVersion = 0;
++ header.PageLength = 0;
++ header.PageNumber = 0;
++ header.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
++ cfg.cfghdr.hdr = &header;
++ cfg.physAddr = -1;
++ cfg.pageAddr = 0;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0;
++ cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
++ if (mpt_config(ioc, &cfg) != 0) {
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++
++ if (header.PageLength == 0) {
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++
++ physdiskpage0sz = header.PageLength * 4;
++ pPhysDisk0 = pci_alloc_consistent(ioc->pcidev, physdiskpage0sz,
++ &physdisk0_dma);
++ if (!pPhysDisk0) {
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++ cfg.physAddr = physdisk0_dma;
++
++ for (i=0; i < min(pVolume0->NumPhysDisks, physDiskNumMax); i++) {
++
++ /* obtain a refresh of pPhysDisk0 */
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = pVolume0->PhysDisk[i].PhysDiskNum;
++ if (mpt_config(ioc, &cfg) != 0){
++ rc = -1;
++ goto sas_fill_location_data_raid_exit;
++ }
++
++ if((csmisas_fill_location_data(ioc, pPhysDisk0->PhysDiskBus,
++ pPhysDisk0->PhysDiskID, karg->bIdentify,
++ &karg->Location[karg->bNumberOfLocationIdentifiers])) == 0)
++ karg->bNumberOfLocationIdentifiers++;
++
++ if (device_info)
++ continue;
++ sas_info = csmisas_get_device_component_by_fw(ioc,
++ pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID);
++ if (!sas_info || sas_info->is_cached)
++ continue;
++ device_info = sas_info->device_info;
++ }
++
++ if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IS)
++ goto sas_fill_location_data_raid_exit;
++
++ /*
++ * hot spare support
++ *
++ */
++
++ num_hotpares = csmisas_get_number_hotspares(ioc);
++
++ if (num_hotpares) {
++
++ sz = offsetof(IOCPage5_t, HotSpare) +
++ num_hotpares * sizeof(IOC_5_HOT_SPARE);
++ iocPage5 = kmalloc(sz, GFP_KERNEL);
++
++ if (!iocPage5)
++ goto sas_fill_location_data_raid_exit;
++ memset(iocPage5, 0, sizeof(*iocPage5));
++
++ if (csmisas_get_ioc_pg5(ioc, iocPage5, sz) != 0)
++ goto sas_fill_location_data_raid_exit;
++
++ for(i = 0, idx = pVolume0->NumPhysDisks ; i < num_hotpares;
++ i++, idx++) {
++
++ if (idx >= physDiskNumMax)
++ break;
++
++ /* obtain a refresh of pPhysDisk0 */
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = iocPage5->HotSpare[i].PhysDiskNum;
++ if (mpt_config(ioc, &cfg) != 0)
++ goto sas_fill_location_data_raid_exit;
++
++ /* Search the list for the matching SAS address. */
++ sas_info = csmisas_get_device_component_by_fw(ioc,
++ pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID);
++
++ if (!sas_info || sas_info->is_cached)
++ continue;
++
++ /* don't mix SSP hot spare
++ * in SATA volume
++ */
++ if (!csmisas_is_sata(pPhysDisk0) &&
++ (device_info &
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE))
++ continue;
++
++ /* don't mix SATA hot spare
++ * in SSP volume
++ */
++ if (csmisas_is_sata(pPhysDisk0) &&
++ (device_info &
++ MPI_SAS_DEVICE_INFO_SSP_TARGET))
++ continue;
++
++ /* capacity check for IM volumes*/
++ if ((pVolume0->VolumeType ==
++ MPI_RAID_VOL_TYPE_IM) &&
++ (totalMaxLBA +
++ (64*2*1024) /* metadata = 64MB*/ >
++ le32_to_cpu(pPhysDisk0->MaxLBA)))
++ continue;
++
++ tmpTotalMaxLBA = totalMaxLBA;
++ do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks);
++ /* capacity check for IME volumes*/
++ if ((pVolume0->VolumeType ==
++ MPI_RAID_VOL_TYPE_IME) &&
++ ((tmpTotalMaxLBA * 2) +
++ (64*2*1024 ) /*metadata = 64MB*/ >
++ le32_to_cpu(pPhysDisk0->MaxLBA)))
++ continue;
++
++ if((csmisas_fill_location_data(ioc,
++ pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID,
++ karg->bIdentify,
++ &karg->Location[karg->bNumberOfLocationIdentifiers])) == 0)
++ karg->bNumberOfLocationIdentifiers++;
++ }
++ }
++
++
++ sas_fill_location_data_raid_exit:
++
++ kfree(iocPage5);
++
++ if (pVolume0)
++ pci_free_consistent(ioc->pcidev, volumepage0sz, pVolume0,
++ volume0_dma);
++
++ if(pPhysDisk0)
++ pci_free_consistent(ioc->pcidev, physdiskpage0sz, pPhysDisk0,
++ physdisk0_dma);
++
++ return rc;
++}
++
++/**
++ * Prototype Routine for the CSMI SAS Get location command.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -ENODEV if no such device/adapter
++ */
++static int
++csmisas_get_location(unsigned long arg)
++{
++ CSMI_SAS_GET_LOCATION_BUFFER __user *uarg = (void __user *) arg;
++ PCSMI_SAS_GET_LOCATION_BUFFER karg;
++ IOCTL_HEADER ioctl_header;
++ MPT_ADAPTER *ioc = NULL;
++ int iocnum,i;
++ int csmi_sas_get_location_sz;
++ int memory_pages;
++ struct sas_device_info *sas_info;
++
++ if (copy_from_user(&ioctl_header, uarg, sizeof(IOCTL_HEADER))) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in IOCTL_HEADER"
++ "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ csmi_sas_get_location_sz = ioctl_header.Length;
++ memory_pages = get_order(csmi_sas_get_location_sz);
++ karg = (PCSMI_SAS_GET_LOCATION_BUFFER)__get_free_pages(
++ GFP_KERNEL, memory_pages);
++ if (!karg){
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to malloc GET_LOCATION_BUFFER "
++ "csmi_sas_get_location_sz=%d memory_pages=%d\n",
++ __FILE__, __LINE__, __FUNCTION__,
++ csmi_sas_get_location_sz, memory_pages);
++ return -ENOMEM;
++ }
++ memset(karg, 0, sizeof(*karg));
++
++ if (copy_from_user(karg, uarg, csmi_sas_get_location_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to read in csmi_sas_phy_control_buffer "
++ "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
++ &ioc)) < 0) || (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ if (!csmisas_is_this_sas_cntr(ioc)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ free_pages((unsigned long)karg, memory_pages);
++ return -ENODEV;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
++
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
++ if(karg->bLengthOfLocationIdentifier !=
++ sizeof(CSMI_SAS_LOCATION_IDENTIFIER))
++ goto cim_sas_get_location_exit;
++
++ sas_info = csmisas_get_device_component_by_os(ioc, karg->bPathId,
++ karg->bTargetId);
++ if (!sas_info)
++ goto cim_sas_get_location_exit;
++
++ /* RAID SUPPORT */
++ if (ioc->raid_data.pIocPg2 && sas_info->is_logical_volume) {
++ for (i=0; i<ioc->raid_data.pIocPg2->NumActiveVolumes; i++){
++ if (sas_info->fw.id ==
++ ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID &&
++ sas_info->fw.channel ==
++ ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus) {
++ if(csmisas_fill_location_data_raid(ioc, karg,
++ ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus,
++ ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID) == 0)
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_SUCCESS;
++ else
++ karg->IoctlHeader.ReturnCode =
++ CSMI_SAS_STATUS_FAILED;
++ goto cim_sas_get_location_exit;
++ }
++ }
++ }
++
++ /* NON-RAID SUPPORT */
++ if (sas_info->is_cached || sas_info->is_logical_volume)
++ goto cim_sas_get_location_exit;
++
++ /* make sure there's enough room to populate the Location[] struct */
++ if ((csmi_sas_get_location_sz -
++ offsetof(CSMI_SAS_GET_LOCATION_BUFFER,Location)) <
++ sizeof(CSMI_SAS_LOCATION_IDENTIFIER))
++ goto cim_sas_get_location_exit;
++
++ karg->bNumberOfLocationIdentifiers=1;
++ karg->Location[0].bLocationFlags=0;
++ if((csmisas_fill_location_data(ioc, sas_info->fw.channel,
++ sas_info->fw.id, karg->bIdentify, &karg->Location[0])) == 0)
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
++ else
++ karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
++
++ cim_sas_get_location_exit:
++
++ /* Copy the data from kernel memory to user memory
++ */
++ if (copy_to_user(uarg, karg, csmi_sas_get_location_sz)) {
++ printk(KERN_ERR "%s@%d::%s() - "
++ "Unable to write out csmi_sas_get_location_buffer "
++ "@ %p\n",__FILE__, __LINE__, __FUNCTION__, uarg);
++ free_pages((unsigned long)karg, memory_pages);
++ return -EFAULT;
++ }
++
++ dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
++ free_pages((unsigned long)karg, memory_pages);
++ return 0;
++}
+--- /dev/null
++++ b/drivers/message/fusion/csmi/csmisas.h
+@@ -0,0 +1,1854 @@
++/**************************************************************************
++
++Module Name:
++
++ CSMISAS.H
++
++
++Abstract:
++
++ This file contains constants and data structure definitions used by drivers
++ that support the Common Storage Management Interface specification for
++ SAS or SATA in either the Windows or Linux.
++
++ This should be considered as a reference implementation only. Changes may
++ be necessary to accommodate a specific build environment or target OS.
++
++Revision History:
++
++ 001 SEF 8/12/03 Initial release.
++ 002 SEF 8/20/03 Cleanup to match documentation.
++ 003 SEF 9/12/03 Additional cleanup, created combined header
++ 004 SEF 9/23/03 Changed base types to match linux defaults
++ Added RAID signature
++ Added bControllerFlags to CSMI_SAS_CNTLR_CONFIG
++ Changed CSMI_SAS_BEGIN_PACK to 8 for common structures
++ Fixed other typos identified in first compilation test
++ 005 SEF 10/03/03 Additions to match first version of CSMI document
++ 006 SEF 10/14/03 Fixed typedef struct _CSMI_SAS_SMP_PASSTHRU_BUFFER
++ Added defines for bConnectionRate
++ 007 SEF 10/15/03 Added Firmware Download Control Code and support
++ Added CSMI revision support
++ 008 SEF 10/30/03 No functional change, just updated version to track
++ spec changes
++ 009 SEF 12/09/03 No functional change, just updated version to track
++ spec changes
++ 010 SEF 3/11/04 Fixed typedef struct CSMI_SAS_RAID_DRIVES to include the
++ bFirmware member that is defined in the spec, but
++ was missing in this file,
++ added CC_CSMI_SAS_TASK_MANAGEMENT
++ 011 SEF 4/02/04 No functional change, added comment line before
++ CC_CSMI_SAS_TASK_MANAGEMENT
++ 012 SEF 4/16/04 Added IOControllerNumber to linux header,
++ Modified linux control codes to have upper word of
++ 0xCC77.... to indicate CSMI version 77
++ Added bSignalClass to CC_CSMI_SET_PHY_INFO
++ Added CC_CSMI_SAS_PHY_CONTROL support
++ 013 SEF 5/14/04 Added CC_CSMI_SAS_GET_CONNECTOR_INFO support
++ 014 SEF 5/24/04 No functional change, just updated version to track spec
++ changes
++ 015 SEF 6/16/04 changed bPinout to uPinout to reflect proper size,
++ changed width of bLocation defines to reflect size
++ 016 SEF 6/17/04 changed bLengthOfControls in CSMI_SAS_PHY_CONTROL
++ to be proper size
++ 017 SEF 9/17/04 added CSMI_SAS_SATA_PORT_SELECTOR,
++ CSMI_SAS_LINK_VIRTUAL, CSMI_SAS_CON_NOT_PRESENT, and
++ CSMI_SAS_CON_NOT_CONNECTED
++ 018 SEF 9/20/04 added CSMI_SAS_PHY_USER_PATTERN,
++ changed definition of CSMI_SAS_PHY_FIXED_PATTERN to not
++ conflict with activate definition
++ 019 SEF 12/06/04 added CSMI_SAS_GET_LOCATION
++ added bSSPStatus to CSMI_SAS_SSP_PASSTHRU_STATUS
++ structure
++ 020 SEF 5/25/05 added CSMI_SAS_PHY_VIRTUAL_SMP, and changes to
++ CSMI_SAS_GET_LOCATION
++ 021 SEF 11/03/05 added new RAID creation functionality
++ 022 SEF 2/01/06 corrected typo bNegotitiatedLInkRate
++ Added two more RAID_TYPES, 7 and 8
++ 023 SEF 4/04/06 added CSMI_RAID_TYPE_1E
++ changed structures that contained surface scan
++ to priority approach rather than time, causes
++ 0.89 to incompatible with 0.87, so a version
++ check is necessary when interpreting the
++ raid structures
++ Added netware section
++ 024 DRG 5/22/06 Added uFailureCode to CSMI_SAS_RAID_CONFIG and
++ CSMI_SAS_RAID_FEATURES
++ Changed __u64 fields to high and low __u32 fields in
++ order to avoid backward compatibility issues with
++ packing and alignment.
++ Fixed alignment problem in CSMI_SAS_RAID_DRIVES.
++ Added CSMI_SAS_CNTLR_SMART_ARRAY to uControllerFlags
++ Reassigned the value of CSMI_SAS_CNTLR_RAID_CFG_SUPPORT
++ to avoid a conflict.
++
++**************************************************************************/
++
++#ifndef _CSMI_SAS_H_
++#define _CSMI_SAS_H_
++
++// CSMI Specification Revision, the intent is that all versions of the
++// specification will be backward compatible after the 1.00 release.
++// Major revision number, corresponds to xxxx. of CSMI specification
++// Minor revision number, corresponds to .xxxx of CSMI specification
++#define CSMI_MAJOR_REVISION 0
++#define CSMI_MINOR_REVISION 90
++
++/*************************************************************************/
++/* PATCHES FOR TYPOS */
++/*************************************************************************/
++
++#define bNegotitiatedLInkRate bNegotiatedLinkRate
++
++/*************************************************************************/
++/* TARGET OS LINUX SPECIFIC CODE */
++/*************************************************************************/
++
++// EDM #ifdef _linux
++#ifdef __KERNEL__
++
++// Linux base types
++
++#include <linux/types.h>
++
++#define __i8 char
++
++// pack definition
++
++// EDM #define CSMI_SAS_BEGIN_PACK(x) pack(x)
++// EDM #define CSMI_SAS_END_PACK pack()
++
++// IOCTL Control Codes
++// (IoctlHeader.ControlCode)
++
++// Control Codes prior to 0.77
++
++// Control Codes requiring CSMI_ALL_SIGNATURE
++
++// #define CC_CSMI_SAS_GET_DRIVER_INFO 0x12345678
++// #define CC_CSMI_SAS_GET_CNTLR_CONFIG 0x23456781
++// #define CC_CSMI_SAS_GET_CNTLR_STATUS 0x34567812
++// #define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 0x92345678
++
++// Control Codes requiring CSMI_RAID_SIGNATURE
++
++// #define CC_CSMI_SAS_GET_RAID_INFO 0x45678123
++// #define CC_CSMI_SAS_GET_RAID_CONFIG 0x56781234
++
++// Control Codes requiring CSMI_SAS_SIGNATURE
++
++// #define CC_CSMI_SAS_GET_PHY_INFO 0x67812345
++// #define CC_CSMI_SAS_SET_PHY_INFO 0x78123456
++// #define CC_CSMI_SAS_GET_LINK_ERRORS 0x81234567
++// #define CC_CSMI_SAS_SMP_PASSTHRU 0xA1234567
++// #define CC_CSMI_SAS_SSP_PASSTHRU 0xB1234567
++// #define CC_CSMI_SAS_STP_PASSTHRU 0xC1234567
++// #define CC_CSMI_SAS_GET_SATA_SIGNATURE 0xD1234567
++// #define CC_CSMI_SAS_GET_SCSI_ADDRESS 0xE1234567
++// #define CC_CSMI_SAS_GET_DEVICE_ADDRESS 0xF1234567
++// #define CC_CSMI_SAS_TASK_MANAGEMENT 0xA2345678
++
++// Control Codes for 0.77 and later
++
++// Control Codes requiring CSMI_ALL_SIGNATURE
++
++#define CC_CSMI_SAS_GET_DRIVER_INFO 0xCC770001
++#define CC_CSMI_SAS_GET_CNTLR_CONFIG 0xCC770002
++#define CC_CSMI_SAS_GET_CNTLR_STATUS 0xCC770003
++#define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 0xCC770004
++
++// Control Codes requiring CSMI_RAID_SIGNATURE
++
++#define CC_CSMI_SAS_GET_RAID_INFO 0xCC77000A
++#define CC_CSMI_SAS_GET_RAID_CONFIG 0xCC77000B
++#define CC_CSMI_SAS_GET_RAID_FEATURES 0xCC77000C
++#define CC_CSMI_SAS_SET_RAID_CONTROL 0xCC77000D
++#define CC_CSMI_SAS_GET_RAID_ELEMENT 0xCC77000E
++#define CC_CSMI_SAS_SET_RAID_OPERATION 0xCC77000F
++
++// Control Codes requiring CSMI_SAS_SIGNATURE
++
++#define CC_CSMI_SAS_GET_PHY_INFO 0xCC770014
++#define CC_CSMI_SAS_SET_PHY_INFO 0xCC770015
++#define CC_CSMI_SAS_GET_LINK_ERRORS 0xCC770016
++#define CC_CSMI_SAS_SMP_PASSTHRU 0xCC770017
++#define CC_CSMI_SAS_SSP_PASSTHRU 0xCC770018
++#define CC_CSMI_SAS_STP_PASSTHRU 0xCC770019
++#define CC_CSMI_SAS_GET_SATA_SIGNATURE 0xCC770020
++#define CC_CSMI_SAS_GET_SCSI_ADDRESS 0xCC770021
++#define CC_CSMI_SAS_GET_DEVICE_ADDRESS 0xCC770022
++#define CC_CSMI_SAS_TASK_MANAGEMENT 0xCC770023
++#define CC_CSMI_SAS_GET_CONNECTOR_INFO 0xCC770024
++#define CC_CSMI_SAS_GET_LOCATION 0xCC770025
++
++
++// Control Codes requiring CSMI_PHY_SIGNATURE
++
++#define CC_CSMI_SAS_PHY_CONTROL 0xCC77003C
++
++// EDM #pragma CSMI_SAS_BEGIN_PACK(8)
++#pragma pack(8)
++
++// IOCTL_HEADER
++typedef struct _IOCTL_HEADER {
++ __u32 IOControllerNumber;
++ __u32 Length;
++ __u32 ReturnCode;
++ __u32 Timeout;
++ __u16 Direction;
++} IOCTL_HEADER,
++ *PIOCTL_HEADER;
++
++// EDM #pragma CSMI_SAS_END_PACK
++#pragma pack()
++
++#endif
++
++/*************************************************************************/
++/* TARGET OS WINDOWS SPECIFIC CODE */
++/*************************************************************************/
++
++#ifdef _WIN32
++
++// windows IOCTL definitions
++
++#ifndef _NTDDSCSIH_
++#include <ntddscsi.h>
++#endif
++
++// pack definition
++
++#if defined _MSC_VER
++ #define CSMI_SAS_BEGIN_PACK(x) pack(push,x)
++ #define CSMI_SAS_END_PACK pack(pop)
++#elif defined __BORLANDC__
++ #define CSMI_SAS_BEGIN_PACK(x) option -a##x
++ #define CSMI_SAS_END_PACK option -a.
++#else
++ #error "CSMISAS.H - Must externally define a pack compiler designator."
++#endif
++
++// base types
++
++#define __u8 unsigned char
++#define __u16 unsigned short
++#define __u32 unsigned long
++#define __u64 unsigned __int64
++
++#define __i8 char
++
++// IOCTL Control Codes
++// (IoctlHeader.ControlCode)
++
++// Control Codes requiring CSMI_ALL_SIGNATURE
++
++#define CC_CSMI_SAS_GET_DRIVER_INFO 1
++#define CC_CSMI_SAS_GET_CNTLR_CONFIG 2
++#define CC_CSMI_SAS_GET_CNTLR_STATUS 3
++#define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 4
++
++// Control Codes requiring CSMI_RAID_SIGNATURE
++
++#define CC_CSMI_SAS_GET_RAID_INFO 10
++#define CC_CSMI_SAS_GET_RAID_CONFIG 11
++#define CC_CSMI_SAS_GET_RAID_FEATURES 12
++#define CC_CSMI_SAS_SET_RAID_CONTROL 13
++#define CC_CSMI_SAS_GET_RAID_ELEMENT 14
++#define CC_CSMI_SAS_SET_RAID_OPERATION 15
++
++// Control Codes requiring CSMI_SAS_SIGNATURE
++
++#define CC_CSMI_SAS_GET_PHY_INFO 20
++#define CC_CSMI_SAS_SET_PHY_INFO 21
++#define CC_CSMI_SAS_GET_LINK_ERRORS 22
++#define CC_CSMI_SAS_SMP_PASSTHRU 23
++#define CC_CSMI_SAS_SSP_PASSTHRU 24
++#define CC_CSMI_SAS_STP_PASSTHRU 25
++#define CC_CSMI_SAS_GET_SATA_SIGNATURE 26
++#define CC_CSMI_SAS_GET_SCSI_ADDRESS 27
++#define CC_CSMI_SAS_GET_DEVICE_ADDRESS 28
++#define CC_CSMI_SAS_TASK_MANAGEMENT 29
++#define CC_CSMI_SAS_GET_CONNECTOR_INFO 30
++#define CC_CSMI_SAS_GET_LOCATION 31
++
++// Control Codes requiring CSMI_PHY_SIGNATURE
++
++#define CC_CSMI_SAS_PHY_CONTROL 60
++
++#define IOCTL_HEADER SRB_IO_CONTROL
++#define PIOCTL_HEADER PSRB_IO_CONTROL
++
++#endif
++
++/*************************************************************************/
++/* TARGET OS NETWARE SPECIFIC CODE */
++/*************************************************************************/
++
++#ifdef _NETWARE
++
++// NetWare IOCTL definitions
++
++#define CSMI_SAS_BEGIN_PACK(x) pack(x)
++#define CSMI_SAS_END_PACK pack()
++
++#ifndef LONG
++typedef unsigned long LONG;
++#endif
++
++#ifndef WORD
++typedef unsigned short WORD;
++#endif
++
++#ifndef BYTE
++typedef unsigned char BYTE;
++#endif
++
++/* Need to have these definitions for Netware */
++#define __u8 unsigned char
++#define __u16 unsigned short
++#define __u32 unsigned long
++#define __u64 unsigned __int64
++
++#define __i8 char
++
++
++// EDM #pragma CSMI_SAS_BEGIN_PACK(8)
++#pragma pack(8)
++
++// IOCTL_HEADER
++typedef struct _IOCTL_HEADER {
++ __u32 Length;
++ __u32 ReturnCode;
++} IOCTL_HEADER,
++ *PIOCTL_HEADER;
++
++// EDM #pragma CSMI_SAS_END_PACK
++#pragma pack()
++
++// IOCTL Control Codes
++// (IoctlHeader.ControlCode)
++
++// Control Codes requiring CSMI_ALL_SIGNATURE
++
++#define CC_CSMI_SAS_GET_DRIVER_INFO 0x01FF0001
++#define CC_CSMI_SAS_GET_CNTLR_CONFIG 0x01FF0002
++#define CC_CSMI_SAS_GET_CNTLR_STATUS 0x01FF0003
++#define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 0x01FF0004
++
++// Control Codes requiring CSMI_RAID_SIGNATURE
++
++#define CC_CSMI_SAS_GET_RAID_INFO 0x01FF000A
++#define CC_CSMI_SAS_GET_RAID_CONFIG 0x01FF000B
++#define CC_CSMI_SAS_GET_RAID_FEATURES 0x01FF000C
++#define CC_CSMI_SAS_SET_RAID_CONTROL 0x01FF000D
++#define CC_CSMI_SAS_GET_RAID_ELEMENT 0x01FF000E
++#define CC_CSMI_SAS_SET_RAID_OPERATION 0x01FF000F
++
++// Control Codes requiring CSMI_SAS_SIGNATURE
++
++#define CC_CSMI_SAS_GET_PHY_INFO 0x01FF0014
++#define CC_CSMI_SAS_SET_PHY_INFO 0x01FF0015
++#define CC_CSMI_SAS_GET_LINK_ERRORS 0x01FF0016
++#define CC_CSMI_SAS_SMP_PASSTHRU 0x01FF0017
++#define CC_CSMI_SAS_SSP_PASSTHRU 0x01FF0018
++#define CC_CSMI_SAS_STP_PASSTHRU 0x01FF0019
++#define CC_CSMI_SAS_GET_SATA_SIGNATURE 0x01FF001A
++#define CC_CSMI_SAS_GET_SCSI_ADDRESS 0x01FF001B
++#define CC_CSMI_SAS_GET_DEVICE_ADDRESS 0x01FF001C
++#define CC_CSMI_SAS_TASK_MANAGEMENT 0x01FF001D
++#define CC_CSMI_SAS_GET_CONNECTOR_INFO 0x01FF001E
++#define CC_CSMI_SAS_GET_LOCATION 0x01FF001F
++
++// Control Codes requiring CSMI_PHY_SIGNATURE
++
++#define CC_CSMI_SAS_PHY_CONTROL 60
++
++#endif
++
++/*************************************************************************/
++/* TARGET OS NOT DEFINED ERROR */
++/*************************************************************************/
++
++// EDM
++//#if (!_WIN32 && !_linux && !_NETWARE)
++// #error "Unknown target OS."
++//#endif
++
++/*************************************************************************/
++/* OS INDEPENDENT CODE */
++/*************************************************************************/
++
++/* * * * * * * * * * Class Independent IOCTL Constants * * * * * * * * * */
++
++// Return codes for all IOCTL's regardless of class
++// (IoctlHeader.ReturnCode)
++
++#define CSMI_SAS_STATUS_SUCCESS 0
++#define CSMI_SAS_STATUS_FAILED 1
++#define CSMI_SAS_STATUS_BAD_CNTL_CODE 2
++#define CSMI_SAS_STATUS_INVALID_PARAMETER 3
++#define CSMI_SAS_STATUS_WRITE_ATTEMPTED 4
++
++// Signature value
++// (IoctlHeader.Signature)
++
++#define CSMI_ALL_SIGNATURE "CSMIALL"
++
++// Timeout value default of 60 seconds
++// (IoctlHeader.Timeout)
++
++#define CSMI_ALL_TIMEOUT 60
++
++// Direction values for data flow on this IOCTL
++// (IoctlHeader.Direction, Linux only)
++#define CSMI_SAS_DATA_READ 0
++#define CSMI_SAS_DATA_WRITE 1
++
++// I/O Bus Types
++// ISA and EISA bus types are not supported
++// (bIoBusType)
++
++#define CSMI_SAS_BUS_TYPE_PCI 3
++#define CSMI_SAS_BUS_TYPE_PCMCIA 4
++
++// Controller Status
++// (uStatus)
++
++#define CSMI_SAS_CNTLR_STATUS_GOOD 1
++#define CSMI_SAS_CNTLR_STATUS_FAILED 2
++#define CSMI_SAS_CNTLR_STATUS_OFFLINE 3
++#define CSMI_SAS_CNTLR_STATUS_POWEROFF 4
++
++// Offline Status Reason
++// (uOfflineReason)
++
++#define CSMI_SAS_OFFLINE_REASON_NO_REASON 0
++#define CSMI_SAS_OFFLINE_REASON_INITIALIZING 1
++#define CSMI_SAS_OFFLINE_REASON_BACKSIDE_BUS_DEGRADED 2
++#define CSMI_SAS_OFFLINE_REASON_BACKSIDE_BUS_FAILURE 3
++
++// Controller Class
++// (bControllerClass)
++
++#define CSMI_SAS_CNTLR_CLASS_HBA 5
++
++// Controller Flag bits
++// (uControllerFlags)
++
++#define CSMI_SAS_CNTLR_SAS_HBA 0x00000001
++#define CSMI_SAS_CNTLR_SAS_RAID 0x00000002
++#define CSMI_SAS_CNTLR_SATA_HBA 0x00000004
++#define CSMI_SAS_CNTLR_SATA_RAID 0x00000008
++#define CSMI_SAS_CNTLR_SMART_ARRAY 0x00000010
++
++// for firmware download
++#define CSMI_SAS_CNTLR_FWD_SUPPORT 0x00010000
++#define CSMI_SAS_CNTLR_FWD_ONLINE 0x00020000
++#define CSMI_SAS_CNTLR_FWD_SRESET 0x00040000
++#define CSMI_SAS_CNTLR_FWD_HRESET 0x00080000
++#define CSMI_SAS_CNTLR_FWD_RROM 0x00100000
++
++// for RAID configuration supported
++#define CSMI_SAS_CNTLR_RAID_CFG_SUPPORT 0x01000000
++
++// Download Flag bits
++// (uDownloadFlags)
++#define CSMI_SAS_FWD_VALIDATE 0x00000001
++#define CSMI_SAS_FWD_SOFT_RESET 0x00000002
++#define CSMI_SAS_FWD_HARD_RESET 0x00000004
++
++// Firmware Download Status
++// (usStatus)
++#define CSMI_SAS_FWD_SUCCESS 0
++#define CSMI_SAS_FWD_FAILED 1
++#define CSMI_SAS_FWD_USING_RROM 2
++#define CSMI_SAS_FWD_REJECT 3
++#define CSMI_SAS_FWD_DOWNREV 4
++
++// Firmware Download Severity
++// (usSeverity>
++#define CSMI_SAS_FWD_INFORMATION 0
++#define CSMI_SAS_FWD_WARNING 1
++#define CSMI_SAS_FWD_ERROR 2
++#define CSMI_SAS_FWD_FATAL 3
++
++/* * * * * * * * * * SAS RAID Class IOCTL Constants * * * * * * * * */
++
++// Return codes for the RAID IOCTL's regardless of class
++// (IoctlHeader.ReturnCode)
++
++#define CSMI_SAS_RAID_SET_OUT_OF_RANGE 1000
++#define CSMI_SAS_RAID_SET_BUFFER_TOO_SMALL 1001
++#define CSMI_SAS_RAID_SET_DATA_CHANGED 1002
++
++// Signature value
++// (IoctlHeader.Signature)
++
++#define CSMI_RAID_SIGNATURE "CSMIARY"
++
++// Timeout value default of 60 seconds
++// (IoctlHeader.Timeout)
++
++#define CSMI_RAID_TIMEOUT 60
++
++// RAID Types
++// (bRaidType)
++#define CSMI_SAS_RAID_TYPE_NONE 0
++#define CSMI_SAS_RAID_TYPE_0 1
++#define CSMI_SAS_RAID_TYPE_1 2
++#define CSMI_SAS_RAID_TYPE_10 3
++#define CSMI_SAS_RAID_TYPE_5 4
++#define CSMI_SAS_RAID_TYPE_15 5
++#define CSMI_SAS_RAID_TYPE_6 6
++#define CSMI_SAS_RAID_TYPE_50 7
++#define CSMI_SAS_RAID_TYPE_VOLUME 8
++#define CSMI_SAS_RAID_TYPE_1E 9
++#define CSMI_SAS_RAID_TYPE_OTHER 255
++// the last value 255 was already defined for other
++// so end is defined as 254
++#define CSMI_SAS_RAID_TYPE_END 254
++
++// RAID Status
++// (bStatus)
++#define CSMI_SAS_RAID_SET_STATUS_OK 0
++#define CSMI_SAS_RAID_SET_STATUS_DEGRADED 1
++#define CSMI_SAS_RAID_SET_STATUS_REBUILDING 2
++#define CSMI_SAS_RAID_SET_STATUS_FAILED 3
++#define CSMI_SAS_RAID_SET_STATUS_OFFLINE 4
++#define CSMI_SAS_RAID_SET_STATUS_TRANSFORMING 5
++#define CSMI_SAS_RAID_SET_STATUS_QUEUED_FOR_REBUILD 6
++#define CSMI_SAS_RAID_SET_STATUS_QUEUED_FOR_TRANSFORMATION 7
++
++// RAID Drive Count
++// (bDriveCount, 0xF1 to 0xFF are reserved)
++#define CSMI_SAS_RAID_DRIVE_COUNT_TOO_BIG 0xF1
++#define CSMI_SAS_RAID_DRIVE_COUNT_SUPRESSED 0xF2
++
++// RAID Data Type
++// (bDataType)
++#define CSMI_SAS_RAID_DATA_DRIVES 0
++#define CSMI_SAS_RAID_DATA_DEVICE_ID 1
++#define CSMI_SAS_RAID_DATA_ADDITIONAL_DATA 2
++
++// RAID Drive Status
++// (bDriveStatus)
++#define CSMI_SAS_DRIVE_STATUS_OK 0
++#define CSMI_SAS_DRIVE_STATUS_REBUILDING 1
++#define CSMI_SAS_DRIVE_STATUS_FAILED 2
++#define CSMI_SAS_DRIVE_STATUS_DEGRADED 3
++#define CSMI_SAS_DRIVE_STATUS_OFFLINE 4
++#define CSMI_SAS_DRIVE_STATUS_QUEUED_FOR_REBUILD 5
++
++// RAID Drive Usage
++// (bDriveUsage)
++#define CSMI_SAS_DRIVE_CONFIG_NOT_USED 0
++#define CSMI_SAS_DRIVE_CONFIG_MEMBER 1
++#define CSMI_SAS_DRIVE_CONFIG_SPARE 2
++#define CSMI_SAS_DRIVE_CONFIG_SPARE_ACTIVE 3
++
++// RAID Drive Type
++// (bDriveType)
++#define CSMI_SAS_DRIVE_TYPE_UNKNOWN 0
++#define CSMI_SAS_DRIVE_TYPE_SINGLE_PORT_SAS 1
++#define CSMI_SAS_DRIVE_TYPE_DUAL_PORT_SAS 2
++#define CSMI_SAS_DRIVE_TYPE_SATA 3
++#define CSMI_SAS_DRIVE_TYPE_SATA_PS 4
++#define CSMI_SAS_DRIVE_TYPE_OTHER 255
++
++// RAID Write Protect
++// (bWriteProtect)
++#define CSMI_SAS_RAID_SET_WRITE_PROTECT_UNKNOWN 0
++#define CSMI_SAS_RAID_SET_WRITE_PROTECT_UNCHANGED 0
++#define CSMI_SAS_RAID_SET_WRITE_PROTECT_ENABLED 1
++#define CSMI_SAS_RAID_SET_WRITE_PROTECT_DISABLED 2
++
++// RAID Cache Setting
++// (bCacheSetting)
++#define CSMI_SAS_RAID_SET_CACHE_UNKNOWN 0
++#define CSMI_SAS_RAID_SET_CACHE_UNCHANGED 0
++#define CSMI_SAS_RAID_SET_CACHE_ENABLED 1
++#define CSMI_SAS_RAID_SET_CACHE_DISABLED 2
++#define CSMI_SAS_RAID_SET_CACHE_CORRUPT 3
++
++// RAID Features
++// (uFeatures)
++#define CSMI_SAS_RAID_FEATURE_TRANSFORMATION 0x00000001
++#define CSMI_SAS_RAID_FEATURE_REBUILD 0x00000002
++#define CSMI_SAS_RAID_FEATURE_SPLIT_MIRROR 0x00000004
++#define CSMI_SAS_RAID_FEATURE_MERGE_MIRROR 0x00000008
++#define CSMI_SAS_RAID_FEATURE_LUN_RENUMBER 0x00000010
++#define CSMI_SAS_RAID_FEATURE_SURFACE_SCAN 0x00000020
++#define CSMI_SAS_RAID_FEATURE_SPARES_SHARED 0x00000040
++
++// RAID Priority
++// (bDefaultTransformPriority, etc.)
++#define CSMI_SAS_PRIORITY_UNKNOWN 0
++#define CSMI_SAS_PRIORITY_UNCHANGED 0
++#define CSMI_SAS_PRIORITY_AUTO 1
++#define CSMI_SAS_PRIORITY_OFF 2
++#define CSMI_SAS_PRIORITY_LOW 3
++#define CSMI_SAS_PRIORITY_MEDIUM 4
++#define CSMI_SAS_PRIORITY_HIGH 5
++
++// RAID Transformation Rules
++// (uRaidSetTransformationRules)
++#define CSMI_SAS_RAID_RULE_AVAILABLE_MEMORY 0x00000001
++#define CSMI_SAS_RAID_RULE_OVERLAPPED_EXTENTS 0x00000002
++
++// RAID Cache Ratios Supported
++// (bCacheRatiosSupported)
++// from 0 to 100 defines the write to read ratio, 0 is 100% write
++#define CSMI_SAS_RAID_CACHE_RATIO_RANGE 101
++#define CSMI_SAS_RAID_CACHE_RATIO_FIXED 102
++#define CSMI_SAS_RAID_CACHE_RATIO_AUTO 103
++#define CSMI_SAS_RAID_CACHE_RATIO_END 255
++
++// RAID Cache Ratio Flag
++// (bCacheRatioFlag)
++#define CSMI_SAS_RAID_CACHE_RATIO_DISABLE 0
++#define CSMI_SAS_RAID_CACHE_RATIO_ENABLE 1
++
++// RAID Clear Configuration Signature
++// (bClearConfiguration)
++#define CSMI_SAS_RAID_CLEAR_CONFIGURATION_SIGNATURE "RAIDCLR"
++
++// RAID Failure Codes
++// (uFailureCode)
++#define CSMI_SAS_FAIL_CODE_OK 0
++#define CSMI_SAS_FAIL_CODE_PARAMETER_INVALID 1000
++#define CSMI_SAS_FAIL_CODE_TRANSFORM_PRIORITY_INVALID 1001
++#define CSMI_SAS_FAIL_CODE_REBUILD_PRIORITY_INVALID 1002
++#define CSMI_SAS_FAIL_CODE_CACHE_RATIO_INVALID 1003
++#define CSMI_SAS_FAIL_CODE_SURFACE_SCAN_INVALID 1004
++#define CSMI_SAS_FAIL_CODE_CLEAR_CONFIGURATION_INVALID 1005
++#define CSMI_SAS_FAIL_CODE_ELEMENT_INDEX_INVALID 1006
++#define CSMI_SAS_FAIL_CODE_SUBELEMENT_INDEX_INVALID 1007
++#define CSMI_SAS_FAIL_CODE_EXTENT_INVALID 1008
++#define CSMI_SAS_FAIL_CODE_BLOCK_COUNT_INVALID 1009
++#define CSMI_SAS_FAIL_CODE_DRIVE_INDEX_INVALID 1010
++#define CSMI_SAS_FAIL_CODE_EXISTING_LUN_INVALID 1011
++#define CSMI_SAS_FAIL_CODE_RAID_TYPE_INVALID 1012
++#define CSMI_SAS_FAIL_CODE_STRIPE_SIZE_INVALID 1013
++#define CSMI_SAS_FAIL_CODE_TRANSFORMATION_INVALID 1014
++#define CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID 1015
++#define CSMI_SAS_FAIL_CODE_ENUMERATION_TYPE_INVALID 1016
++
++#define CSMI_SAS_FAIL_CODE_EXCEEDED_RAID_SET_COUNT 2000
++#define CSMI_SAS_FAIL_CODE_DUPLICATE_LUN 2001
++
++#define CSMI_SAS_FAIL_CODE_WAIT_FOR_OPERATION 3000
++
++// RAID Enumeration Types
++// (uEnumerationType)
++#define CSMI_SAS_RAID_ELEMENT_TYPE_DRIVE 0
++#define CSMI_SAS_RAID_ELEMENT_TYPE_MODULE 1
++#define CSMI_SAS_RAID_ELEMENT_TYPE_DRIVE_RAID_SET 2
++#define CSMI_SAS_RAID_ELEMENT_TYPE_EXTENT_DRIVE 3
++
++// RAID Extent Types
++// (bExtentType)
++#define CSMI_SAS_RAID_EXTENT_RESERVED 0
++#define CSMI_SAS_RAID_EXTENT_METADATA 1
++#define CSMI_SAS_RAID_EXTENT_ALLOCATED 2
++#define CSMI_SAS_RAID_EXTENT_UNALLOCATED 3
++
++// RAID Operation Types
++// (uOperationType)
++#define CSMI_SAS_RAID_SET_CREATE 0
++#define CSMI_SAS_RAID_SET_LABEL 1
++#define CSMI_SAS_RAID_SET_TRANSFORM 2
++#define CSMI_SAS_RAID_SET_DELETE 3
++#define CSMI_SAS_RAID_SET_WRITE_PROTECT 4
++#define CSMI_SAS_RAID_SET_CACHE 5
++#define CSMI_SAS_RAID_SET_ONLINE_STATE 6
++#define CSMI_SAS_RAID_SET_SPARE 7
++
++// RAID Transform Types
++// (bTransformType)
++#define CSMI_SAS_RAID_SET_TRANSFORM_SPLIT_MIRROR 0
++#define CSMI_SAS_RAID_SET_TRANSFORM_MERGE_RAID_0 1
++#define CSMI_SAS_RAID_SET_TRANSFORM_LUN_RENUMBER 2
++#define CSMI_SAS_RAID_SET_TRANSFORM_RAID_SET 3
++
++// RAID Online State
++// (bOnlineState)
++#define CSMI_SAS_RAID_SET_STATE_UNKNOWN 0
++#define CSMI_SAS_RAID_SET_STATE_ONLINE 1
++#define CSMI_SAS_RAID_SET_STATE_OFFLINE 2
++
++/* * * * * * * * * * SAS HBA Class IOCTL Constants * * * * * * * * * */
++
++// Return codes for SAS IOCTL's
++// (IoctlHeader.ReturnCode)
++
++#define CSMI_SAS_PHY_INFO_CHANGED CSMI_SAS_STATUS_SUCCESS
++#define CSMI_SAS_PHY_INFO_NOT_CHANGEABLE 2000
++#define CSMI_SAS_LINK_RATE_OUT_OF_RANGE 2001
++
++#define CSMI_SAS_PHY_DOES_NOT_EXIST 2002
++#define CSMI_SAS_PHY_DOES_NOT_MATCH_PORT 2003
++#define CSMI_SAS_PHY_CANNOT_BE_SELECTED 2004
++#define CSMI_SAS_SELECT_PHY_OR_PORT 2005
++#define CSMI_SAS_PORT_DOES_NOT_EXIST 2006
++#define CSMI_SAS_PORT_CANNOT_BE_SELECTED 2007
++#define CSMI_SAS_CONNECTION_FAILED 2008
++
++#define CSMI_SAS_NO_SATA_DEVICE 2009
++#define CSMI_SAS_NO_SATA_SIGNATURE 2010
++#define CSMI_SAS_SCSI_EMULATION 2011
++#define CSMI_SAS_NOT_AN_END_DEVICE 2012
++#define CSMI_SAS_NO_SCSI_ADDRESS 2013
++#define CSMI_SAS_NO_DEVICE_ADDRESS 2014
++
++// Signature value
++// (IoctlHeader.Signature)
++
++#define CSMI_SAS_SIGNATURE "CSMISAS"
++
++// Timeout value default of 60 seconds
++// (IoctlHeader.Timeout)
++
++#define CSMI_SAS_TIMEOUT 60
++
++// Device types
++// (bDeviceType)
++
++#define CSMI_SAS_PHY_UNUSED 0x00
++#define CSMI_SAS_NO_DEVICE_ATTACHED 0x00
++#define CSMI_SAS_END_DEVICE 0x10
++#define CSMI_SAS_EDGE_EXPANDER_DEVICE 0x20
++#define CSMI_SAS_FANOUT_EXPANDER_DEVICE 0x30
++
++// Protocol options
++// (bInitiatorPortProtocol, bTargetPortProtocol)
++
++#define CSMI_SAS_PROTOCOL_SATA 0x01
++#define CSMI_SAS_PROTOCOL_SMP 0x02
++#define CSMI_SAS_PROTOCOL_STP 0x04
++#define CSMI_SAS_PROTOCOL_SSP 0x08
++
++// Negotiated and hardware link rates
++// (bNegotiatedLinkRate, bMinimumLinkRate, bMaximumLinkRate)
++
++#define CSMI_SAS_LINK_RATE_UNKNOWN 0x00
++#define CSMI_SAS_PHY_DISABLED 0x01
++#define CSMI_SAS_LINK_RATE_FAILED 0x02
++#define CSMI_SAS_SATA_SPINUP_HOLD 0x03
++#define CSMI_SAS_SATA_PORT_SELECTOR 0x04
++#define CSMI_SAS_LINK_RATE_1_5_GBPS 0x08
++#define CSMI_SAS_LINK_RATE_3_0_GBPS 0x09
++#define CSMI_SAS_LINK_VIRTUAL 0x10
++
++// Discover state
++// (bAutoDiscover)
++
++#define CSMI_SAS_DISCOVER_NOT_SUPPORTED 0x00
++#define CSMI_SAS_DISCOVER_NOT_STARTED 0x01
++#define CSMI_SAS_DISCOVER_IN_PROGRESS 0x02
++#define CSMI_SAS_DISCOVER_COMPLETE 0x03
++#define CSMI_SAS_DISCOVER_ERROR 0x04
++
++// Phy features
++
++#define CSMI_SAS_PHY_VIRTUAL_SMP 0x01
++
++// Programmed link rates
++// (bMinimumLinkRate, bMaximumLinkRate)
++// (bProgrammedMinimumLinkRate, bProgrammedMaximumLinkRate)
++
++#define CSMI_SAS_PROGRAMMED_LINK_RATE_UNCHANGED 0x00
++#define CSMI_SAS_PROGRAMMED_LINK_RATE_1_5_GBPS 0x08
++#define CSMI_SAS_PROGRAMMED_LINK_RATE_3_0_GBPS 0x09
++
++// Link rate
++// (bNegotiatedLinkRate in CSMI_SAS_SET_PHY_INFO)
++
++#define CSMI_SAS_LINK_RATE_NEGOTIATE 0x00
++#define CSMI_SAS_LINK_RATE_PHY_DISABLED 0x01
++
++// Signal class
++// (bSignalClass in CSMI_SAS_SET_PHY_INFO)
++
++#define CSMI_SAS_SIGNAL_CLASS_UNKNOWN 0x00
++#define CSMI_SAS_SIGNAL_CLASS_DIRECT 0x01
++#define CSMI_SAS_SIGNAL_CLASS_SERVER 0x02
++#define CSMI_SAS_SIGNAL_CLASS_ENCLOSURE 0x03
++
++// Link error reset
++// (bResetCounts)
++
++#define CSMI_SAS_LINK_ERROR_DONT_RESET_COUNTS 0x00
++#define CSMI_SAS_LINK_ERROR_RESET_COUNTS 0x01
++
++// Phy identifier
++// (bPhyIdentifier)
++
++#define CSMI_SAS_USE_PORT_IDENTIFIER 0xFF
++
++// Port identifier
++// (bPortIdentifier)
++
++#define CSMI_SAS_IGNORE_PORT 0xFF
++
++// Programmed link rates
++// (bConnectionRate)
++
++#define CSMI_SAS_LINK_RATE_NEGOTIATED 0x00
++#define CSMI_SAS_LINK_RATE_1_5_GBPS 0x08
++#define CSMI_SAS_LINK_RATE_3_0_GBPS 0x09
++
++// Connection status
++// (bConnectionStatus)
++
++#define CSMI_SAS_OPEN_ACCEPT 0
++#define CSMI_SAS_OPEN_REJECT_BAD_DESTINATION 1
++#define CSMI_SAS_OPEN_REJECT_RATE_NOT_SUPPORTED 2
++#define CSMI_SAS_OPEN_REJECT_NO_DESTINATION 3
++#define CSMI_SAS_OPEN_REJECT_PATHWAY_BLOCKED 4
++#define CSMI_SAS_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED 5
++#define CSMI_SAS_OPEN_REJECT_RESERVE_ABANDON 6
++#define CSMI_SAS_OPEN_REJECT_RESERVE_CONTINUE 7
++#define CSMI_SAS_OPEN_REJECT_RESERVE_INITIALIZE 8
++#define CSMI_SAS_OPEN_REJECT_RESERVE_STOP 9
++#define CSMI_SAS_OPEN_REJECT_RETRY 10
++#define CSMI_SAS_OPEN_REJECT_STP_RESOURCES_BUSY 11
++#define CSMI_SAS_OPEN_REJECT_WRONG_DESTINATION 12
++
++// SSP Status
++// (bSSPStatus)
++
++#define CSMI_SAS_SSP_STATUS_UNKNOWN 0x00
++#define CSMI_SAS_SSP_STATUS_WAITING 0x01
++#define CSMI_SAS_SSP_STATUS_COMPLETED 0x02
++#define CSMI_SAS_SSP_STATUS_FATAL_ERROR 0x03
++#define CSMI_SAS_SSP_STATUS_RETRY 0x04
++#define CSMI_SAS_SSP_STATUS_NO_TAG 0x05
++
++// SSP Flags
++// (uFlags)
++
++#define CSMI_SAS_SSP_READ 0x00000001
++#define CSMI_SAS_SSP_WRITE 0x00000002
++#define CSMI_SAS_SSP_UNSPECIFIED 0x00000004
++
++#define CSMI_SAS_SSP_TASK_ATTRIBUTE_SIMPLE 0x00000000
++#define CSMI_SAS_SSP_TASK_ATTRIBUTE_HEAD_OF_QUEUE 0x00000010
++#define CSMI_SAS_SSP_TASK_ATTRIBUTE_ORDERED 0x00000020
++#define CSMI_SAS_SSP_TASK_ATTRIBUTE_ACA 0x00000040
++
++// SSP Data present
++// (bDataPresent)
++
++#define CSMI_SAS_SSP_NO_DATA_PRESENT 0x00
++#define CSMI_SAS_SSP_RESPONSE_DATA_PRESENT 0x01
++#define CSMI_SAS_SSP_SENSE_DATA_PRESENT 0x02
++
++// STP Flags
++// (uFlags)
++
++#define CSMI_SAS_STP_READ 0x00000001
++#define CSMI_SAS_STP_WRITE 0x00000002
++#define CSMI_SAS_STP_UNSPECIFIED 0x00000004
++#define CSMI_SAS_STP_PIO 0x00000010
++#define CSMI_SAS_STP_DMA 0x00000020
++#define CSMI_SAS_STP_PACKET 0x00000040
++#define CSMI_SAS_STP_DMA_QUEUED 0x00000080
++#define CSMI_SAS_STP_EXECUTE_DIAG 0x00000100
++#define CSMI_SAS_STP_RESET_DEVICE 0x00000200
++
++// Task Management Flags
++// (uFlags)
++
++#define CSMI_SAS_TASK_IU 0x00000001
++#define CSMI_SAS_HARD_RESET_SEQUENCE 0x00000002
++#define CSMI_SAS_SUPPRESS_RESULT 0x00000004
++
++// Task Management Functions
++// (bTaskManagement)
++
++#define CSMI_SAS_SSP_ABORT_TASK 0x01
++#define CSMI_SAS_SSP_ABORT_TASK_SET 0x02
++#define CSMI_SAS_SSP_CLEAR_TASK_SET 0x04
++#define CSMI_SAS_SSP_LOGICAL_UNIT_RESET 0x08
++#define CSMI_SAS_SSP_CLEAR_ACA 0x40
++#define CSMI_SAS_SSP_QUERY_TASK 0x80
++
++// Task Management Information
++// (uInformation)
++
++#define CSMI_SAS_SSP_TEST 1
++#define CSMI_SAS_SSP_EXCEEDED 2
++#define CSMI_SAS_SSP_DEMAND 3
++#define CSMI_SAS_SSP_TRIGGER 4
++
++// Connector Pinout Information
++// (uPinout)
++
++#define CSMI_SAS_CON_UNKNOWN 0x00000001
++#define CSMI_SAS_CON_SFF_8482 0x00000002
++#define CSMI_SAS_CON_SFF_8470_LANE_1 0x00000100
++#define CSMI_SAS_CON_SFF_8470_LANE_2 0x00000200
++#define CSMI_SAS_CON_SFF_8470_LANE_3 0x00000400
++#define CSMI_SAS_CON_SFF_8470_LANE_4 0x00000800
++#define CSMI_SAS_CON_SFF_8484_LANE_1 0x00010000
++#define CSMI_SAS_CON_SFF_8484_LANE_2 0x00020000
++#define CSMI_SAS_CON_SFF_8484_LANE_3 0x00040000
++#define CSMI_SAS_CON_SFF_8484_LANE_4 0x00080000
++
++// Connector Location Information
++// (bLocation)
++
++// same as uPinout above...
++// #define CSMI_SAS_CON_UNKNOWN 0x01
++#define CSMI_SAS_CON_INTERNAL 0x02
++#define CSMI_SAS_CON_EXTERNAL 0x04
++#define CSMI_SAS_CON_SWITCHABLE 0x08
++#define CSMI_SAS_CON_AUTO 0x10
++#define CSMI_SAS_CON_NOT_PRESENT 0x20
++#define CSMI_SAS_CON_NOT_CONNECTED 0x80
++
++// Device location identification
++// (bIdentify)
++
++#define CSMI_SAS_LOCATE_UNKNOWN 0x00
++#define CSMI_SAS_LOCATE_FORCE_OFF 0x01
++#define CSMI_SAS_LOCATE_FORCE_ON 0x02
++
++// Location Valid flags
++// (uLocationFlags)
++
++#define CSMI_SAS_LOCATE_SAS_ADDRESS_VALID 0x00000001
++#define CSMI_SAS_LOCATE_SAS_LUN_VALID 0x00000002
++#define CSMI_SAS_LOCATE_ENCLOSURE_IDENTIFIER_VALID 0x00000004
++#define CSMI_SAS_LOCATE_ENCLOSURE_NAME_VALID 0x00000008
++#define CSMI_SAS_LOCATE_BAY_PREFIX_VALID 0x00000010
++#define CSMI_SAS_LOCATE_BAY_IDENTIFIER_VALID 0x00000020
++#define CSMI_SAS_LOCATE_LOCATION_STATE_VALID 0x00000040
++
++/* * * * * * * * SAS Phy Control Class IOCTL Constants * * * * * * * * */
++
++// Return codes for SAS Phy Control IOCTL's
++// (IoctlHeader.ReturnCode)
++
++// Signature value
++// (IoctlHeader.Signature)
++
++#define CSMI_PHY_SIGNATURE "CSMIPHY"
++
++// Phy Control Functions
++// (bFunction)
++
++// values 0x00 to 0xFF are consistent in definition with the SMP PHY CONTROL
++// function defined in the SAS spec
++#define CSMI_SAS_PC_NOP 0x00000000
++#define CSMI_SAS_PC_LINK_RESET 0x00000001
++#define CSMI_SAS_PC_HARD_RESET 0x00000002
++#define CSMI_SAS_PC_PHY_DISABLE 0x00000003
++// 0x04 to 0xFF reserved...
++#define CSMI_SAS_PC_GET_PHY_SETTINGS 0x00000100
++
++// Link Flags
++#define CSMI_SAS_PHY_ACTIVATE_CONTROL 0x00000001
++#define CSMI_SAS_PHY_UPDATE_SPINUP_RATE 0x00000002
++#define CSMI_SAS_PHY_AUTO_COMWAKE 0x00000004
++
++// Device Types for Phy Settings
++// (bType)
++#define CSMI_SAS_UNDEFINED 0x00
++#define CSMI_SAS_SATA 0x01
++#define CSMI_SAS_SAS 0x02
++
++// Transmitter Flags
++// (uTransmitterFlags)
++#define CSMI_SAS_PHY_PREEMPHASIS_DISABLED 0x00000001
++
++// Receiver Flags
++// (uReceiverFlags)
++#define CSMI_SAS_PHY_EQUALIZATION_DISABLED 0x00000001
++
++// Pattern Flags
++// (uPatternFlags)
++// #define CSMI_SAS_PHY_ACTIVATE_CONTROL 0x00000001
++#define CSMI_SAS_PHY_DISABLE_SCRAMBLING 0x00000002
++#define CSMI_SAS_PHY_DISABLE_ALIGN 0x00000004
++#define CSMI_SAS_PHY_DISABLE_SSC 0x00000008
++
++#define CSMI_SAS_PHY_FIXED_PATTERN 0x00000010
++#define CSMI_SAS_PHY_USER_PATTERN 0x00000020
++
++// Fixed Patterns
++// (bFixedPattern)
++#define CSMI_SAS_PHY_CJPAT 0x00000001
++#define CSMI_SAS_PHY_ALIGN 0x00000002
++
++// Type Flags
++// (bTypeFlags)
++#define CSMI_SAS_PHY_POSITIVE_DISPARITY 0x01
++#define CSMI_SAS_PHY_NEGATIVE_DISPARITY 0x02
++#define CSMI_SAS_PHY_CONTROL_CHARACTER 0x04
++
++// Miscellaneous
++#define SLOT_NUMBER_UNKNOWN 0xFFFF
++
++/*************************************************************************/
++/* DATA STRUCTURES */
++/*************************************************************************/
++
++/* * * * * * * * * * Class Independent Structures * * * * * * * * * */
++
++// EDM #pragma CSMI_SAS_BEGIN_PACK(8)
++#pragma pack(8)
++
++// CC_CSMI_SAS_DRIVER_INFO
++
++typedef struct _CSMI_SAS_DRIVER_INFO {
++ __u8 szName[81];
++ __u8 szDescription[81];
++ __u16 usMajorRevision;
++ __u16 usMinorRevision;
++ __u16 usBuildRevision;
++ __u16 usReleaseRevision;
++ __u16 usCSMIMajorRevision;
++ __u16 usCSMIMinorRevision;
++} CSMI_SAS_DRIVER_INFO,
++ *PCSMI_SAS_DRIVER_INFO;
++
++typedef struct _CSMI_SAS_DRIVER_INFO_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_DRIVER_INFO Information;
++} CSMI_SAS_DRIVER_INFO_BUFFER,
++ *PCSMI_SAS_DRIVER_INFO_BUFFER;
++
++// CC_CSMI_SAS_CNTLR_CONFIGURATION
++
++typedef struct _CSMI_SAS_PCI_BUS_ADDRESS {
++ __u8 bBusNumber;
++ __u8 bDeviceNumber;
++ __u8 bFunctionNumber;
++ __u8 bReserved;
++} CSMI_SAS_PCI_BUS_ADDRESS,
++ *PCSMI_SAS_PCI_BUS_ADDRESS;
++
++typedef union _CSMI_SAS_IO_BUS_ADDRESS {
++ CSMI_SAS_PCI_BUS_ADDRESS PciAddress;
++ __u8 bReserved[32];
++} CSMI_SAS_IO_BUS_ADDRESS,
++ *PCSMI_SAS_IO_BUS_ADDRESS;
++
++typedef struct _CSMI_SAS_CNTLR_CONFIG {
++ __u32 uBaseIoAddress;
++ struct {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } BaseMemoryAddress;
++ __u32 uBoardID;
++ __u16 usSlotNumber;
++ __u8 bControllerClass;
++ __u8 bIoBusType;
++ CSMI_SAS_IO_BUS_ADDRESS BusAddress;
++ __u8 szSerialNumber[81];
++ __u16 usMajorRevision;
++ __u16 usMinorRevision;
++ __u16 usBuildRevision;
++ __u16 usReleaseRevision;
++ __u16 usBIOSMajorRevision;
++ __u16 usBIOSMinorRevision;
++ __u16 usBIOSBuildRevision;
++ __u16 usBIOSReleaseRevision;
++ __u32 uControllerFlags;
++ __u16 usRromMajorRevision;
++ __u16 usRromMinorRevision;
++ __u16 usRromBuildRevision;
++ __u16 usRromReleaseRevision;
++ __u16 usRromBIOSMajorRevision;
++ __u16 usRromBIOSMinorRevision;
++ __u16 usRromBIOSBuildRevision;
++ __u16 usRromBIOSReleaseRevision;
++ __u8 bReserved[7];
++} CSMI_SAS_CNTLR_CONFIG,
++ *PCSMI_SAS_CNTLR_CONFIG;
++
++typedef struct _CSMI_SAS_CNTLR_CONFIG_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_CNTLR_CONFIG Configuration;
++} CSMI_SAS_CNTLR_CONFIG_BUFFER,
++ *PCSMI_SAS_CNTLR_CONFIG_BUFFER;
++
++// CC_CSMI_SAS_CNTLR_STATUS
++
++typedef struct _CSMI_SAS_CNTLR_STATUS {
++ __u32 uStatus;
++ __u32 uOfflineReason;
++ __u8 bReserved[28];
++} CSMI_SAS_CNTLR_STATUS,
++ *PCSMI_SAS_CNTLR_STATUS;
++
++typedef struct _CSMI_SAS_CNTLR_STATUS_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_CNTLR_STATUS Status;
++} CSMI_SAS_CNTLR_STATUS_BUFFER,
++ *PCSMI_SAS_CNTLR_STATUS_BUFFER;
++
++// CC_CSMI_SAS_FIRMWARE_DOWNLOAD
++
++typedef struct _CSMI_SAS_FIRMWARE_DOWNLOAD {
++ __u32 uBufferLength;
++ __u32 uDownloadFlags;
++ __u8 bReserved[32];
++ __u16 usStatus;
++ __u16 usSeverity;
++} CSMI_SAS_FIRMWARE_DOWNLOAD,
++ *PCSMI_SAS_FIRMWARE_DOWNLOAD;
++
++typedef struct _CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_FIRMWARE_DOWNLOAD Information;
++ __u8 bDataBuffer[1];
++} CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER,
++ *PCSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER;
++
++// CC_CSMI_SAS_RAID_INFO
++
++typedef struct _CSMI_SAS_RAID_INFO {
++ __u32 uNumRaidSets;
++ __u32 uMaxDrivesPerSet;
++ __u32 uMaxRaidSets;
++ __u8 bMaxRaidTypes;
++ __u8 bReservedByteFields[7];
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulMinRaidSetBlocks;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulMaxRaidSetBlocks;
++ __u32 uMaxPhysicalDrives;
++ __u32 uMaxExtents;
++ __u32 uMaxModules;
++ __u32 uMaxTransformationMemory;
++ __u32 uChangeCount;
++ __u8 bReserved[44];
++} CSMI_SAS_RAID_INFO,
++ *PCSMI_SAS_RAID_INFO;
++
++typedef struct _CSMI_SAS_RAID_INFO_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_RAID_INFO Information;
++} CSMI_SAS_RAID_INFO_BUFFER,
++ *PCSMI_SAS_RAID_INFO_BUFFER;
++
++// CC_CSMI_SAS_GET_RAID_CONFIG
++
++typedef struct _CSMI_SAS_RAID_DRIVES {
++ __u8 bModel[40];
++ __u8 bFirmware[8];
++ __u8 bSerialNumber[40];
++ __u8 bSASAddress[8];
++ __u8 bSASLun[8];
++ __u8 bDriveStatus;
++ __u8 bDriveUsage;
++ __u16 usBlockSize;
++ __u8 bDriveType;
++ __u8 bReserved[15];
++ __u32 uDriveIndex;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulTotalUserBlocks;
++} CSMI_SAS_RAID_DRIVES,
++ *PCSMI_SAS_RAID_DRIVES;
++
++typedef struct _CSMI_SAS_RAID_DEVICE_ID {
++ __u8 bDeviceIdentificationVPDPage[1];
++} CSMI_SAS_RAID_DEVICE_ID,
++ *PCSMI_SAS_RAID_DEVICE_ID;
++
++typedef struct _CSMI_SAS_RAID_SET_ADDITIONAL_DATA {
++ __u8 bLabel[16];
++ __u8 bRaidSetLun[8];
++ __u8 bWriteProtection;
++ __u8 bCacheSetting;
++ __u8 bCacheRatio;
++ __u16 usBlockSize;
++ __u8 bReservedBytes[11];
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulRaidSetExtentOffset;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulRaidSetBlocks;
++ __u32 uStripeSizeInBlocks;
++ __u32 uSectorsPerTrack;
++ __u8 bApplicationScratchPad[16];
++ __u32 uNumberOfHeads;
++ __u32 uNumberOfTracks;
++ __u8 bReserved[24];
++} CSMI_SAS_RAID_SET_ADDITIONAL_DATA,
++ *PCSMI_SAS_RAID_SET_ADDITIONAL_DATA;
++
++typedef struct _CSMI_SAS_RAID_CONFIG {
++ __u32 uRaidSetIndex;
++ __u32 uCapacity;
++ __u32 uStripeSize;
++ __u8 bRaidType;
++ __u8 bStatus;
++ __u8 bInformation;
++ __u8 bDriveCount;
++ __u8 bDataType;
++ __u8 bReserved[11];
++ __u32 uFailureCode;
++ __u32 uChangeCount;
++ union {
++ CSMI_SAS_RAID_DRIVES Drives[1];
++ CSMI_SAS_RAID_DEVICE_ID DeviceId[1];
++ CSMI_SAS_RAID_SET_ADDITIONAL_DATA Data[1];
++ };
++} CSMI_SAS_RAID_CONFIG,
++ *PCSMI_SAS_RAID_CONFIG;
++
++typedef struct _CSMI_SAS_RAID_CONFIG_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_RAID_CONFIG Configuration;
++} CSMI_SAS_RAID_CONFIG_BUFFER,
++ *PCSMI_SAS_RAID_CONFIG_BUFFER;
++
++// CC_CSMI_SAS_GET_RAID_FEATURES
++
++typedef struct _CSMI_SAS_RAID_TYPE_DESCRIPTION {
++ __u8 bRaidType;
++ __u8 bReservedBytes[7];
++ __u32 uSupportedStripeSizeMap;
++ __u8 bReserved[24];
++} CSMI_SAS_RAID_TYPE_DESCRIPTION,
++ *PCSMI_SAS_RAID_TYPE_DESCRIPTION;
++
++typedef struct _CSMI_SAS_RAID_FEATURES {
++ __u32 uFeatures;
++ __u8 bReservedFeatures[32];
++ __u8 bDefaultTransformPriority;
++ __u8 bTransformPriority;
++ __u8 bDefaultRebuildPriority;
++ __u8 bRebuildPriority;
++ __u8 bDefaultSurfaceScanPriority;
++ __u8 bSurfaceScanPriority;
++ __u16 usReserved;
++ __u32 uRaidSetTransformationRules;
++ __u32 uReserved[11];
++ CSMI_SAS_RAID_TYPE_DESCRIPTION RaidType[24];
++ __u8 bCacheRatiosSupported[104];
++ __u32 uChangeCount;
++ __u32 uFailureCode;
++ __u8 bReserved[120];
++} CSMI_SAS_RAID_FEATURES,
++ *PCSMI_SAS_RAID_FEATURES;
++
++typedef struct _CSMI_SAS_RAID_FEATURES_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_RAID_FEATURES Information;
++} CSMI_SAS_RAID_FEATURES_BUFFER,
++ *PCSMI_SAS_RAID_FEATURES_BUFFER;
++
++// CC_CSMI_SAS_SET_RAID_CONTROL
++
++typedef struct _CSMI_SAS_RAID_CONTROL {
++ __u8 bTransformPriority;
++ __u8 bRebuildPriority;
++ __u8 bCacheRatioFlag;
++ __u8 bCacheRatio;
++ __u8 bSurfaceScanPriority;
++ __u8 bReservedBytes[15];
++ __u8 bClearConfiguration[8];
++ __u32 uChangeCount;
++ __u8 bReserved[88];
++ __u32 uFailureCode;
++ __u8 bFailureDescription[80];
++} CSMI_SAS_RAID_CONTROL,
++ *PCSMI_SAS_RAID_CONTROL;
++
++typedef struct _CSMI_SAS_RAID_CONTROL_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_RAID_CONTROL Information;
++} CSMI_SAS_RAID_CONTROL_BUFFER,
++ *PCSMI_SAS_RAID_CONTROL_BUFFER;
++
++// CC_CSMI_SAS_GET_RAID_ELEMENT
++
++typedef struct _CSMI_SAS_DRIVE_EXTENT_INFO {
++ __u32 uDriveIndex;
++ __u8 bExtentType;
++ __u8 bReservedBytes[7];
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulExtentOffset;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulExtentBlocks;
++ __u32 uRaidSetIndex;
++ __u8 bReserved[96];
++} CSMI_SAS_DRIVE_EXTENT_INFO,
++ *PCSMI_SAS_DRIVE_EXTENT_INFO;
++
++typedef struct _CSMI_SAS_RAID_MODULE_INFO {
++ __u8 bReserved[128];
++} CSMI_SAS_RAID_MODULE_INFO,
++ *PCSMI_SAS_RAID_MODULE_INFO;
++
++typedef struct _CSMI_SAS_DRIVE_LOCATION {
++ __u8 bConnector[16];
++ __u8 bBoxName[16];
++ __u32 uBay;
++ __u8 bReservedBytes[4];
++ __u8 bAttachedSASAddress[8];
++ __u8 bAttachedPhyIdentifier;
++ __u8 bReserved[79];
++} CSMI_SAS_DRIVE_LOCATION,
++ *PCSMI_SAS_DRIVE_LOCATION;
++
++typedef struct _CSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA {
++ __u8 bNegotiatedLinkRate[2];
++ __u8 bReserved[126];
++} CSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA,
++ *PCSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA;
++
++typedef struct _CSMI_SAS_DRIVE_INFO {
++ CSMI_SAS_RAID_DRIVES Device;
++ CSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA Data;
++ CSMI_SAS_DRIVE_LOCATION Location;
++ __u8 bReserved[16];
++} CSMI_SAS_DRIVE_INFO,
++ *PCSMI_SAS_DRIVE_INFO;
++
++typedef struct _CSMI_SAS_RAID_ELEMENT {
++ __u32 uEnumerationType;
++ __u32 uElementIndex;
++ __u32 uNumElements;
++ __u32 uChangeCount;
++ __u32 uSubElementIndex;
++ __u8 bReserved[32];
++ __u32 uFailureCode;
++ __u8 bFailureDescription[80];
++ union {
++ CSMI_SAS_DRIVE_INFO Drive;
++ CSMI_SAS_RAID_MODULE_INFO Module;
++ CSMI_SAS_DRIVE_EXTENT_INFO Extent;
++ } Element;
++} CSMI_SAS_RAID_ELEMENT,
++ *PCSMI_SAS_RAID_ELEMENT;
++
++typedef struct _CSMI_SAS_RAID_ELEMENT_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_RAID_ELEMENT Information;
++} CSMI_SAS_RAID_ELEMENT_BUFFER,
++ *PCSMI_SAS_RAID_ELEMENT_BUFFER;
++
++// CC_CSMI_SAS_SET_RAID_OPERATION
++
++typedef struct _CSMI_SAS_RAID_SET_LIST {
++ __u32 uRaidSetIndex;
++ __u8 bExistingLun[8];
++ __u8 bNewLun[8];
++ __u8 bReserved[12];
++} CSMI_SAS_RAID_SET_LIST,
++ *PCSMI_SAS_RAID_SET_LIST;
++
++typedef struct _CSMI_SAS_RAID_SET_DRIVE_LIST {
++ __u32 uDriveIndex;
++ __u8 bDriveUsage;
++ __u8 bReserved[27];
++} CSMI_SAS_RAID_SET_DRIVE_LIST,
++ *PCSMI_SAS_RAID_SET_DRIVE_LIST;
++
++typedef struct _CSMI_SAS_RAID_SET_SPARE_INFO {
++ __u32 uRaidSetIndex;
++ __u32 uDriveCount;
++ __u8 bApplicationScratchPad[16];
++ __u8 bReserved[104];
++} CSMI_SAS_RAID_SET_SPARE_INFO,
++ *PCSMI_SAS_RAID_SET_SPARE_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_ONLINE_STATE_INFO {
++ __u32 uRaidSetIndex;
++ __u8 bOnlineState;
++ __u8 bReserved[123];
++} CSMI_SAS_RAID_SET_ONLINE_STATE_INFO,
++ *PCSMI_SAS_RAID_SET_ONLINE_STATE_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_CACHE_INFO {
++ __u32 uRaidSetIndex;
++ __u8 bCacheSetting;
++ __u8 bCacheRatioFlag;
++ __u8 bCacheRatio;
++ __u8 bReserved[121];
++} CSMI_SAS_RAID_SET_CACHE_INFO,
++ *PCSMI_SAS_RAID_SET_CACHE_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_WRITE_PROTECT_INFO {
++ __u32 uRaidSetIndex;
++ __u8 bWriteProtectSetting;
++ __u8 bReserved[123];
++} CSMI_SAS_RAID_SET_WRITE_PROTECT_INFO,
++ *PCSMI_SAS_RAID_SET_WRITE_PROTECT_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_DELETE_INFO {
++ __u32 uRaidSetIndex;
++ __u8 bReserved[124];
++} CSMI_SAS_RAID_SET_DELETE_INFO,
++ *PCSMI_SAS_RAID_SET_DELETE_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_MODIFY_INFO {
++ __u8 bRaidType;
++ __u8 bReservedBytes[7];
++ __u32 uStripeSize;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulRaidSetBlocks;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulRaidSetExtentOffset;
++ __u32 uDriveCount;
++ __u8 bReserved[96];
++} CSMI_SAS_RAID_SET_MODIFY_INFO,
++ *PCSMI_SAS_RAID_SET_MODIFY_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_TRANSFORM_INFO {
++ __u8 bTransformType;
++ __u8 bReservedBytes[3];
++ __u32 uRaidSetIndex;
++ __u8 bRaidType;
++ __u8 bReservedBytes2[11];
++ __u32 uAdditionalRaidSetIndex;
++ __u32 uRaidSetCount;
++ __u8 bApplicationScratchPad[16];
++ CSMI_SAS_RAID_SET_MODIFY_INFO Modify;
++ __u8 bReserved[80];
++} CSMI_SAS_RAID_SET_TRANSFORM_INFO,
++ *PCSMI_SAS_RAID_SET_TRANSFORM_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_LABEL_INFO {
++ __u32 uRaidSetIndex;
++ __u8 bLabel[16];
++ __u8 bReserved[108];
++} CSMI_SAS_RAID_SET_LABEL_INFO,
++ *PCSMI_SAS_RAID_SET_LABEL_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_CREATE_INFO {
++ __u8 bRaidType;
++ __u8 bReservedBytes[7];
++ __u32 uStripeSize;
++ __u32 uTrackSectorCount;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulRaidSetBlocks;
++ struct
++ {
++ __u32 uLowPart;
++ __u32 uHighPart;
++ } ulRaidSetExtentOffset;
++ __u32 uDriveCount;
++ __u8 bLabel[16];
++ __u32 uRaidSetIndex;
++ __u8 bApplicationScratchPad[16];
++ __u32 uNumberOfHeads;
++ __u32 uNumberOfTracks;
++ __u8 bReserved[48];
++} CSMI_SAS_RAID_SET_CREATE_INFO,
++ *PCSMI_SAS_RAID_SET_CREATE_INFO;
++
++typedef struct _CSMI_SAS_RAID_SET_OPERATION {
++ __u32 uOperationType;
++ __u32 uChangeCount;
++ __u32 uFailureCode;
++ __u8 bFailureDescription[80];
++ __u8 bReserved[28];
++ union {
++ CSMI_SAS_RAID_SET_CREATE_INFO Create;
++ CSMI_SAS_RAID_SET_LABEL_INFO Label;
++ CSMI_SAS_RAID_SET_TRANSFORM_INFO Transform;
++ CSMI_SAS_RAID_SET_DELETE_INFO Delete;
++ CSMI_SAS_RAID_SET_WRITE_PROTECT_INFO Protect;
++ CSMI_SAS_RAID_SET_CACHE_INFO Cache;
++ CSMI_SAS_RAID_SET_ONLINE_STATE_INFO State;
++ CSMI_SAS_RAID_SET_SPARE_INFO Spare;
++ } Operation;
++ union {
++ CSMI_SAS_RAID_SET_DRIVE_LIST DriveList[1];
++ CSMI_SAS_RAID_SET_LIST RaidSetList[1];
++ } Parameters;
++} CSMI_SAS_RAID_SET_OPERATION,
++ *PCSMI_SAS_RAID_SET_OPERATION;
++
++typedef struct _CSMI_SAS_RAID_SET_OPERATION_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_RAID_SET_OPERATION Information;
++} CSMI_SAS_RAID_SET_OPERATION_BUFFER,
++ *PCSMI_SAS_RAID_SET_OPERATION_BUFFER;
++
++/* * * * * * * * * * SAS HBA Class Structures * * * * * * * * * */
++
++// CC_CSMI_SAS_GET_PHY_INFO
++
++typedef struct _CSMI_SAS_IDENTIFY {
++ __u8 bDeviceType;
++ __u8 bRestricted;
++ __u8 bInitiatorPortProtocol;
++ __u8 bTargetPortProtocol;
++ __u8 bRestricted2[8];
++ __u8 bSASAddress[8];
++ __u8 bPhyIdentifier;
++ __u8 bSignalClass;
++ __u8 bReserved[6];
++} CSMI_SAS_IDENTIFY,
++ *PCSMI_SAS_IDENTIFY;
++
++typedef struct _CSMI_SAS_PHY_ENTITY {
++ CSMI_SAS_IDENTIFY Identify;
++ __u8 bPortIdentifier;
++ __u8 bNegotiatedLinkRate;
++ __u8 bMinimumLinkRate;
++ __u8 bMaximumLinkRate;
++ __u8 bPhyChangeCount;
++ __u8 bAutoDiscover;
++ __u8 bPhyFeatures;
++ __u8 bReserved;
++ CSMI_SAS_IDENTIFY Attached;
++} CSMI_SAS_PHY_ENTITY,
++ *PCSMI_SAS_PHY_ENTITY;
++
++typedef struct _CSMI_SAS_PHY_INFO {
++ __u8 bNumberOfPhys;
++ __u8 bReserved[3];
++ CSMI_SAS_PHY_ENTITY Phy[32];
++} CSMI_SAS_PHY_INFO,
++ *PCSMI_SAS_PHY_INFO;
++
++typedef struct _CSMI_SAS_PHY_INFO_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_PHY_INFO Information;
++} CSMI_SAS_PHY_INFO_BUFFER,
++ *PCSMI_SAS_PHY_INFO_BUFFER;
++
++// CC_CSMI_SAS_SET_PHY_INFO
++
++typedef struct _CSMI_SAS_SET_PHY_INFO {
++ __u8 bPhyIdentifier;
++ __u8 bNegotiatedLinkRate;
++ __u8 bProgrammedMinimumLinkRate;
++ __u8 bProgrammedMaximumLinkRate;
++ __u8 bSignalClass;
++ __u8 bReserved[3];
++} CSMI_SAS_SET_PHY_INFO,
++ *PCSMI_SAS_SET_PHY_INFO;
++
++typedef struct _CSMI_SAS_SET_PHY_INFO_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_SET_PHY_INFO Information;
++} CSMI_SAS_SET_PHY_INFO_BUFFER,
++ *PCSMI_SAS_SET_PHY_INFO_BUFFER;
++
++// CC_CSMI_SAS_GET_LINK_ERRORS
++
++typedef struct _CSMI_SAS_LINK_ERRORS {
++ __u8 bPhyIdentifier;
++ __u8 bResetCounts;
++ __u8 bReserved[2];
++ __u32 uInvalidDwordCount;
++ __u32 uRunningDisparityErrorCount;
++ __u32 uLossOfDwordSyncCount;
++ __u32 uPhyResetProblemCount;
++} CSMI_SAS_LINK_ERRORS,
++ *PCSMI_SAS_LINK_ERRORS;
++
++typedef struct _CSMI_SAS_LINK_ERRORS_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_LINK_ERRORS Information;
++} CSMI_SAS_LINK_ERRORS_BUFFER,
++ *PCSMI_SAS_LINK_ERRORS_BUFFER;
++
++// CC_CSMI_SAS_SMP_PASSTHRU
++
++typedef struct _CSMI_SAS_SMP_REQUEST {
++ __u8 bFrameType;
++ __u8 bFunction;
++ __u8 bReserved[2];
++ __u8 bAdditionalRequestBytes[1016];
++} CSMI_SAS_SMP_REQUEST,
++ *PCSMI_SAS_SMP_REQUEST;
++
++typedef struct _CSMI_SAS_SMP_RESPONSE {
++ __u8 bFrameType;
++ __u8 bFunction;
++ __u8 bFunctionResult;
++ __u8 bReserved;
++ __u8 bAdditionalResponseBytes[1016];
++} CSMI_SAS_SMP_RESPONSE,
++ *PCSMI_SAS_SMP_RESPONSE;
++
++typedef struct _CSMI_SAS_SMP_PASSTHRU {
++ __u8 bPhyIdentifier;
++ __u8 bPortIdentifier;
++ __u8 bConnectionRate;
++ __u8 bReserved;
++ __u8 bDestinationSASAddress[8];
++ __u32 uRequestLength;
++ CSMI_SAS_SMP_REQUEST Request;
++ __u8 bConnectionStatus;
++ __u8 bReserved2[3];
++ __u32 uResponseBytes;
++ CSMI_SAS_SMP_RESPONSE Response;
++} CSMI_SAS_SMP_PASSTHRU,
++ *PCSMI_SAS_SMP_PASSTHRU;
++
++typedef struct _CSMI_SAS_SMP_PASSTHRU_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_SMP_PASSTHRU Parameters;
++} CSMI_SAS_SMP_PASSTHRU_BUFFER,
++ *PCSMI_SAS_SMP_PASSTHRU_BUFFER;
++
++// CC_CSMI_SAS_SSP_PASSTHRU
++
++typedef struct _CSMI_SAS_SSP_PASSTHRU {
++ __u8 bPhyIdentifier;
++ __u8 bPortIdentifier;
++ __u8 bConnectionRate;
++ __u8 bReserved;
++ __u8 bDestinationSASAddress[8];
++ __u8 bLun[8];
++ __u8 bCDBLength;
++ __u8 bAdditionalCDBLength;
++ __u8 bReserved2[2];
++ __u8 bCDB[16];
++ __u32 uFlags;
++ __u8 bAdditionalCDB[24];
++ __u32 uDataLength;
++} CSMI_SAS_SSP_PASSTHRU,
++ *PCSMI_SAS_SSP_PASSTHRU;
++
++typedef struct _CSMI_SAS_SSP_PASSTHRU_STATUS {
++ __u8 bConnectionStatus;
++ __u8 bSSPStatus;
++ __u8 bReserved[2];
++ __u8 bDataPresent;
++ __u8 bStatus;
++ __u8 bResponseLength[2];
++ __u8 bResponse[256];
++ __u32 uDataBytes;
++} CSMI_SAS_SSP_PASSTHRU_STATUS,
++ *PCSMI_SAS_SSP_PASSTHRU_STATUS;
++
++typedef struct _CSMI_SAS_SSP_PASSTHRU_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_SSP_PASSTHRU Parameters;
++ CSMI_SAS_SSP_PASSTHRU_STATUS Status;
++ __u8 bDataBuffer[1];
++} CSMI_SAS_SSP_PASSTHRU_BUFFER,
++ *PCSMI_SAS_SSP_PASSTHRU_BUFFER;
++
++// CC_CSMI_SAS_STP_PASSTHRU
++
++typedef struct _CSMI_SAS_STP_PASSTHRU {
++ __u8 bPhyIdentifier;
++ __u8 bPortIdentifier;
++ __u8 bConnectionRate;
++ __u8 bReserved;
++ __u8 bDestinationSASAddress[8];
++ __u8 bReserved2[4];
++ __u8 bCommandFIS[20];
++ __u32 uFlags;
++ __u32 uDataLength;
++} CSMI_SAS_STP_PASSTHRU,
++ *PCSMI_SAS_STP_PASSTHRU;
++
++typedef struct _CSMI_SAS_STP_PASSTHRU_STATUS {
++ __u8 bConnectionStatus;
++ __u8 bReserved[3];
++ __u8 bStatusFIS[20];
++ __u32 uSCR[16];
++ __u32 uDataBytes;
++} CSMI_SAS_STP_PASSTHRU_STATUS,
++ *PCSMI_SAS_STP_PASSTHRU_STATUS;
++
++typedef struct _CSMI_SAS_STP_PASSTHRU_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_STP_PASSTHRU Parameters;
++ CSMI_SAS_STP_PASSTHRU_STATUS Status;
++ __u8 bDataBuffer[1];
++} CSMI_SAS_STP_PASSTHRU_BUFFER,
++ *PCSMI_SAS_STP_PASSTHRU_BUFFER;
++
++// CC_CSMI_SAS_GET_SATA_SIGNATURE
++
++typedef struct _CSMI_SAS_SATA_SIGNATURE {
++ __u8 bPhyIdentifier;
++ __u8 bReserved[3];
++ __u8 bSignatureFIS[20];
++} CSMI_SAS_SATA_SIGNATURE,
++ *PCSMI_SAS_SATA_SIGNATURE;
++
++typedef struct _CSMI_SAS_SATA_SIGNATURE_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_SATA_SIGNATURE Signature;
++} CSMI_SAS_SATA_SIGNATURE_BUFFER,
++ *PCSMI_SAS_SATA_SIGNATURE_BUFFER;
++
++// CC_CSMI_SAS_GET_SCSI_ADDRESS
++
++typedef struct _CSMI_SAS_GET_SCSI_ADDRESS_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ __u8 bSASAddress[8];
++ __u8 bSASLun[8];
++ __u8 bHostIndex;
++ __u8 bPathId;
++ __u8 bTargetId;
++ __u8 bLun;
++} CSMI_SAS_GET_SCSI_ADDRESS_BUFFER,
++ *PCSMI_SAS_GET_SCSI_ADDRESS_BUFFER;
++
++// CC_CSMI_SAS_GET_DEVICE_ADDRESS
++
++typedef struct _CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ __u8 bHostIndex;
++ __u8 bPathId;
++ __u8 bTargetId;
++ __u8 bLun;
++ __u8 bSASAddress[8];
++ __u8 bSASLun[8];
++} CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER,
++ *PCSMI_SAS_GET_DEVICE_ADDRESS_BUFFER;
++
++// CC_CSMI_SAS_TASK_MANAGEMENT
++
++typedef struct _CSMI_SAS_SSP_TASK_IU {
++ __u8 bHostIndex;
++ __u8 bPathId;
++ __u8 bTargetId;
++ __u8 bLun;
++ __u32 uFlags;
++ __u32 uQueueTag;
++ __u32 uReserved;
++ __u8 bTaskManagementFunction;
++ __u8 bReserved[7];
++ __u32 uInformation;
++} CSMI_SAS_SSP_TASK_IU,
++ *PCSMI_SAS_SSP_TASK_IU;
++
++typedef struct _CSMI_SAS_SSP_TASK_IU_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_SSP_TASK_IU Parameters;
++ CSMI_SAS_SSP_PASSTHRU_STATUS Status;
++} CSMI_SAS_SSP_TASK_IU_BUFFER,
++ *PCSMI_SAS_SSP_TASK_IU_BUFFER;
++
++// CC_CSMI_SAS_GET_CONNECTOR_INFO
++
++typedef struct _CSMI_SAS_GET_CONNECTOR_INFO {
++ __u32 uPinout;
++ __u8 bConnector[16];
++ __u8 bLocation;
++ __u8 bReserved[15];
++} CSMI_SAS_CONNECTOR_INFO,
++ *PCSMI_SAS_CONNECTOR_INFO;
++
++typedef struct _CSMI_SAS_CONNECTOR_INFO_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ CSMI_SAS_CONNECTOR_INFO Reference[32];
++} CSMI_SAS_CONNECTOR_INFO_BUFFER,
++ *PCSMI_SAS_CONNECTOR_INFO_BUFFER;
++
++// CC_CSMI_SAS_GET_LOCATION
++
++typedef struct _CSMI_SAS_LOCATION_IDENTIFIER {
++ __u32 bLocationFlags;
++ __u8 bSASAddress[8];
++ __u8 bSASLun[8];
++ __u8 bEnclosureIdentifier[8];
++ __u8 bEnclosureName[32];
++ __u8 bBayPrefix[32];
++ __u8 bBayIdentifier;
++ __u8 bLocationState;
++ __u8 bReserved[2];
++} CSMI_SAS_LOCATION_IDENTIFIER,
++ *PCSMI_SAS_LOCATION_IDENTIFIER;
++
++typedef struct _CSMI_SAS_GET_LOCATION_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ __u8 bHostIndex;
++ __u8 bPathId;
++ __u8 bTargetId;
++ __u8 bLun;
++ __u8 bIdentify;
++ __u8 bNumberOfLocationIdentifiers;
++ __u8 bLengthOfLocationIdentifier;
++ CSMI_SAS_LOCATION_IDENTIFIER Location[1];
++} CSMI_SAS_GET_LOCATION_BUFFER,
++ *PCSMI_SAS_GET_LOCATION_BUFFER;
++
++// CC_CSMI_SAS_PHY_CONTROL
++
++typedef struct _CSMI_SAS_CHARACTER {
++ __u8 bTypeFlags;
++ __u8 bValue;
++} CSMI_SAS_CHARACTER,
++ *PCSMI_SAS_CHARACTER;
++
++typedef struct _CSMI_SAS_PHY_CONTROL {
++ __u8 bType;
++ __u8 bRate;
++ __u8 bReserved[6];
++ __u32 uVendorUnique[8];
++ __u32 uTransmitterFlags;
++ __i8 bTransmitAmplitude;
++ __i8 bTransmitterPreemphasis;
++ __i8 bTransmitterSlewRate;
++ __i8 bTransmitterReserved[13];
++ __u8 bTransmitterVendorUnique[64];
++ __u32 uReceiverFlags;
++ __i8 bReceiverThreshold;
++ __i8 bReceiverEqualizationGain;
++ __i8 bReceiverReserved[14];
++ __u8 bReceiverVendorUnique[64];
++ __u32 uPatternFlags;
++ __u8 bFixedPattern;
++ __u8 bUserPatternLength;
++ __u8 bPatternReserved[6];
++ CSMI_SAS_CHARACTER UserPatternBuffer[16];
++} CSMI_SAS_PHY_CONTROL,
++ *PCSMI_SAS_PHY_CONTROL;
++
++typedef struct _CSMI_SAS_PHY_CONTROL_BUFFER {
++ IOCTL_HEADER IoctlHeader;
++ __u32 uFunction;
++ __u8 bPhyIdentifier;
++ __u16 usLengthOfControl;
++ __u8 bNumberOfControls;
++ __u8 bReserved[4];
++ __u32 uLinkFlags;
++ __u8 bSpinupRate;
++ __u8 bLinkReserved[7];
++ __u32 uVendorUnique[8];
++ CSMI_SAS_PHY_CONTROL Control[1];
++} CSMI_SAS_PHY_CONTROL_BUFFER,
++ *PCSMI_SAS_PHY_CONTROL_BUFFER;
++
++//EDM #pragma CSMI_SAS_END_PACK
++#pragma pack()
++
++#endif // _CSMI_SAS_H_
+--- a/drivers/message/fusion/Kconfig
++++ b/drivers/message/fusion/Kconfig
+@@ -61,13 +61,25 @@ config FUSION_SAS
+ LSISAS1078
+
+ config FUSION_MAX_SGE
+- int "Maximum number of scatter gather entries (16 - 128)"
++ int "Maximum number of scatter gather entries for SAS and SPI (16 - 128)"
+ default "128"
+ range 16 128
+ help
+ This option allows you to specify the maximum number of scatter-
+ gather entries per I/O. The driver default is 128, which matches
+- SCSI_MAX_PHYS_SEGMENTS. However, it may decreased down to 16.
++ SAFE_PHYS_SEGMENTS. However, it may decreased down to 16.
++ Decreasing this parameter will reduce memory requirements
++ on a per controller instance.
++
++config FUSION_MAX_FC_SGE
++ int "Maximum number of scatter gather entries for FC (16 - 256)"
++ depends on FUSION_FC
++ default "256"
++ range 16 256
++ help
++ This option allows you to specify the maximum number of scatter-
++ gather entries per I/O. The driver default is 256, which matches
++ MAX_PHYS_SEGMENTS. However, it may decreased down to 16.
+ Decreasing this parameter will reduce memory requirements
+ on a per controller instance.
+
+--- a/drivers/message/fusion/lsi/mpi_cnfg.h
++++ b/drivers/message/fusion/lsi/mpi_cnfg.h
+@@ -6,7 +6,7 @@
+ * Title: MPI Config message, structures, and Pages
+ * Creation Date: July 27, 2000
+ *
+- * mpi_cnfg.h Version: 01.05.15
++ * mpi_cnfg.h Version: 01.05.18
+ *
+ * Version History
+ * ---------------
+@@ -308,6 +308,20 @@
+ * Expander Page 0 Flags field.
+ * Fixed define for
+ * MPI_SAS_EXPANDER1_DISCINFO_BAD_PHY_DISABLED.
++ * 08-07-07 01.05.16 Added MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT
++ * define.
++ * Added BIOS Page 4 structure.
++ * Added MPI_RAID_PHYS_DISK1_PATH_MAX define for RAID
++ * Physcial Disk Page 1.
++ * 01-15-07 01.05.17 Added additional bit defines for ExtFlags field of
++ * Manufacturing Page 4.
++ * Added Solid State Drives Supported bit to IOC Page 6
++ * Capabilities Flags.
++ * Added new value for AccessStatus field of SAS Device
++ * Page 0 (_SATA_NEEDS_INITIALIZATION).
++ * 03-28-08 01.05.18 Defined new bits in Manufacturing Page 4 ExtFlags field
++ * to control coercion size and the mixing of SAS and SATA
++ * SSD drives.
+ * --------------------------------------------------------------------------
+ */
+
+@@ -686,6 +700,14 @@ typedef struct _CONFIG_PAGE_MANUFACTURIN
+ #define MPI_MANPAGE4_IR_NO_MIX_SAS_SATA (0x01)
+
+ /* defines for the ExtFlags field */
++#define MPI_MANPAGE4_EXTFLAGS_MASK_COERCION_SIZE (0x0180)
++#define MPI_MANPAGE4_EXTFLAGS_SHIFT_COERCION_SIZE (7)
++#define MPI_MANPAGE4_EXTFLAGS_1GB_COERCION_SIZE (0)
++#define MPI_MANPAGE4_EXTFLAGS_128MB_COERCION_SIZE (1)
++
++#define MPI_MANPAGE4_EXTFLAGS_NO_MIX_SSD_SAS_SATA (0x0040)
++#define MPI_MANPAGE4_EXTFLAGS_MIX_SSD_AND_NON_SSD (0x0020)
++#define MPI_MANPAGE4_EXTFLAGS_DUAL_PORT_SUPPORT (0x0010)
+ #define MPI_MANPAGE4_EXTFLAGS_HIDE_NON_IR_METADATA (0x0008)
+ #define MPI_MANPAGE4_EXTFLAGS_SAS_CACHE_DISABLE (0x0004)
+ #define MPI_MANPAGE4_EXTFLAGS_SATA_CACHE_DISABLE (0x0002)
+@@ -1159,6 +1181,8 @@ typedef struct _CONFIG_PAGE_IOC_6
+
+ /* IOC Page 6 Capabilities Flags */
+
++#define MPI_IOCPAGE6_CAP_FLAGS_SSD_SUPPORT (0x00000020)
++#define MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT (0x00000010)
+ #define MPI_IOCPAGE6_CAP_FLAGS_DISABLE_SMART_POLLING (0x00000008)
+
+ #define MPI_IOCPAGE6_CAP_FLAGS_MASK_METADATA_SIZE (0x00000006)
+@@ -1428,6 +1452,15 @@ typedef struct _CONFIG_PAGE_BIOS_2
+ #define MPI_BIOSPAGE2_FORM_SAS_WWN (0x05)
+ #define MPI_BIOSPAGE2_FORM_ENCLOSURE_SLOT (0x06)
+
++typedef struct _CONFIG_PAGE_BIOS_4
++{
++ CONFIG_PAGE_HEADER Header; /* 00h */
++ U64 ReassignmentBaseWWID; /* 04h */
++} CONFIG_PAGE_BIOS_4, MPI_POINTER PTR_CONFIG_PAGE_BIOS_4,
++ BIOSPage4_t, MPI_POINTER pBIOSPage4_t;
++
++#define MPI_BIOSPAGE4_PAGEVERSION (0x00)
++
+
+ /****************************************************************************
+ * SCSI Port Config Pages
+@@ -2419,6 +2452,15 @@ typedef struct _RAID_PHYS_DISK1_PATH
+ #define MPI_RAID_PHYSDISK1_FLAG_BROKEN (0x0002)
+ #define MPI_RAID_PHYSDISK1_FLAG_INVALID (0x0001)
+
++
++/*
++ * Host code (drivers, BIOS, utilities, etc.) should leave this define set to
++ * one and check Header.PageLength or NumPhysDiskPaths at runtime.
++ */
++#ifndef MPI_RAID_PHYS_DISK1_PATH_MAX
++#define MPI_RAID_PHYS_DISK1_PATH_MAX (1)
++#endif
++
+ typedef struct _CONFIG_PAGE_RAID_PHYS_DISK_1
+ {
+ CONFIG_PAGE_HEADER Header; /* 00h */
+@@ -2426,7 +2468,7 @@ typedef struct _CONFIG_PAGE_RAID_PHYS_DI
+ U8 PhysDiskNum; /* 05h */
+ U16 Reserved2; /* 06h */
+ U32 Reserved1; /* 08h */
+- RAID_PHYS_DISK1_PATH Path[1]; /* 0Ch */
++ RAID_PHYS_DISK1_PATH Path[MPI_RAID_PHYS_DISK1_PATH_MAX];/* 0Ch */
+ } CONFIG_PAGE_RAID_PHYS_DISK_1, MPI_POINTER PTR_CONFIG_PAGE_RAID_PHYS_DISK_1,
+ RaidPhysDiskPage1_t, MPI_POINTER pRaidPhysDiskPage1_t;
+
+@@ -2844,6 +2886,7 @@ typedef struct _CONFIG_PAGE_SAS_DEVICE_0
+ #define MPI_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED (0x01)
+ #define MPI_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED (0x02)
+ #define MPI_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT (0x03)
++#define MPI_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION (0x04)
+ /* specific values for SATA Init failures */
+ #define MPI_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN (0x10)
+ #define MPI_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT (0x11)
+--- a/drivers/message/fusion/lsi/mpi_fc.h
++++ b/drivers/message/fusion/lsi/mpi_fc.h
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2000-2004 LSI Corporation.
++ * Copyright (c) 2000-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_fc.h
+--- a/drivers/message/fusion/lsi/mpi.h
++++ b/drivers/message/fusion/lsi/mpi.h
+@@ -6,7 +6,7 @@
+ * Title: MPI Message independent structures and definitions
+ * Creation Date: July 27, 2000
+ *
+- * mpi.h Version: 01.05.13
++ * mpi.h Version: 01.05.16
+ *
+ * Version History
+ * ---------------
+@@ -79,6 +79,9 @@
+ * 03-27-06 01.05.11 Bumped MPI_HEADER_VERSION_UNIT.
+ * 10-11-06 01.05.12 Bumped MPI_HEADER_VERSION_UNIT.
+ * 05-24-07 01.05.13 Bumped MPI_HEADER_VERSION_UNIT.
++ * 08-07-07 01.05.14 Bumped MPI_HEADER_VERSION_UNIT.
++ * 01-15-08 01.05.15 Bumped MPI_HEADER_VERSION_UNIT.
++ * 03-28-08 01.05.16 Bumped MPI_HEADER_VERSION_UNIT.
+ * --------------------------------------------------------------------------
+ */
+
+@@ -109,7 +112,7 @@
+ /* Note: The major versions of 0xe0 through 0xff are reserved */
+
+ /* versioning for this MPI header set */
+-#define MPI_HEADER_VERSION_UNIT (0x10)
++#define MPI_HEADER_VERSION_UNIT (0x13)
+ #define MPI_HEADER_VERSION_DEV (0x00)
+ #define MPI_HEADER_VERSION_UNIT_MASK (0xFF00)
+ #define MPI_HEADER_VERSION_UNIT_SHIFT (8)
+--- a/drivers/message/fusion/lsi/mpi_history.txt
++++ b/drivers/message/fusion/lsi/mpi_history.txt
+@@ -3,28 +3,28 @@
+ MPI Header File Change History
+ ==============================
+
+- Copyright (c) 2000-2007 LSI Corporation.
++ Copyright (c) 2000-2008 LSI Corporation.
+
+ ---------------------------------------
+- Header Set Release Version: 01.05.16
+- Header Set Release Date: 05-24-07
++ Header Set Release Version: 01.05.19
++ Header Set Release Date: 03-28-08
+ ---------------------------------------
+
+ Filename Current version Prior version
+ ---------- --------------- -------------
+- mpi.h 01.05.13 01.05.12
+- mpi_ioc.h 01.05.14 01.05.13
+- mpi_cnfg.h 01.05.15 01.05.14
++ mpi.h 01.05.16 01.05.15
++ mpi_ioc.h 01.05.16 01.05.15
++ mpi_cnfg.h 01.05.18 01.05.17
+ mpi_init.h 01.05.09 01.05.09
+ mpi_targ.h 01.05.06 01.05.06
+ mpi_fc.h 01.05.01 01.05.01
+ mpi_lan.h 01.05.01 01.05.01
+- mpi_raid.h 01.05.03 01.05.03
++ mpi_raid.h 01.05.05 01.05.05
+ mpi_tool.h 01.05.03 01.05.03
+ mpi_inb.h 01.05.01 01.05.01
+- mpi_sas.h 01.05.04 01.05.04
++ mpi_sas.h 01.05.05 01.05.05
+ mpi_type.h 01.05.02 01.05.02
+- mpi_history.txt 01.05.14 01.05.14
++ mpi_history.txt 01.05.19 01.05.18
+
+
+ * Date Version Description
+@@ -96,6 +96,9 @@ mpi.h
+ * 03-27-06 01.05.11 Bumped MPI_HEADER_VERSION_UNIT.
+ * 10-11-06 01.05.12 Bumped MPI_HEADER_VERSION_UNIT.
+ * 05-24-07 01.05.13 Bumped MPI_HEADER_VERSION_UNIT.
++ * 08-07-07 01.05.14 Bumped MPI_HEADER_VERSION_UNIT.
++ * 01-15-08 01.05.15 Bumped MPI_HEADER_VERSION_UNIT.
++ * 03-28-08 01.05.16 Bumped MPI_HEADER_VERSION_UNIT.
+ * --------------------------------------------------------------------------
+
+ mpi_ioc.h
+@@ -127,7 +130,7 @@ mpi_ioc.h
+ * 08-08-01 01.02.01 Original release for v1.2 work.
+ * New format for FWVersion and ProductId in
+ * MSG_IOC_FACTS_REPLY and MPI_FW_HEADER.
+- * 08-31-01 01.02.02 Added event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
++ * 08-31-01 01.02.02 Addded event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
+ * related structure and defines.
+ * Added event MPI_EVENT_ON_BUS_TIMER_EXPIRED.
+ * Added MPI_IOCINIT_FLAGS_DISCARD_FW_IMAGE.
+@@ -187,7 +190,7 @@ mpi_ioc.h
+ * 10-11-06 01.05.12 Added MPI_IOCFACTS_EXCEPT_METADATA_UNSUPPORTED.
+ * Added MaxInitiators field to PortFacts reply.
+ * Added SAS Device Status Change ReasonCode for
+- * asynchronous notification.
++ * asynchronous notificaiton.
+ * Added MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE and event
+ * data structure.
+ * Added new ImageType values for FWDownload and FWUpload
+@@ -199,6 +202,16 @@ mpi_ioc.h
+ * added _MULTI_PORT_DOMAIN.
+ * 05-24-07 01.05.14 Added Common Boot Block type to FWDownload Request.
+ * Added Common Boot Block type to FWUpload Request.
++ * 08-07-07 01.05.15 Added MPI_EVENT_SAS_INIT_RC_REMOVED define.
++ * Added MPI_EVENT_IR2_RC_DUAL_PORT_ADDED and
++ * MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED for IR2 event data.
++ * Added SASAddress field to SAS Initiator Device Table
++ * Overflow event data structure.
++ * 03-28-08 01.05.16 Added two new ReasonCode values to SAS Device Status
++ * Change Event data to indicate completion of internally
++ * generated task management.
++ * Added MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE define.
++ * Added MPI_EVENT_SAS_INIT_RC_INACCESSIBLE define.
+ * --------------------------------------------------------------------------
+
+ mpi_cnfg.h
+@@ -213,7 +226,7 @@ mpi_cnfg.h
+ * Added _RESPONSE_ID_MASK definition to SCSI_PORT_1
+ * page and updated the page version.
+ * Added Information field and _INFO_PARAMS_NEGOTIATED
+- * definition to SCSI_DEVICE_0 page.
++ * definitionto SCSI_DEVICE_0 page.
+ * 06-22-00 01.00.03 Removed batch controls from LAN_0 page and updated the
+ * page version.
+ * Added BucketsRemaining to LAN_1 page, redefined the
+@@ -496,6 +509,20 @@ mpi_cnfg.h
+ * Expander Page 0 Flags field.
+ * Fixed define for
+ * MPI_SAS_EXPANDER1_DISCINFO_BAD_PHY_DISABLED.
++ * 08-07-07 01.05.16 Added MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT
++ * define.
++ * Added BIOS Page 4 structure.
++ * Added MPI_RAID_PHYS_DISK1_PATH_MAX define for RAID
++ * Physcial Disk Page 1.
++ * 01-15-07 01.05.17 Added additional bit defines for ExtFlags field of
++ * Manufacturing Page 4.
++ * Added Solid State Drives Supported bit to IOC Page 6
++ * Capabilities Flags.
++ * Added new value for AccessStatus field of SAS Device
++ * Page 0 (_SATA_NEEDS_INITIALIZATION).
++ * 03-28-08 01.05.18 Defined new bits in Manufacturing Page 4 ExtFlags field
++ * to control coercion size and the mixing of SAS and SATA
++ * SSD drives.
+ * --------------------------------------------------------------------------
+
+ mpi_init.h
+@@ -661,6 +688,9 @@ mpi_raid.h
+ * _SET_RESYNC_RATE and _SET_DATA_SCRUB_RATE.
+ * 02-28-07 01.05.03 Added new RAID Action, Device FW Update Mode, and
+ * associated defines.
++ * 08-07-07 01.05.04 Added Disable Full Rebuild bit to the ActionDataWord
++ * for the RAID Action MPI_RAID_ACTION_DISABLE_VOLUME.
++ * 01-15-08 01.05.05 Added define for MPI_RAID_ACTION_SET_VOLUME_NAME.
+ * --------------------------------------------------------------------------
+
+ mpi_tool.h
+@@ -694,6 +724,10 @@ mpi_sas.h
+ * reply.
+ * 10-11-06 01.05.04 Fixed the name of a define for Operation field of SAS IO
+ * Unit Control request.
++ * 01-15-08 01.05.05 Added support for MPI_SAS_OP_SET_IOC_PARAMETER,
++ * including adding IOCParameter and IOCParameter value
++ * fields to SAS IO Unit Control Request.
++ * Added MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC define.
+ * --------------------------------------------------------------------------
+
+ mpi_type.h
+@@ -709,20 +743,20 @@ mpi_type.h
+
+ mpi_history.txt Parts list history
+
+-Filename 01.05.15 01.05.15
+----------- -------- --------
+-mpi.h 01.05.12 01.05.13
+-mpi_ioc.h 01.05.13 01.05.14
+-mpi_cnfg.h 01.05.14 01.05.15
+-mpi_init.h 01.05.09 01.05.09
+-mpi_targ.h 01.05.06 01.05.06
+-mpi_fc.h 01.05.01 01.05.01
+-mpi_lan.h 01.05.01 01.05.01
+-mpi_raid.h 01.05.03 01.05.03
+-mpi_tool.h 01.05.03 01.05.03
+-mpi_inb.h 01.05.01 01.05.01
+-mpi_sas.h 01.05.04 01.05.04
+-mpi_type.h 01.05.02 01.05.02
++Filename 01.05.19 01.05.18 01.05.17 01.05.16 01.05.15
++---------- -------- -------- -------- -------- --------
++mpi.h 01.05.16 01.05.15 01.05.14 01.05.13 01.05.12
++mpi_ioc.h 01.05.16 01.05.15 01.05.15 01.05.14 01.05.13
++mpi_cnfg.h 01.05.18 01.05.17 01.05.16 01.05.15 01.05.14
++mpi_init.h 01.05.09 01.05.09 01.05.09 01.05.09 01.05.09
++mpi_targ.h 01.05.06 01.05.06 01.05.06 01.05.06 01.05.06
++mpi_fc.h 01.05.01 01.05.01 01.05.01 01.05.01 01.05.01
++mpi_lan.h 01.05.01 01.05.01 01.05.01 01.05.01 01.05.01
++mpi_raid.h 01.05.05 01.05.05 01.05.04 01.05.03 01.05.03
++mpi_tool.h 01.05.03 01.05.03 01.05.03 01.05.03 01.05.03
++mpi_inb.h 01.05.01 01.05.01 01.05.01 01.05.01 01.05.01
++mpi_sas.h 01.05.05 01.05.05 01.05.04 01.05.04 01.05.04
++mpi_type.h 01.05.02 01.05.02 01.05.02 01.05.02 01.05.02
+
+ Filename 01.05.14 01.05.13 01.05.12 01.05.11 01.05.10 01.05.09
+ ---------- -------- -------- -------- -------- -------- --------
+--- a/drivers/message/fusion/lsi/mpi_init.h
++++ b/drivers/message/fusion/lsi/mpi_init.h
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2000-2007 LSI Corporation.
++ * Copyright (c) 2000-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_init.h
+--- a/drivers/message/fusion/lsi/mpi_ioc.h
++++ b/drivers/message/fusion/lsi/mpi_ioc.h
+@@ -1,12 +1,12 @@
+ /*
+- * Copyright (c) 2000-2007 LSI Corporation.
++ * Copyright (c) 2000-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_ioc.h
+ * Title: MPI IOC, Port, Event, FW Download, and FW Upload messages
+ * Creation Date: August 11, 2000
+ *
+- * mpi_ioc.h Version: 01.05.14
++ * mpi_ioc.h Version: 01.05.16
+ *
+ * Version History
+ * ---------------
+@@ -113,6 +113,16 @@
+ * added _MULTI_PORT_DOMAIN.
+ * 05-24-07 01.05.14 Added Common Boot Block type to FWDownload Request.
+ * Added Common Boot Block type to FWUpload Request.
++ * 08-07-07 01.05.15 Added MPI_EVENT_SAS_INIT_RC_REMOVED define.
++ * Added MPI_EVENT_IR2_RC_DUAL_PORT_ADDED and
++ * MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED for IR2 event data.
++ * Added SASAddress field to SAS Initiator Device Table
++ * Overflow event data structure.
++ * 03-28-08 01.05.16 Added two new ReasonCode values to SAS Device Status
++ * Change Event data to indicate completion of internally
++ * generated task management.
++ * Added MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE define.
++ * Added MPI_EVENT_SAS_INIT_RC_INACCESSIBLE define.
+ * --------------------------------------------------------------------------
+ */
+
+@@ -612,6 +622,8 @@ typedef struct _EVENT_DATA_SAS_DEVICE_ST
+ #define MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL (0x0B)
+ #define MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL (0x0C)
+ #define MPI_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION (0x0D)
++#define MPI_EVENT_SAS_DEV_STAT_RC_CMPL_INTERNAL_DEV_RESET (0x0E)
++#define MPI_EVENT_SAS_DEV_STAT_RC_CMPL_TASK_ABORT_INTERNAL (0x0F)
+
+
+ /* SCSI Event data for Queue Full event */
+@@ -708,6 +720,8 @@ typedef struct _MPI_EVENT_DATA_IR2
+ #define MPI_EVENT_IR2_RC_PD_REMOVED (0x05)
+ #define MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED (0x06)
+ #define MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR (0x07)
++#define MPI_EVENT_IR2_RC_DUAL_PORT_ADDED (0x08)
++#define MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED (0x09)
+
+ /* defines for logical disk states */
+ #define MPI_LD_STATE_OPTIMAL (0x00)
+@@ -867,6 +881,7 @@ typedef struct _EVENT_DATA_DISCOVERY_ERR
+ #define MPI_EVENT_DSCVRY_ERR_DS_UNSUPPORTED_DEVICE (0x00000800)
+ #define MPI_EVENT_DSCVRY_ERR_DS_MAX_SATA_TARGETS (0x00001000)
+ #define MPI_EVENT_DSCVRY_ERR_DS_MULTI_PORT_DOMAIN (0x00002000)
++#define MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE (0x00004000)
+
+ /* SAS SMP Error Event data */
+
+@@ -902,6 +917,8 @@ typedef struct _EVENT_DATA_SAS_INIT_DEV_
+
+ /* defines for the ReasonCode field of the SAS Initiator Device Status Change event */
+ #define MPI_EVENT_SAS_INIT_RC_ADDED (0x01)
++#define MPI_EVENT_SAS_INIT_RC_REMOVED (0x02)
++#define MPI_EVENT_SAS_INIT_RC_INACCESSIBLE (0x03)
+
+ /* SAS Initiator Device Table Overflow Event data */
+
+@@ -910,6 +927,7 @@ typedef struct _EVENT_DATA_SAS_INIT_TABL
+ U8 MaxInit; /* 00h */
+ U8 CurrentInit; /* 01h */
+ U16 Reserved1; /* 02h */
++ U64 SASAddress; /* 04h */
+ } EVENT_DATA_SAS_INIT_TABLE_OVERFLOW,
+ MPI_POINTER PTR_EVENT_DATA_SAS_INIT_TABLE_OVERFLOW,
+ MpiEventDataSasInitTableOverflow_t,
+--- a/drivers/message/fusion/lsi/mpi_lan.h
++++ b/drivers/message/fusion/lsi/mpi_lan.h
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2000-2004 LSI Corporation.
++ * Copyright (c) 2000-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_lan.h
+--- a/drivers/message/fusion/lsi/mpi_log_fc.h
++++ b/drivers/message/fusion/lsi/mpi_log_fc.h
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2000-2001 LSI Corporation. All rights reserved.
++ * Copyright (c) 2000-2008 LSI Corporation. All rights reserved.
+ *
+ * NAME: fc_log.h
+ * SUMMARY: MPI IocLogInfo definitions for the SYMFC9xx chips
+--- a/drivers/message/fusion/lsi/mpi_log_sas.h
++++ b/drivers/message/fusion/lsi/mpi_log_sas.h
+@@ -1,6 +1,6 @@
+ /***************************************************************************
+ * *
+- * Copyright 2003 LSI Corporation. All rights reserved. *
++ * Copyright (c) 2000-2008 LSI Corporation. All rights reserved. *
+ * *
+ * Description *
+ * ------------ *
+@@ -73,6 +73,8 @@
+ #define IOP_LOGINFO_CODE_TARGET_MODE_ABORT_EXACT_IO (0x00070004)
+ #define IOP_LOGINFO_CODE_TARGET_MODE_ABORT_EXACT_IO_REQ (0x00070005)
+
++#define IOP_LOGINFO_CODE_LOG_TIMESTAMP_EVENT (0x00080000)
++
+ /****************************************************************************/
+ /* PL LOGINFO_CODE defines, valid if IOC_LOGINFO_ORIGINATOR = PL */
+ /****************************************************************************/
+@@ -92,7 +94,7 @@
+ #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_OPEN_TIMEOUT_EXP (0x0000000C)
+ #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_UNUSED_0D (0x0000000D)
+ #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_DVTBLE_ACCSS_FAIL (0x0000000E)
+-#define PL_LOGINFO_SUB CODE_OPEN_FAIL_BAD_DEST (0x00000011)
++#define PL_LOGINFO_SUB_CODE_OPEN_FAIL_BAD_DEST (0x00000011)
+ #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_RATE_NOT_SUPP (0x00000012)
+ #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_PROT_NOT_SUPP (0x00000013)
+ #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_RESERVED_ABANDON0 (0x00000014)
+@@ -162,7 +164,7 @@
+ #define PL_LOGINFO_SUB_CODE_FRAME_XFER_ERROR (0x00000400) /* Bits 0-3 encode Transport Status Register (offset 0x08) */
+ /* Bit 0 is Status Bit 0: FrameXferErr */
+ /* Bit 1 & 2 are Status Bits 16 and 17: FrameXmitErrStatus */
+- /* Bit 3 is Status Bit 18 WriteDataLengthGTDataLengthErr */
++ /* Bit 3 is Status Bit 18 WriteDataLenghtGTDataLengthErr */
+
+ #define PL_LOGINFO_SUB_CODE_TX_FM_CONNECTED_LOW (0x00000500)
+ #define PL_LOGINFO_SUB_CODE_SATA_NON_NCQ_RW_ERR_BIT_SET (0x00000600)
+@@ -177,6 +179,10 @@
+ #define PL_LOGINFO_SUB_CODE_DISCOVERY_REMOTE_SEP_RESET (0x00000E01)
+ #define PL_LOGINFO_SUB_CODE_SECOND_OPEN (0x00000F00)
+ #define PL_LOGINFO_SUB_CODE_DSCVRY_SATA_INIT_TIMEOUT (0x00001000)
++#define PL_LOGINFO_SUB_CODE_BREAK_ON_SATA_CONNECTION (0x00002000) /* not currently used in mainline */
++#define PL_LOGINFO_SUB_CODE_BREAK_ON_STUCK_LINK (0x00003000)
++#define PL_LOGINFO_SUB_CODE_BREAK_ON_STUCK_LINK_AIP (0x00004000)
++#define PL_LOGINFO_SUB_CODE_BREAK_ON_INCOMPLETE_BREAK_RCVD (0x00005000)
+
+ #define PL_LOGINFO_CODE_ENCL_MGMT_SMP_FRAME_FAILURE (0x00200000) /* Can't get SMP Frame */
+ #define PL_LOGINFO_CODE_ENCL_MGMT_SMP_READ_ERROR (0x00200010) /* Error occured on SMP Read */
+@@ -243,6 +249,8 @@
+ #define IR_LOGINFO_VOLUME_ACTIVATE_VOLUME_FAILED (0x00010014)
+ /* Activation failed trying to import the volume */
+ #define IR_LOGINFO_VOLUME_ACTIVATING_IMPORT_VOLUME_FAILED (0x00010015)
++/* Activation failed trying to import the volume */
++#define IR_LOGINFO_VOLUME_ACTIVATING_TOO_MANY_PHYS_DISKS (0x00010016)
+
+ /* Phys Disk failed, too many phys disks */
+ #define IR_LOGINFO_PHYSDISK_CREATE_TOO_MANY_DISKS (0x00010020)
+@@ -285,6 +293,23 @@
+ /* Compatibility Error : IME size limited to < 2TB */
+ #define IR_LOGINFO_COMPAT_ERROR_IME_VOL_NOT_CURRENTLY_SUPPORTED (0x0001003D)
+
++/* Device Firmware Update: DFU can only be started once */
++#define IR_LOGINFO_DEV_FW_UPDATE_ERR_DFU_IN_PROGRESS (0x00010050)
++/* Device Firmware Update: Volume must be Optimal/Active/non-Quiesced */
++#define IR_LOGINFO_DEV_FW_UPDATE_ERR_DEVICE_IN_INVALID_STATE (0x00010051)
++/* Device Firmware Update: DFU Timeout cannot be zero */
++#define IR_LOGINFO_DEV_FW_UPDATE_ERR_INVALID_TIMEOUT (0x00010052)
++/* Device Firmware Update: CREATE TIMER FAILED */
++#define IR_LOGINFO_DEV_FW_UPDATE_ERR_NO_TIMERS (0x00010053)
++/* Device Firmware Update: Failed to read SAS_IO_UNIT_PG_1 */
++#define IR_LOGINFO_DEV_FW_UPDATE_ERR_READING_CFG_PAGE (0x00010054)
++/* Device Firmware Update: Invalid SAS_IO_UNIT_PG_1 value(s) */
++#define IR_LOGINFO_DEV_FW_UPDATE_ERR_PORT_IO_TIMEOUTS_REQUIRED (0x00010055)
++/* Device Firmware Update: Unable to allocate memory for page */
++#define IR_LOGINFO_DEV_FW_UPDATE_ERR_ALLOC_CFG_PAGE (0x00010056)
++/* Device Firmware Update: */
++//#define IR_LOGINFO_DEV_FW_UPDATE_ERR_ (0x00010054)
++
+
+ /****************************************************************************/
+ /* Defines for convenience */
+--- a/drivers/message/fusion/lsi/mpi_raid.h
++++ b/drivers/message/fusion/lsi/mpi_raid.h
+@@ -1,12 +1,12 @@
+ /*
+- * Copyright (c) 2001-2007 LSI Corporation.
++ * Copyright (c) 2001-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_raid.h
+ * Title: MPI RAID message and structures
+ * Creation Date: February 27, 2001
+ *
+- * mpi_raid.h Version: 01.05.03
++ * mpi_raid.h Version: 01.05.05
+ *
+ * Version History
+ * ---------------
+@@ -34,6 +34,9 @@
+ * _SET_RESYNC_RATE and _SET_DATA_SCRUB_RATE.
+ * 02-28-07 01.05.03 Added new RAID Action, Device FW Update Mode, and
+ * associated defines.
++ * 08-07-07 01.05.04 Added Disable Full Rebuild bit to the ActionDataWord
++ * for the RAID Action MPI_RAID_ACTION_DISABLE_VOLUME.
++ * 01-15-08 01.05.05 Added define for MPI_RAID_ACTION_SET_VOLUME_NAME.
+ * --------------------------------------------------------------------------
+ */
+
+@@ -93,6 +96,7 @@ typedef struct _MSG_RAID_ACTION
+ #define MPI_RAID_ACTION_SET_RESYNC_RATE (0x13)
+ #define MPI_RAID_ACTION_SET_DATA_SCRUB_RATE (0x14)
+ #define MPI_RAID_ACTION_DEVICE_FW_UPDATE_MODE (0x15)
++#define MPI_RAID_ACTION_SET_VOLUME_NAME (0x16)
+
+ /* ActionDataWord defines for use with MPI_RAID_ACTION_CREATE_VOLUME action */
+ #define MPI_RAID_ACTION_ADATA_DO_NOT_SYNC (0x00000001)
+@@ -105,6 +109,9 @@ typedef struct _MSG_RAID_ACTION
+ #define MPI_RAID_ACTION_ADATA_KEEP_LBA0 (0x00000000)
+ #define MPI_RAID_ACTION_ADATA_ZERO_LBA0 (0x00000002)
+
++/* ActionDataWord defines for use with MPI_RAID_ACTION_DISABLE_VOLUME action */
++#define MPI_RAID_ACTION_ADATA_DISABLE_FULL_REBUILD (0x00000001)
++
+ /* ActionDataWord defines for use with MPI_RAID_ACTION_ACTIVATE_VOLUME action */
+ #define MPI_RAID_ACTION_ADATA_INACTIVATE_ALL (0x00000001)
+
+--- a/drivers/message/fusion/lsi/mpi_sas.h
++++ b/drivers/message/fusion/lsi/mpi_sas.h
+@@ -1,12 +1,12 @@
+ /*
+- * Copyright (c) 2004-2006 LSI Corporation.
++ * Copyright (c) 2004-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_sas.h
+ * Title: MPI Serial Attached SCSI structures and definitions
+ * Creation Date: August 19, 2004
+ *
+- * mpi_sas.h Version: 01.05.04
++ * mpi_sas.h Version: 01.05.05
+ *
+ * Version History
+ * ---------------
+@@ -23,6 +23,10 @@
+ * reply.
+ * 10-11-06 01.05.04 Fixed the name of a define for Operation field of SAS IO
+ * Unit Control request.
++ * 01-15-08 01.05.05 Added support for MPI_SAS_OP_SET_IOC_PARAMETER,
++ * including adding IOCParameter and IOCParameter value
++ * fields to SAS IO Unit Control Request.
++ * Added MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC define.
+ * --------------------------------------------------------------------------
+ */
+
+@@ -60,6 +64,8 @@
+ * Values for the SAS DeviceInfo field used in SAS Device Status Change Event
+ * data and SAS IO Unit Configuration pages.
+ */
++#define MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC (0xF0000000)
++
+ #define MPI_SAS_DEVICE_INFO_SEP (0x00004000)
+ #define MPI_SAS_DEVICE_INFO_ATAPI_DEVICE (0x00002000)
+ #define MPI_SAS_DEVICE_INFO_LSI_DEVICE (0x00001000)
+@@ -216,7 +222,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
+ U8 ChainOffset; /* 02h */
+ U8 Function; /* 03h */
+ U16 DevHandle; /* 04h */
+- U8 Reserved3; /* 06h */
++ U8 IOCParameter; /* 06h */
+ U8 MsgFlags; /* 07h */
+ U32 MsgContext; /* 08h */
+ U8 TargetID; /* 0Ch */
+@@ -225,7 +231,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
+ U8 PrimFlags; /* 0Fh */
+ U32 Primitive; /* 10h */
+ U64 SASAddress; /* 14h */
+- U32 Reserved4; /* 1Ch */
++ U32 IOCParameterValue; /* 1Ch */
+ } MSG_SAS_IOUNIT_CONTROL_REQUEST, MPI_POINTER PTR_MSG_SAS_IOUNIT_CONTROL_REQUEST,
+ SasIoUnitControlRequest_t, MPI_POINTER pSasIoUnitControlRequest_t;
+
+@@ -241,6 +247,8 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
+ #define MPI_SAS_OP_TRANSMIT_PORT_SELECT_SIGNAL (0x0C)
+ #define MPI_SAS_OP_TRANSMIT_REMOVE_DEVICE (0x0D) /* obsolete name */
+ #define MPI_SAS_OP_REMOVE_DEVICE (0x0D)
++#define MPI_SAS_OP_SET_IOC_PARAMETER (0x0E)
++#define MPI_SAS_OP_PRODUCT_SPECIFIC_MIN (0x80)
+
+ /* values for the PrimFlags field */
+ #define MPI_SAS_PRIMFLAGS_SINGLE (0x08)
+@@ -256,7 +264,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
+ U8 MsgLength; /* 02h */
+ U8 Function; /* 03h */
+ U16 DevHandle; /* 04h */
+- U8 Reserved3; /* 06h */
++ U8 IOCParameter; /* 06h */
+ U8 MsgFlags; /* 07h */
+ U32 MsgContext; /* 08h */
+ U16 Reserved4; /* 0Ch */
+--- a/drivers/message/fusion/lsi/mpi_targ.h
++++ b/drivers/message/fusion/lsi/mpi_targ.h
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2000-2004 LSI Corporation.
++ * Copyright (c) 2000-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_targ.h
+--- a/drivers/message/fusion/lsi/mpi_tool.h
++++ b/drivers/message/fusion/lsi/mpi_tool.h
+@@ -1,5 +1,5 @@
+ /*
+- * Copyright (c) 2001-2005 LSI Corporation.
++ * Copyright (c) 2001-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_tool.h
+--- a/drivers/message/fusion/lsi/mpi_type.h
++++ b/drivers/message/fusion/lsi/mpi_type.h
+@@ -1,12 +1,12 @@
+ /*
+- * Copyright (c) 2000-2004 LSI Corporation.
++ * Copyright (c) 2000-2008 LSI Corporation.
+ *
+ *
+ * Name: mpi_type.h
+ * Title: MPI Basic type definitions
+ * Creation Date: June 6, 2000
+ *
+- * mpi_type.h Version: 01.05.01
++ * mpi_type.h Version: 01.05.02
+ *
+ * Version History
+ * ---------------
+@@ -20,6 +20,7 @@
+ * 08-08-01 01.02.01 Original release for v1.2 work.
+ * 05-11-04 01.03.01 Original release for MPI v1.3.
+ * 08-19-04 01.05.01 Original release for MPI v1.5.
++ * 08-30-05 01.05.02 Added PowerPC option to #ifdef's.
+ * --------------------------------------------------------------------------
+ */
+
+@@ -49,8 +50,18 @@ typedef signed short S16;
+ typedef unsigned short U16;
+
+
+-typedef int32_t S32;
+-typedef u_int32_t U32;
++#if defined(unix) || defined(__arm) || defined(ALPHA) || defined(__PPC__) || defined(__ppc)
++
++ typedef signed int S32;
++ typedef unsigned int U32;
++
++#else
++
++ typedef signed long S32;
++ typedef unsigned long U32;
++
++#endif
++
+
+ typedef struct _S64
+ {
+--- a/drivers/message/fusion/Makefile
++++ b/drivers/message/fusion/Makefile
+@@ -1,12 +1,17 @@
+-# Fusion MPT drivers; recognized debug defines...
++#
++# LSI mpt fusion
++#
++
++# csmi ioctls enable
++EXTRA_CFLAGS += -DCPQ_CIM
++EXTRA_CFLAGS += -DDIAG_BUFFER_SUPPORT
++
++EXTRA_CFLAGS += -DCONFIG_FUSION_LOGGING
+
+ # enable verbose logging
+ # CONFIG_FUSION_LOGGING needs to be enabled in Kconfig
+ #EXTRA_CFLAGS += -DMPT_DEBUG_VERBOSE
+
+-
+-#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-} LSI_LOGIC
+-
+ obj-$(CONFIG_FUSION_SPI) += mptbase.o mptscsih.o mptspi.o
+ obj-$(CONFIG_FUSION_FC) += mptbase.o mptscsih.o mptfc.o
+ obj-$(CONFIG_FUSION_SAS) += mptbase.o mptscsih.o mptsas.o
+--- a/drivers/message/fusion/mptbase.c
++++ b/drivers/message/fusion/mptbase.c
+@@ -58,6 +58,7 @@
+ #include <linux/delay.h>
+ #include <linux/interrupt.h> /* needed for in_interrupt() proto */
+ #include <linux/dma-mapping.h>
++#include <linux/sort.h>
+ #include <asm/io.h>
+ #ifdef CONFIG_MTRR
+ #include <asm/mtrr.h>
+@@ -79,19 +80,38 @@ MODULE_VERSION(my_VERSION);
+ /*
+ * cmd line parameters
+ */
+-static int mpt_msi_enable = -1;
+-module_param(mpt_msi_enable, int, 0);
+-MODULE_PARM_DESC(mpt_msi_enable, " MSI Support Enable (default=0)");
++
++static int mpt_msi_enable_spi;
++module_param(mpt_msi_enable_spi, int, 0);
++MODULE_PARM_DESC(mpt_msi_enable_spi, " Enable MSI Support for SPI controllers (default=0)");
++
++static int mpt_msi_enable_fc;
++module_param(mpt_msi_enable_fc, int, 0);
++MODULE_PARM_DESC(mpt_msi_enable_fc, " Enable MSI Support for FC controllers (default=0)");
++
++static int mpt_msi_enable_sas = 1;
++module_param(mpt_msi_enable_sas, int, 0);
++MODULE_PARM_DESC(mpt_msi_enable_sas, " Enable MSI Support for SAS controllers (default=1)");
++
+
+ static int mpt_channel_mapping;
+ module_param(mpt_channel_mapping, int, 0);
+ MODULE_PARM_DESC(mpt_channel_mapping, " Mapping id's to channels (default=0)");
+
+-static int mpt_debug_level;
++int mpt_debug_level;
+ static int mpt_set_debug_level(const char *val, struct kernel_param *kp);
+ module_param_call(mpt_debug_level, mpt_set_debug_level, param_get_int,
+ &mpt_debug_level, 0600);
+ MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h - (default=0)");
++EXPORT_SYMBOL(mpt_debug_level);
++
++int mpt_fwfault_debug;
++module_param_call(mpt_fwfault_debug, param_set_int, param_get_int,
++ &mpt_fwfault_debug, 0600);
++MODULE_PARM_DESC(mpt_fwfault_debug, "Enable detection of Firmware fault"
++ " and halt Firmware on fault - (default=0)");
++EXPORT_SYMBOL(mpt_fwfault_debug);
++
+
+ #ifdef MFCNT
+ static int mfcounter = 0;
+@@ -102,8 +122,7 @@ static int mfcounter = 0;
+ /*
+ * Public data...
+ */
+-
+-static struct proc_dir_entry *mpt_proc_root_dir;
++struct proc_dir_entry *mpt_proc_root_dir;
+
+ #define WHOINIT_UNKNOWN 0xAA
+
+@@ -125,6 +144,8 @@ static struct mpt_pci_driver *MptDevice
+
+ static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
+
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++
+ /*
+ * Driver Callback Index's
+ */
+@@ -135,8 +156,7 @@ static u8 last_drv_idx;
+ /*
+ * Forward protos...
+ */
+-static irqreturn_t mpt_interrupt(int irq, void *bus_id);
+-static int mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
++static int mptbase_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
+ static int mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
+ u32 *req, int replyBytes, u16 *u16reply, int maxwait,
+ int sleepFlag);
+@@ -167,9 +187,8 @@ static int mpt_GetScsiPortSettings(MPT_A
+ static int mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
+ static void mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
+ static void mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
+-static void mpt_timer_expired(unsigned long data);
+ static void mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc);
+-static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
++static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch, int sleepFlag);
+ static int SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
+ static int mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
+ static int mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
+@@ -184,7 +203,6 @@ static int procmpt_iocinfo_read(char *bu
+ #endif
+ static void mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
+
+-//int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
+ static int ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
+ static void mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
+ static void mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
+@@ -193,6 +211,7 @@ static void mpt_sas_log_info(MPT_ADAPTER
+ static int mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
+ static void mpt_inactive_raid_list_free(MPT_ADAPTER *ioc);
+
++
+ /* module entry point */
+ static int __init fusion_init (void);
+ static void __exit fusion_exit (void);
+@@ -223,7 +242,16 @@ pci_enable_io_access(struct pci_dev *pde
+ pci_write_config_word(pdev, PCI_COMMAND, command_reg);
+ }
+
+-static int mpt_set_debug_level(const char *val, struct kernel_param *kp)
++/**
++ * mpt_set_debug_level - global setting of the mpt_debug_level
++ * found via /sys/module/mptbase/parameters/mpt_debug_level
++ * @val:
++ * @kp:
++ *
++ * Returns
++ **/
++static int
++mpt_set_debug_level(const char *val, struct kernel_param *kp)
+ {
+ int ret = param_set_int(val, kp);
+ MPT_ADAPTER *ioc;
+@@ -254,6 +282,56 @@ mpt_get_cb_idx(MPT_DRIVER_CLASS dclass)
+ }
+
+ /**
++ * mpt_is_discovery_complete - determine if discovery has completed
++ * @ioc: per adatper instance
++ *
++ * Returns 1 when discovery completed, else zero.
++ */
++static int
++mpt_is_discovery_complete(MPT_ADAPTER *ioc)
++{
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ SasIOUnitPage0_t *buffer;
++ dma_addr_t dma_handle;
++ int rc = 0;
++
++ memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
++ memset(&cfg, 0, sizeof(CONFIGPARMS));
++ hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++
++ if ((mpt_config(ioc, &cfg)))
++ goto out;
++ if (!hdr.ExtPageLength)
++ goto out;
++
++ buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
++ &dma_handle);
++ if (!buffer)
++ goto out;
++
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ if ((mpt_config(ioc, &cfg)))
++ goto out_free_consistent;
++
++ if (!(buffer->PhyData[0].PortFlags &
++ MPI_SAS_IOUNIT0_PORT_FLAGS_DISCOVERY_IN_PROGRESS))
++ rc = 1;
++
++ out_free_consistent:
++ pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
++ buffer, dma_handle);
++ out:
++ return rc;
++}
++
++/**
+ * mpt_fault_reset_work - work performed on workq after ioc fault
+ * @work: input argument, used to derive ioc
+ *
+@@ -267,23 +345,29 @@ mpt_fault_reset_work(struct work_struct
+ int rc;
+ unsigned long flags;
+
+- if (ioc->diagPending || !ioc->active)
++ if (ioc->ioc_reset_in_progress || !ioc->active)
+ goto out;
+
+ ioc_raw_state = mpt_GetIocState(ioc, 0);
+ if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
+ printk(MYIOC_s_WARN_FMT "IOC is in FAULT state (%04xh)!!!\n",
+- ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
++ ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
+ printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
+- ioc->name, __func__);
++ ioc->name, __FUNCTION__);
+ rc = mpt_HardResetHandler(ioc, CAN_SLEEP);
+ printk(MYIOC_s_WARN_FMT "%s: HardReset: %s\n", ioc->name,
+- __func__, (rc == 0) ? "success" : "failed");
++ __FUNCTION__, (rc == 0) ? "success" : "failed");
+ ioc_raw_state = mpt_GetIocState(ioc, 0);
+ if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT)
+ printk(MYIOC_s_WARN_FMT "IOC is in FAULT state after "
+ "reset (%04xh)\n", ioc->name, ioc_raw_state &
+ MPI_DOORBELL_DATA_MASK);
++ } else if (ioc->bus_type == SAS && ioc->sas_discovery_quiesce_io) {
++ if ((mpt_is_discovery_complete(ioc))) {
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "clearing "
++ "discovery_quiesce_io flag\n", ioc->name));
++ ioc->sas_discovery_quiesce_io = 0;
++ }
+ }
+
+ out:
+@@ -294,14 +378,13 @@ mpt_fault_reset_work(struct work_struct
+ ioc = ioc->alt_ioc;
+
+ /* rearm the timer */
+- spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
+ if (ioc->reset_work_q)
+ queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
+ msecs_to_jiffies(MPT_POLLING_INTERVAL));
+- spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+ }
+
+-
+ /*
+ * Process turbo (context) reply...
+ */
+@@ -354,9 +437,9 @@ mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa
+
+ /* Check for (valid) IO callback! */
+ if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
+- MptCallbacks[cb_idx] == NULL) {
++ MptCallbacks[cb_idx] == NULL) {
+ printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
+- __func__, ioc->name, cb_idx);
++ __FUNCTION__, ioc->name, cb_idx);
+ goto out;
+ }
+
+@@ -398,6 +481,7 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
+
+ dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
+ ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
++
+ DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mr);
+
+ /* Check/log IOC log info
+@@ -413,14 +497,17 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
+ mpt_sas_log_info(ioc, log_info);
+ }
+
++ /* TODO - add shost_attrs, or command line option, and
++ * extend this to SAS/FC
++ */
+ if (ioc_stat & MPI_IOCSTATUS_MASK)
+ mpt_iocstatus_info(ioc, (u32)ioc_stat, mf);
+
+ /* Check for (valid) IO callback! */
+ if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
+- MptCallbacks[cb_idx] == NULL) {
++ MptCallbacks[cb_idx] == NULL) {
+ printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
+- __func__, ioc->name, cb_idx);
++ __FUNCTION__, ioc->name, cb_idx);
+ freeme = 0;
+ goto out;
+ }
+@@ -436,11 +523,11 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
+ mb();
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
+ * @irq: irq number (not used)
+ * @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
++ * @r: pt_regs pointer (not used)
+ *
+ * This routine is registered via the request_irq() kernel API call,
+ * and handles all interrupts generated from a specific MPT adapter
+@@ -452,7 +539,7 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
+ * This routine handles register-level access of the adapter but
+ * dispatches (calls) a protocol-specific callback routine to handle
+ * the protocol-specific details of the MPT request completion.
+- */
++ **/
+ static irqreturn_t
+ mpt_interrupt(int irq, void *bus_id)
+ {
+@@ -478,9 +565,9 @@ mpt_interrupt(int irq, void *bus_id)
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mpt_base_reply - MPT base driver's callback routine
++ * mptbase_reply - MPT base driver's callback routine
+ * @ioc: Pointer to MPT_ADAPTER structure
+- * @mf: Pointer to original MPT request frame
++ * @req: Pointer to original MPT request frame
+ * @reply: Pointer to MPT reply frame (NULL if TurboReply)
+ *
+ * MPT base driver's callback routine; all base driver
+@@ -491,122 +578,49 @@ mpt_interrupt(int irq, void *bus_id)
+ * should be freed, or 0 if it shouldn't.
+ */
+ static int
+-mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
++mptbase_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
+ {
++ EventNotificationReply_t *pEventReply;
++ u8 event;
++ int evHandlers;
+ int freereq = 1;
+- u8 func;
+-
+- dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply() called\n", ioc->name));
+-#ifdef CONFIG_FUSION_LOGGING
+- if ((ioc->debug_level & MPT_DEBUG_MSG_FRAME) &&
+- !(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
+- dmfprintk(ioc, printk(MYIOC_s_INFO_FMT ": Original request frame (@%p) header\n",
+- ioc->name, mf));
+- DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)mf);
+- }
+-#endif
+-
+- func = reply->u.hdr.Function;
+- dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, Function=%02Xh\n",
+- ioc->name, func));
+-
+- if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
+- EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
+- int evHandlers = 0;
+- int results;
+-
+- results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
+- if (results != evHandlers) {
+- /* CHECKME! Any special handling needed here? */
+- devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
+- ioc->name, evHandlers, results));
+- }
+
+- /*
+- * Hmmm... It seems that EventNotificationReply is an exception
+- * to the rule of one reply per request.
+- */
+- if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
++ switch (reply->u.hdr.Function) {
++ case MPI_FUNCTION_EVENT_NOTIFICATION:
++ pEventReply = (EventNotificationReply_t *)reply;
++ evHandlers = 0;
++ ProcessEventNotification(ioc, pEventReply, &evHandlers);
++ event = le32_to_cpu(pEventReply->Event) & 0xFF;
++ if (pEventReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)
+ freereq = 0;
+- } else {
+- devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
+- ioc->name, pEvReply));
+- }
+-
+-#ifdef CONFIG_PROC_FS
+-// LogEvent(ioc, pEvReply);
+-#endif
+-
+- } else if (func == MPI_FUNCTION_EVENT_ACK) {
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, EventAck reply received\n",
+- ioc->name));
+- } else if (func == MPI_FUNCTION_CONFIG) {
+- CONFIGPARMS *pCfg;
+- unsigned long flags;
+-
+- dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "config_complete (mf=%p,mr=%p)\n",
+- ioc->name, mf, reply));
+-
+- pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
+-
+- if (pCfg) {
+- /* disable timer and remove from linked list */
+- del_timer(&pCfg->timer);
+-
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- list_del(&pCfg->linkage);
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+-
+- /*
+- * If IOC Status is SUCCESS, save the header
+- * and set the status code to GOOD.
+- */
+- pCfg->status = MPT_CONFIG_ERROR;
+- if (reply) {
+- ConfigReply_t *pReply = (ConfigReply_t *)reply;
+- u16 status;
+-
+- status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
+- dcprintk(ioc, printk(MYIOC_s_NOTE_FMT " IOCStatus=%04xh, IOCLogInfo=%08xh\n",
+- ioc->name, status, le32_to_cpu(pReply->IOCLogInfo)));
+-
+- pCfg->status = status;
+- if (status == MPI_IOCSTATUS_SUCCESS) {
+- if ((pReply->Header.PageType &
+- MPI_CONFIG_PAGETYPE_MASK) ==
+- MPI_CONFIG_PAGETYPE_EXTENDED) {
+- pCfg->cfghdr.ehdr->ExtPageLength =
+- le16_to_cpu(pReply->ExtPageLength);
+- pCfg->cfghdr.ehdr->ExtPageType =
+- pReply->ExtPageType;
+- }
+- pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
+-
+- /* If this is a regular header, save PageLength. */
+- /* LMP Do this better so not using a reserved field! */
+- pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
+- pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
+- pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
+- }
+- }
+-
+- /*
+- * Wake up the original calling thread
+- */
+- pCfg->wait_done = 1;
+- wake_up(&mpt_waitq);
+- }
+- } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
+- /* we should be always getting a reply frame */
+- memcpy(ioc->persist_reply_frame, reply,
+- min(MPT_DEFAULT_FRAME_SIZE,
+- 4*reply->u.reply.MsgLength));
+- del_timer(&ioc->persist_timer);
+- ioc->persist_wait_done = 1;
+- wake_up(&mpt_waitq);
+- } else {
+- printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
+- ioc->name, func);
++ if (event != MPI_EVENT_EVENT_CHANGE)
++ break;
++ case MPI_FUNCTION_CONFIG:
++ case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
++ ioc->mptbase_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
++ if (reply) {
++ ioc->mptbase_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
++ memcpy(ioc->mptbase_cmds.reply, reply,
++ min(MPT_DEFAULT_FRAME_SIZE,
++ 4 * reply->u.reply.MsgLength));
++ }
++ if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->mptbase_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
++ complete(&ioc->mptbase_cmds.done);
++ } else
++ freereq = 0;
++ if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_FREE_MF)
++ freereq = 1;
++ break;
++ case MPI_FUNCTION_EVENT_ACK:
++ devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "EventAck reply received\n", ioc->name));
++ break;
++ default:
++ printk(MYIOC_s_ERR_FMT
++ "Unexpected msg function (=%02Xh) reply received!\n",
++ ioc->name, reply->u.hdr.Function);
++ break;
+ }
+
+ /*
+@@ -616,7 +630,6 @@ mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRA
+ return freereq;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_register - Register protocol-specific main callback handler.
+ * @cbfunc: callback function pointer
+@@ -635,7 +648,7 @@ mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRA
+ * {N,...,7,6,5,...,1} if successful.
+ * A return value of MPT_MAX_PROTOCOL_DRIVERS (including zero!) should be
+ * considered an error by the caller.
+- */
++ **/
+ u8
+ mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
+ {
+@@ -659,14 +672,13 @@ mpt_register(MPT_CALLBACK cbfunc, MPT_DR
+ return last_drv_idx;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_deregister - Deregister a protocol drivers resources.
+ * @cb_idx: previously registered callback handle
+ *
+ * Each protocol-specific driver should call this routine when its
+ * module is unloaded.
+- */
++ **/
+ void
+ mpt_deregister(u8 cb_idx)
+ {
+@@ -679,9 +691,9 @@ mpt_deregister(u8 cb_idx)
+ }
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mpt_event_register - Register protocol-specific event callback handler.
++ * mpt_event_register - Register protocol-specific event callback
++ * handler.
+ * @cb_idx: previously registered (via mpt_register) callback handle
+ * @ev_cbfunc: callback function
+ *
+@@ -689,7 +701,7 @@ mpt_deregister(u8 cb_idx)
+ * if/when they choose to be notified of MPT events.
+ *
+ * Returns 0 for success.
+- */
++ **/
+ int
+ mpt_event_register(u8 cb_idx, MPT_EVHANDLER ev_cbfunc)
+ {
+@@ -700,15 +712,15 @@ mpt_event_register(u8 cb_idx, MPT_EVHAND
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mpt_event_deregister - Deregister protocol-specific event callback handler
++ * mpt_event_deregister - Deregister protocol-specific event callback
++ * handler.
+ * @cb_idx: previously registered callback handle
+ *
+ * Each protocol-specific driver should call this routine
+ * when it does not (or can no longer) handle events,
+ * or when its module is unloaded.
+- */
++ **/
+ void
+ mpt_event_deregister(u8 cb_idx)
+ {
+@@ -718,7 +730,6 @@ mpt_event_deregister(u8 cb_idx)
+ MptEvHandlers[cb_idx] = NULL;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_reset_register - Register protocol-specific IOC reset handler.
+ * @cb_idx: previously registered (via mpt_register) callback handle
+@@ -728,7 +739,7 @@ mpt_event_deregister(u8 cb_idx)
+ * if/when they choose to be notified of IOC resets.
+ *
+ * Returns 0 for success.
+- */
++ **/
+ int
+ mpt_reset_register(u8 cb_idx, MPT_RESETHANDLER reset_func)
+ {
+@@ -739,7 +750,6 @@ mpt_reset_register(u8 cb_idx, MPT_RESETH
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
+ * @cb_idx: previously registered callback handle
+@@ -747,7 +757,7 @@ mpt_reset_register(u8 cb_idx, MPT_RESETH
+ * Each protocol-specific driver should call this routine
+ * when it does not (or can no longer) handle IOC reset handling,
+ * or when its module is unloaded.
+- */
++ **/
+ void
+ mpt_reset_deregister(u8 cb_idx)
+ {
+@@ -757,12 +767,11 @@ mpt_reset_deregister(u8 cb_idx)
+ MptResetHandlers[cb_idx] = NULL;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_device_driver_register - Register device driver hooks
+ * @dd_cbfunc: driver callbacks struct
+ * @cb_idx: MPT protocol driver index
+- */
++ **/
+ int
+ mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, u8 cb_idx)
+ {
+@@ -776,20 +785,21 @@ mpt_device_driver_register(struct mpt_pc
+
+ /* call per pci device probe entry point */
+ list_for_each_entry(ioc, &ioc_list, list) {
++ if (!pci_get_drvdata(ioc->pcidev))
++ continue;
+ id = ioc->pcidev->driver ?
+ ioc->pcidev->driver->id_table : NULL;
+ if (dd_cbfunc->probe)
+ dd_cbfunc->probe(ioc->pcidev, id);
+- }
++ }
+
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_device_driver_deregister - DeRegister device driver hooks
+ * @cb_idx: MPT protocol driver index
+- */
++ **/
+ void
+ mpt_device_driver_deregister(u8 cb_idx)
+ {
+@@ -809,19 +819,15 @@ mpt_device_driver_deregister(u8 cb_idx)
+ MptDeviceDriverHandlers[cb_idx] = NULL;
+ }
+
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mpt_get_msg_frame - Obtain an MPT request frame from the pool
++ * mpt_get_msg_frame - Obtain a MPT request frame from the pool (of 1024)
++ * allocated per MPT adapter.
+ * @cb_idx: Handle of registered MPT protocol driver
+ * @ioc: Pointer to MPT adapter structure
+ *
+- * Obtain an MPT request frame from the pool (of 1024) that are
+- * allocated per MPT adapter.
+- *
+ * Returns pointer to a MPT request frame or %NULL if none are available
+ * or IOC is not active.
+- */
++ **/
+ MPT_FRAME_HDR*
+ mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc)
+ {
+@@ -851,7 +857,6 @@ mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER
+ mf->u.frame.linkage.arg1 = 0;
+ mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
+ req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
+- /* u16! */
+ req_idx = req_offset / ioc->req_sz;
+ mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
+ mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
+@@ -881,16 +886,16 @@ mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER
+ return mf;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mpt_put_msg_frame - Send a protocol-specific MPT request frame to an IOC
++ * mpt_put_msg_frame - Send a protocol specific MPT request frame
++ * to a IOC.
+ * @cb_idx: Handle of registered MPT protocol driver
+ * @ioc: Pointer to MPT adapter structure
+ * @mf: Pointer to MPT request frame
+ *
+- * This routine posts an MPT request frame to the request post FIFO of a
++ * This routine posts a MPT request frame to the request post FIFO of a
+ * specific MPT adapter.
+- */
++ **/
+ void
+ mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
+ {
+@@ -901,14 +906,14 @@ mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER
+ /* ensure values are reset properly! */
+ mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
+ req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
+- /* u16! */
+ req_idx = req_offset / ioc->req_sz;
+ mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
+ mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
+
+ DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
+
+- mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
++ mf_dma_addr = (ioc->req_frames_low_dma + req_offset) |
++ ioc->RequestNB[req_idx];
+ dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d "
+ "RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx,
+ ioc->RequestNB[req_idx]));
+@@ -916,15 +921,13 @@ mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER
+ }
+
+ /**
+- * mpt_put_msg_frame_hi_pri - Send a hi-pri protocol-specific MPT request frame
++ * mpt_put_msg_frame_hi_pri - Send a protocol specific MPT request frame
++ * to a IOC using hi priority request queue.
+ * @cb_idx: Handle of registered MPT protocol driver
+ * @ioc: Pointer to MPT adapter structure
+ * @mf: Pointer to MPT request frame
+ *
+- * Send a protocol-specific MPT request frame to an IOC using
+- * hi-priority request queue.
+- *
+- * This routine posts an MPT request frame to the request post FIFO of a
++ * This routine posts a MPT request frame to the request post FIFO of a
+ * specific MPT adapter.
+ **/
+ void
+@@ -949,7 +952,6 @@ mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_
+ CHIPREG_WRITE32(&ioc->chip->RequestHiPriFifo, mf_dma_addr);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_free_msg_frame - Place MPT request frame back on FreeQ.
+ * @handle: Handle of registered MPT protocol driver
+@@ -958,7 +960,7 @@ mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_
+ *
+ * This routine places a MPT request frame back on the MPT adapter's
+ * FreeQ.
+- */
++ **/
+ void
+ mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
+ {
+@@ -966,43 +968,144 @@ mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT
+
+ /* Put Request back on FreeQ! */
+ spin_lock_irqsave(&ioc->FreeQlock, flags);
+- mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
++ if (cpu_to_le32(mf->u.frame.linkage.arg1) == 0xdeadbeaf)
++ goto out;
++ mf->u.frame.linkage.arg1 = cpu_to_le32(0xdeadbeaf); /* signature to know if this mf is freed */
+ list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
+ #ifdef MFCNT
+ ioc->mfcnt--;
+ #endif
++ out:
+ spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mpt_add_sge - Place a simple SGE at address pAddr.
++ * mpt_add_sge - Place a simple 32 bit SGE at address pAddr.
+ * @pAddr: virtual address for SGE
+ * @flagslength: SGE flags and data transfer length
+ * @dma_addr: Physical address
+ *
+ * This routine places a MPT request frame back on the MPT adapter's
+ * FreeQ.
+- */
+-void
++ **/
++static void
+ mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
+ {
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
+- SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
+- u32 tmp = dma_addr & 0xFFFFFFFF;
++ SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
++ pSge->FlagsLength = cpu_to_le32(flagslength);
++ pSge->Address = cpu_to_le32(dma_addr);
++}
+
+- pSge->FlagsLength = cpu_to_le32(flagslength);
+- pSge->Address.Low = cpu_to_le32(tmp);
+- tmp = (u32) ((u64)dma_addr >> 32);
+- pSge->Address.High = cpu_to_le32(tmp);
+
+- } else {
+- SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
+- pSge->FlagsLength = cpu_to_le32(flagslength);
+- pSge->Address = cpu_to_le32(dma_addr);
++/**
++ * mpt_add_sge_64bit - Place a simple 64 bit SGE at address pAddr.
++ * @pAddr: virtual address for SGE
++ * @flagslength: SGE flags and data transfer length
++ * @dma_addr: Physical address
++ *
++ * This routine places a MPT request frame back on the MPT adapter's
++ * FreeQ.
++ **/
++static void
++mpt_add_sge_64bit(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
++{
++ SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
++ u32 tmp;
++
++ tmp = dma_addr & 0xFFFFFFFF;
++ pSge->Address.Low = cpu_to_le32(tmp);
++ tmp = (u32) ((u64)dma_addr >> 32);
++ pSge->Address.High = cpu_to_le32(tmp);
++ pSge->FlagsLength = cpu_to_le32(
++ (flagslength | MPT_SGE_FLAGS_64_BIT_ADDRESSING));
++}
++
++
++/**
++ * mpt_add_sge_64bit_1078 - Place a simple 64 bit SGE at address pAddr
++ * (1078 workaround).
++ * @pAddr: virtual address for SGE
++ * @flagslength: SGE flags and data transfer length
++ * @dma_addr: Physical address
++ *
++ * This routine places a MPT request frame back on the MPT adapter's
++ * FreeQ.
++ **/
++static void
++mpt_add_sge_64bit_1078(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
++{
++ SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
++ u32 tmp;
++
++ tmp = dma_addr & 0xFFFFFFFF;
++ pSge->Address.Low = cpu_to_le32(tmp);
++ tmp = (u32) ((u64)dma_addr >> 32);
++
++ /*
++ * 1078 errata workaround for the 36GB limitation
++ */
++ if ((((u64)dma_addr + MPI_SGE_LENGTH(flagslength)) >> 32) == 9) {
++ flagslength |=
++ MPI_SGE_SET_FLAGS(MPI_SGE_FLAGS_LOCAL_ADDRESS);
++ tmp |= (1<<31);
++ if (mpt_debug_level & MPT_DEBUG_36GB_MEM)
++ printk(KERN_DEBUG "1078 P0M2 addressing for "
++ "addr = 0x%llx len = %d\n",
++ (unsigned long long)dma_addr,
++ MPI_SGE_LENGTH(flagslength));
+ }
++
++ pSge->Address.High = cpu_to_le32(tmp);
++ pSge->FlagsLength = cpu_to_le32(
++ (flagslength | MPT_SGE_FLAGS_64_BIT_ADDRESSING));
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/**
++ * mpt_add_chain - Place a 32 bit chain SGE at address pAddr.
++ * @pAddr: virtual address for SGE
++ * @next: nextChainOffset value (u32's)
++ * @length: length of next SGL segment
++ * @dma_addr: Physical address
++ *
++ */
++static void
++mpt_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
++{
++ SGEChain32_t *pChain = (SGEChain32_t *) pAddr;
++ pChain->Length = cpu_to_le16(length);
++ pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT;
++ pChain->NextChainOffset = next;
++ pChain->Address = cpu_to_le32(dma_addr);
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/**
++ * mpt_add_chain_64bit - Place a 64 bit chain SGE at address pAddr.
++ * @pAddr: virtual address for SGE
++ * @next: nextChainOffset value (u32's)
++ * @length: length of next SGL segment
++ * @dma_addr: Physical address
++ *
++ */
++static void
++mpt_add_chain_64bit(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
++{
++ SGEChain64_t *pChain = (SGEChain64_t *) pAddr;
++ u32 tmp = dma_addr & 0xFFFFFFFF;
++
++ pChain->Length = cpu_to_le16(length);
++ pChain->Flags = (MPI_SGE_FLAGS_CHAIN_ELEMENT |
++ MPI_SGE_FLAGS_64_BIT_ADDRESSING);
++
++ pChain->NextChainOffset = next;
++
++ pChain->Address.Low = cpu_to_le32(tmp);
++ tmp = (u32) ((u64)dma_addr >> 32);
++ pChain->Address.High = cpu_to_le32(tmp);
+ }
+
++
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_send_handshake_request - Send MPT request via doorbell handshake method.
+@@ -1019,11 +1122,11 @@ mpt_add_sge(char *pAddr, u32 flagslength
+ * request which are greater than 1 byte in size.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ int
+ mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
+ {
+- int r = 0;
++ int r = 0;
+ u8 *req_as_bytes;
+ int ii;
+
+@@ -1038,7 +1141,7 @@ mpt_send_handshake_request(u8 cb_idx, MP
+ * is in proper (pre-alloc'd) request buffer range...
+ */
+ ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
+- if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
++ if (ii >= 0 && ii < ioc->req_depth) {
+ MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
+ mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
+ mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
+@@ -1096,7 +1199,6 @@ mpt_send_handshake_request(u8 cb_idx, MP
+ return r;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_host_page_access_control - control the IOC's Host Page Buffer access
+ * @ioc: Pointer to MPT adapter structure
+@@ -1113,8 +1215,7 @@ mpt_send_handshake_request(u8 cb_idx, MP
+ * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
+-
++ **/
+ static int
+ mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
+ {
+@@ -1139,7 +1240,6 @@ mpt_host_page_access_control(MPT_ADAPTER
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_host_page_alloc - allocate system memory for the fw
+ * @ioc: Pointer to pointer to IOC adapter
+@@ -1147,7 +1247,7 @@ mpt_host_page_access_control(MPT_ADAPTER
+ *
+ * If we already allocated memory in past, then resend the same pointer.
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
+ {
+@@ -1171,7 +1271,7 @@ mpt_host_page_alloc(MPT_ADAPTER *ioc, pI
+ host_page_buffer_sz,
+ &ioc->HostPageBuffer_dma)) != NULL) {
+
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
+ "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
+ ioc->name, ioc->HostPageBuffer,
+ (u32)ioc->HostPageBuffer_dma,
+@@ -1195,21 +1295,16 @@ mpt_host_page_alloc(MPT_ADAPTER *ioc, pI
+ psge = (char *)&ioc_init->HostPageBufferSGE;
+ flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+ MPI_SGE_FLAGS_SYSTEM_ADDRESS |
+- MPI_SGE_FLAGS_32_BIT_ADDRESSING |
+ MPI_SGE_FLAGS_HOST_TO_IOC |
+ MPI_SGE_FLAGS_END_OF_BUFFER;
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
+- flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
+- }
+ flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
+ flags_length |= ioc->HostPageBuffer_sz;
+- mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
++ ioc->add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
+ ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
+
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_verify_adapter - Given IOC identifier, set pointer to its adapter structure.
+ * @iocid: IOC unique identifier (integer)
+@@ -1220,7 +1315,7 @@ return 0;
+ *
+ * Returns iocid and sets iocpp if iocid is found.
+ * Returns -1 if iocid is not found.
+- */
++ **/
+ int
+ mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
+ {
+@@ -1493,7 +1588,6 @@ mpt_mapresources(MPT_ADAPTER *ioc)
+ unsigned long port;
+ u32 msize;
+ u32 psize;
+- u8 revision;
+ int r = -ENODEV;
+ struct pci_dev *pdev;
+
+@@ -1509,24 +1603,39 @@ mpt_mapresources(MPT_ADAPTER *ioc)
+ "MEM failed\n", ioc->name);
+ return r;
+ }
++ if (sizeof(dma_addr_t) > 4) {
++ const uint64_t required_mask = dma_get_required_mask(&pdev->dev);
++ if (required_mask > DMA_32BIT_MASK
++ && !pci_set_dma_mask(pdev, DMA_64BIT_MASK)
++ && !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
++ ioc->dma_mask = DMA_64BIT_MASK;
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
++ ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
++ ioc->name));
++ } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
++ && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
++ ioc->dma_mask = DMA_32BIT_MASK;
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
++ ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
++ ioc->name));
++ } else {
++ printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
++ ioc->name, pci_name(pdev));
++ return r;
++ }
+
+- pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
+-
+- if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)
+- && !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
+- ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
+- ioc->name));
+- } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
+- && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
+- ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
+- ioc->name));
+ } else {
+- printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
+- ioc->name, pci_name(pdev));
+- pci_release_selected_regions(pdev, ioc->bars);
+- return r;
++ if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
++ && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
++ ioc->dma_mask = DMA_32BIT_MASK;
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
++ ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
++ ioc->name));
++ } else {
++ printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
++ ioc->name, pci_name(pdev));
++ return r;
++ }
+ }
+
+ mem_phys = msize = 0;
+@@ -1554,7 +1663,7 @@ mpt_mapresources(MPT_ADAPTER *ioc)
+ mem = ioremap(mem_phys, msize);
+ if (mem == NULL) {
+ printk(MYIOC_s_ERR_FMT ": ERROR - Unable to map adapter"
+- " memory!\n", ioc->name);
++ "memory!\n", ioc->name);
+ return -EINVAL;
+ }
+ ioc->memmap = mem;
+@@ -1565,13 +1674,15 @@ mpt_mapresources(MPT_ADAPTER *ioc)
+ ioc->chip = (SYSIF_REGS __iomem *)mem;
+
+ /* Save Port IO values in case we need to do downloadboot */
+- ioc->pio_mem_phys = port;
+- ioc->pio_chip = (SYSIF_REGS __iomem *)port;
++ {
++ u8 *pmem = (u8*)port;
++ ioc->pio_mem_phys = port;
++ ioc->pio_chip = (SYSIF_REGS __iomem *)pmem;
++ }
+
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_attach - Install a PCI intelligent MPT adapter.
+ * @pdev: Pointer to pci_dev structure
+@@ -1588,7 +1699,7 @@ mpt_mapresources(MPT_ADAPTER *ioc)
+ * Returns 0 for success, non-zero for failure.
+ *
+ * TODO: Add support for polled controllers
+- */
++ **/
+ int
+ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
+ {
+@@ -1610,6 +1721,7 @@ mpt_attach(struct pci_dev *pdev, const s
+
+ ioc->id = mpt_ids++;
+ sprintf(ioc->name, "ioc%d", ioc->id);
++ dinitprintk(ioc, printk(KERN_WARNING MYNAM ": mpt_adapter_install\n"));
+
+ /*
+ * set initial debug level
+@@ -1620,7 +1732,6 @@ mpt_attach(struct pci_dev *pdev, const s
+ if (mpt_debug_level)
+ printk(KERN_INFO "mpt_debug_level=%xh\n", mpt_debug_level);
+
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": mpt_adapter_install\n", ioc->name));
+
+ ioc->pcidev = pdev;
+ if (mpt_mapresources(ioc)) {
+@@ -1628,14 +1739,34 @@ mpt_attach(struct pci_dev *pdev, const s
+ return r;
+ }
+
++ /*
++ * Setting up proper handlers for scatter gather handling
++ */
++ if (ioc->dma_mask == DMA_64BIT_MASK) {
++ if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1078)
++ ioc->add_sge = &mpt_add_sge_64bit_1078;
++ else
++ ioc->add_sge = &mpt_add_sge_64bit;
++ ioc->add_chain = &mpt_add_chain_64bit;
++ ioc->sg_addr_size = 8;
++ } else {
++ ioc->add_sge = &mpt_add_sge;
++ ioc->add_chain = &mpt_add_chain;
++ ioc->sg_addr_size = 4;
++ }
++ ioc->SGE_size = sizeof(u32) + ioc->sg_addr_size;
++
+ ioc->alloc_total = sizeof(MPT_ADAPTER);
+ ioc->req_sz = MPT_DEFAULT_FRAME_SIZE; /* avoid div by zero! */
+ ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
+
+- ioc->pcidev = pdev;
+- ioc->diagPending = 0;
+- spin_lock_init(&ioc->diagLock);
+- spin_lock_init(&ioc->initializing_hba_lock);
++ spin_lock_init(&ioc->taskmgmt_lock);
++ mutex_init(&ioc->internal_cmds.mutex);
++ init_completion(&ioc->internal_cmds.done);
++ mutex_init(&ioc->mptbase_cmds.mutex);
++ init_completion(&ioc->mptbase_cmds.done);
++ mutex_init(&ioc->taskmgmt_cmds.mutex);
++ init_completion(&ioc->taskmgmt_cmds.done);
+
+ /* Initialize the event logging.
+ */
+@@ -1648,16 +1779,13 @@ mpt_attach(struct pci_dev *pdev, const s
+ ioc->mfcnt = 0;
+ #endif
+
++ ioc->sh = NULL;
+ ioc->cached_fw = NULL;
+
+ /* Initilize SCSI Config Data structure
+ */
+ memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
+
+- /* Initialize the running configQ head.
+- */
+- INIT_LIST_HEAD(&ioc->configQ);
+-
+ /* Initialize the fc rport list head.
+ */
+ INIT_LIST_HEAD(&ioc->fc_rports);
+@@ -1665,11 +1793,10 @@ mpt_attach(struct pci_dev *pdev, const s
+ /* Find lookup slot. */
+ INIT_LIST_HEAD(&ioc->list);
+
+-
+- /* Initialize workqueue */
++ /* Initialize work */
+ INIT_DELAYED_WORK(&ioc->fault_reset_work, mpt_fault_reset_work);
+- spin_lock_init(&ioc->fault_reset_work_lock);
+
++ /* Initialize workqueue */
+ snprintf(ioc->reset_work_q_name, sizeof(ioc->reset_work_q_name),
+ "mpt_poll_%d", ioc->id);
+ ioc->reset_work_q =
+@@ -1682,8 +1809,8 @@ mpt_attach(struct pci_dev *pdev, const s
+ return -ENOMEM;
+ }
+
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts @ %p, pfacts[0] @ %p\n",
+- ioc->name, &ioc->facts, &ioc->pfacts[0]));
++ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts @ %p, pfacts[0] @ %p\n",
++ ioc->name, &ioc->facts, &ioc->pfacts[0]));
+
+ pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
+ mpt_get_product_name(pdev->vendor, pdev->device, revision, ioc->prod_name);
+@@ -1703,14 +1830,14 @@ mpt_attach(struct pci_dev *pdev, const s
+ case MPI_MANUFACTPAGE_DEVICEID_FC929X:
+ if (revision < XL_929) {
+ /* 929X Chip Fix. Set Split transactions level
+- * for PCIX. Set MOST bits to zero.
+- */
++ * for PCIX. Set MOST bits to zero.
++ */
+ pci_read_config_byte(pdev, 0x6a, &pcixcmd);
+ pcixcmd &= 0x8F;
+ pci_write_config_byte(pdev, 0x6a, pcixcmd);
+ } else {
+ /* 929XL Chip Fix. Set MMRBC to 0x08.
+- */
++ */
+ pci_read_config_byte(pdev, 0x6a, &pcixcmd);
+ pcixcmd |= 0x08;
+ pci_write_config_byte(pdev, 0x6a, pcixcmd);
+@@ -1728,6 +1855,7 @@ mpt_attach(struct pci_dev *pdev, const s
+ ioc->bus_type = FC;
+ break;
+
++
+ case MPI_MANUFACTPAGE_DEVID_53C1030:
+ /* 1030 Chip Fix. Disable Split transactions
+ * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
+@@ -1745,22 +1873,33 @@ mpt_attach(struct pci_dev *pdev, const s
+ case MPI_MANUFACTPAGE_DEVID_SAS1064:
+ case MPI_MANUFACTPAGE_DEVID_SAS1068:
+ ioc->errata_flag_1064 = 1;
++ ioc->bus_type = SAS;
++ break;
+
+ case MPI_MANUFACTPAGE_DEVID_SAS1064E:
+ case MPI_MANUFACTPAGE_DEVID_SAS1068E:
+ case MPI_MANUFACTPAGE_DEVID_SAS1078:
+ ioc->bus_type = SAS;
++ break;
+ }
+
+- if (mpt_msi_enable == -1) {
+- /* Enable on SAS, disable on FC and SPI */
+- if (ioc->bus_type == SAS)
+- ioc->msi_enable = 1;
+- else
+- ioc->msi_enable = 0;
+- } else
+- /* follow flag: 0 - disable; 1 - enable */
+- ioc->msi_enable = mpt_msi_enable;
++ switch (ioc->bus_type) {
++ case SAS:
++ ioc->msi_enable = mpt_msi_enable_sas;
++ break;
++
++ case SPI:
++ ioc->msi_enable = mpt_msi_enable_spi;
++ break;
++
++ case FC:
++ ioc->msi_enable = mpt_msi_enable_fc;
++ break;
++
++ default:
++ ioc->msi_enable = 0;
++ break;
++ }
+
+ if (ioc->errata_flag_1064)
+ pci_disable_io_access(pdev);
+@@ -1772,9 +1911,6 @@ mpt_attach(struct pci_dev *pdev, const s
+ ioc->active = 0;
+ CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
+
+- /* Set IOC ptr in the pcidev's driver data. */
+- pci_set_drvdata(ioc->pcidev, ioc);
+-
+ /* Set lookup ptr. */
+ list_add_tail(&ioc->list, &ioc_list);
+
+@@ -1782,10 +1918,17 @@ mpt_attach(struct pci_dev *pdev, const s
+ */
+ mpt_detect_bound_ports(ioc, pdev);
+
++
++ INIT_LIST_HEAD(&ioc->fw_event_list);
++ spin_lock_init(&ioc->fw_event_lock);
++ snprintf(ioc->fw_event_q_name, sizeof(ioc->fw_event_q_name),
++ "mpt/%d", ioc->id);
++ ioc->fw_event_q = create_singlethread_workqueue(ioc->fw_event_q_name);
++
+ if ((r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
+ CAN_SLEEP)) != 0){
+ printk(MYIOC_s_ERR_FMT "didn't initialize properly! (%d)\n",
+- ioc->name, r);
++ ioc->name, r);
+
+ list_del(&ioc->list);
+ if (ioc->alt_ioc)
+@@ -1796,7 +1939,8 @@ mpt_attach(struct pci_dev *pdev, const s
+
+ destroy_workqueue(ioc->reset_work_q);
+ ioc->reset_work_q = NULL;
+-
++ destroy_workqueue(ioc->fw_event_q);
++ ioc->fw_event_q = NULL;
+ kfree(ioc);
+ pci_set_drvdata(pdev, NULL);
+ return r;
+@@ -1832,35 +1976,37 @@ mpt_attach(struct pci_dev *pdev, const s
+ if (!ioc->alt_ioc)
+ queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
+ msecs_to_jiffies(MPT_POLLING_INTERVAL));
+-
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_detach - Remove a PCI intelligent MPT adapter.
+ * @pdev: Pointer to pci_dev structure
+- */
+-
++ **/
+ void
+ mpt_detach(struct pci_dev *pdev)
+ {
+ MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
+ char pname[32];
+ u8 cb_idx;
+- unsigned long flags;
++ unsigned long flags;
+ struct workqueue_struct *wq;
+
+ /*
+ * Stop polling ioc for fault condition
+ */
+- spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
+ wq = ioc->reset_work_q;
+ ioc->reset_work_q = NULL;
+- spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+ cancel_delayed_work(&ioc->fault_reset_work);
+ destroy_workqueue(wq);
+
++ spin_lock_irqsave(&ioc->fw_event_lock, flags);
++ wq = ioc->fw_event_q;
++ ioc->fw_event_q = NULL;
++ spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
++ destroy_workqueue(wq);
+
+ sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
+ remove_proc_entry(pname, NULL);
+@@ -1877,32 +2023,18 @@ mpt_detach(struct pci_dev *pdev)
+ }
+ }
+
+- /* Disable interrupts! */
+- CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
+-
+- ioc->active = 0;
+- synchronize_irq(pdev->irq);
+-
+- /* Clear any lingering interrupt */
+- CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
+-
+- CHIPREG_READ32(&ioc->chip->IntStatus);
+-
+- mpt_adapter_dispose(ioc);
+-
+- pci_set_drvdata(pdev, NULL);
+-}
++ mpt_adapter_dispose(ioc);
++}
+
+ /**************************************************************************
+ * Power Management
+ */
+ #ifdef CONFIG_PM
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_suspend - Fusion MPT base driver suspend routine.
+ * @pdev: Pointer to pci_dev structure
+ * @state: new state to enter
+- */
++ **/
+ int
+ mpt_suspend(struct pci_dev *pdev, pm_message_t state)
+ {
+@@ -1923,7 +2055,6 @@ mpt_suspend(struct pci_dev *pdev, pm_mes
+ /* disable interrupts */
+ CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
+ ioc->active = 0;
+-
+ /* Clear any lingering interrupt */
+ CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
+
+@@ -1938,11 +2069,10 @@ mpt_suspend(struct pci_dev *pdev, pm_mes
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_resume - Fusion MPT base driver resume routine.
+ * @pdev: Pointer to pci_dev structure
+- */
++ **/
+ int
+ mpt_resume(struct pci_dev *pdev)
+ {
+@@ -1962,6 +2092,22 @@ mpt_resume(struct pci_dev *pdev)
+ err = mpt_mapresources(ioc);
+ if (err)
+ return err;
++
++ if (ioc->dma_mask == DMA_64BIT_MASK) {
++ if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1078)
++ ioc->add_sge = &mpt_add_sge_64bit_1078;
++ else
++ ioc->add_sge = &mpt_add_sge_64bit;
++ ioc->add_chain = &mpt_add_chain_64bit;
++ ioc->sg_addr_size = 8;
++ } else {
++
++ ioc->add_sge = &mpt_add_sge;
++ ioc->add_chain = &mpt_add_chain;
++ ioc->sg_addr_size = 4;
++ }
++ ioc->SGE_size = sizeof(u32) + ioc->sg_addr_size;
++
+
+ printk(MYIOC_s_INFO_FMT "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
+ ioc->name, (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
+@@ -1986,9 +2132,7 @@ mpt_resume(struct pci_dev *pdev)
+
+ /* bring ioc to operational state */
+ printk(MYIOC_s_INFO_FMT "Sending mpt_do_ioc_recovery\n", ioc->name);
+- recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
+- CAN_SLEEP);
+- if (recovery_state != 0)
++ if ((recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP, CAN_SLEEP)) != 0)
+ printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover, "
+ "error:[%x]\n", ioc->name, recovery_state);
+ else
+@@ -1996,7 +2140,6 @@ mpt_resume(struct pci_dev *pdev)
+ "pci-resume: success\n", ioc->name);
+ out:
+ return 0;
+-
+ }
+ #endif
+
+@@ -2015,7 +2158,6 @@ mpt_signal_reset(u8 index, MPT_ADAPTER *
+ return (MptResetHandlers[index])(ioc, reset_phase);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_do_ioc_recovery - Initialize or recover MPT adapter.
+ * @ioc: Pointer to MPT adapter structure
+@@ -2034,9 +2176,7 @@ mpt_signal_reset(u8 index, MPT_ADAPTER *
+ * -2 if READY but IOCFacts Failed
+ * -3 if READY but PrimeIOCFifos Failed
+ * -4 if READY but IOCInit Failed
+- * -5 if failed to enable_device and/or request_selected_regions
+- * -6 if failed to upload firmware
+- */
++ **/
+ static int
+ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
+ {
+@@ -2045,14 +2185,12 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ int hard;
+ int rc=0;
+ int ii;
+- u8 cb_idx;
+- int handlers;
+ int ret = 0;
+ int reset_alt_ioc_active = 0;
+ int irq_allocated = 0;
+ u8 *a;
+
+- printk(MYIOC_s_INFO_FMT "Initiating %s\n", ioc->name,
++ printk(MYIOC_s_DEBUG_FMT "Initiating %s\n", ioc->name,
+ reason == MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
+
+ /* Disable reply interrupts (also blocks FreeQ) */
+@@ -2060,7 +2198,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ ioc->active = 0;
+
+ if (ioc->alt_ioc) {
+- if (ioc->alt_ioc->active)
++ if (ioc->alt_ioc->active || reason == MPT_HOSTEVENT_IOC_RECOVER)
+ reset_alt_ioc_active = 1;
+
+ /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
+@@ -2079,16 +2217,17 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+
+ if (reset_alt_ioc_active && ioc->alt_ioc) {
+ /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
+- dprintk(ioc, printk(MYIOC_s_INFO_FMT
+- "alt_ioc reply irq re-enabled\n", ioc->alt_ioc->name));
++ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": alt-ioc reply irq re-enabled\n",
++ ioc->alt_ioc->name));
+ CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
+ ioc->alt_ioc->active = 1;
+ }
+
+ } else {
+- printk(MYIOC_s_WARN_FMT "NOT READY!\n", ioc->name);
++ printk(MYIOC_s_WARN_FMT "NOT READY WARNING!\n", ioc->name);
+ }
+- return -1;
++ ret = -1;
++ goto out;
+ }
+
+ /* hard_reset_done = 0 if a soft reset was performed
+@@ -2098,7 +2237,8 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
+ alt_ioc_ready = 1;
+ else
+- printk(MYIOC_s_WARN_FMT "alt_ioc not ready!\n", ioc->alt_ioc->name);
++ printk(MYIOC_s_WARN_FMT
++ ": alt-ioc Not ready WARNING!\n", ioc->alt_ioc->name);
+ }
+
+ for (ii=0; ii<5; ii++) {
+@@ -2156,23 +2296,28 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ if (ioc->pcidev->irq) {
+ if (ioc->msi_enable && !pci_enable_msi(ioc->pcidev))
+ printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n",
+- ioc->name);
++ ioc->name);
+ else
+ ioc->msi_enable = 0;
++
+ rc = request_irq(ioc->pcidev->irq, mpt_interrupt,
+ IRQF_SHARED, ioc->name, ioc);
+ if (rc < 0) {
+ printk(MYIOC_s_ERR_FMT "Unable to allocate "
+- "interrupt %d!\n", ioc->name, ioc->pcidev->irq);
++ "interrupt %d!\n", ioc->name,
++ ioc->pcidev->irq);
+ if (ioc->msi_enable)
+ pci_disable_msi(ioc->pcidev);
+- return -EBUSY;
++ ret = -EBUSY;
++ goto out;
+ }
+ irq_allocated = 1;
+ ioc->pci_irq = ioc->pcidev->irq;
+ pci_set_master(ioc->pcidev); /* ?? */
+- dprintk(ioc, printk(MYIOC_s_INFO_FMT "installed at interrupt "
+- "%d\n", ioc->name, ioc->pcidev->irq));
++ pci_set_drvdata(ioc->pcidev, ioc);
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
++ "installed at interrupt %d\n", ioc->name,
++ ioc->pcidev->irq));
+ }
+ }
+
+@@ -2181,18 +2326,22 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ * init as upper addresses are needed for init.
+ * If fails, continue with alt-ioc processing
+ */
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "PrimeIocFifos\n",
++ ioc->name));
+ if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
+ ret = -3;
+
+ /* May need to check/upload firmware & data here!
+ * If fails, continue with alt-ioc processing
+ */
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "SendIocInit\n",
++ ioc->name));
+ if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
+ ret = -4;
+ // NEW!
+ if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
+- printk(MYIOC_s_WARN_FMT ": alt_ioc (%d) FIFO mgmt alloc!\n",
+- ioc->alt_ioc->name, rc);
++ printk(MYIOC_s_WARN_FMT ": alt-ioc (%d) FIFO mgmt alloc WARNING!\n",
++ ioc->alt_ioc->name, rc);
+ alt_ioc_ready = 0;
+ reset_alt_ioc_active = 0;
+ }
+@@ -2201,15 +2350,16 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
+ alt_ioc_ready = 0;
+ reset_alt_ioc_active = 0;
+- printk(MYIOC_s_WARN_FMT "alt_ioc (%d) init failure!\n",
+- ioc->alt_ioc->name, rc);
++ printk(MYIOC_s_WARN_FMT
++ ": alt-ioc: (%d) init failure WARNING!\n",
++ ioc->alt_ioc->name, rc);
+ }
+ }
+
+ if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
+ if (ioc->upload_fw) {
+ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "firmware upload required!\n", ioc->name));
++ "firmware upload required!\n", ioc->name));
+
+ /* Controller is not operational, cannot do upload
+ */
+@@ -2232,34 +2382,39 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ } else {
+ printk(MYIOC_s_WARN_FMT
+ "firmware upload failure!\n", ioc->name);
+- ret = -6;
++ ret = -5;
+ }
+ }
+ }
+ }
+
++ /* Enable MPT base driver management of EventNotification
++ * and EventAck handling.
++ */
++ if ((ret == 0) && (!ioc->facts.EventState)) {
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "SendEventNotification\n",
++ ioc->name));
++ ret = SendEventNotification(ioc, 1, sleepFlag); /* 1=Enable */
++ }
++
++ if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
++ rc = SendEventNotification(ioc->alt_ioc, 1, sleepFlag);
++
+ if (ret == 0) {
+ /* Enable! (reply interrupt) */
+ CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
+ ioc->active = 1;
+ }
+-
+- if (reset_alt_ioc_active && ioc->alt_ioc) {
+- /* (re)Enable alt-IOC! (reply interrupt) */
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "alt_ioc reply irq re-enabled\n",
+- ioc->alt_ioc->name));
+- CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
+- ioc->alt_ioc->active = 1;
++ if (rc == 0) { /* alt ioc */
++ if (reset_alt_ioc_active && ioc->alt_ioc) {
++ /* (re)Enable alt-IOC! (reply interrupt) */
++ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "alt-ioc reply irq re-enabled\n",
++ ioc->alt_ioc->name));
++ CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
++ ioc->alt_ioc->active = 1;
++ }
+ }
+
+- /* Enable MPT base driver management of EventNotification
+- * and EventAck handling.
+- */
+- if ((ret == 0) && (!ioc->facts.EventState))
+- (void) SendEventNotification(ioc, 1); /* 1=Enable EventNotification */
+-
+- if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
+- (void) SendEventNotification(ioc->alt_ioc, 1); /* 1=Enable EventNotification */
+
+ /* Add additional "reason" check before call to GetLanConfigPages
+ * (combined with GetIoUnitPage2 call). This prevents a somewhat
+@@ -2272,11 +2427,12 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ /*
+ * Initalize link list for inactive raid volumes.
+ */
+- mutex_init(&ioc->raid_data.inactive_list_mutex);
++ init_MUTEX(&ioc->raid_data.inactive_list_mutex);
+ INIT_LIST_HEAD(&ioc->raid_data.inactive_list);
+
+- if (ioc->bus_type == SAS) {
++ switch (ioc->bus_type) {
+
++ case SAS:
+ /* clear persistency table */
+ if(ioc->facts.IOCExceptions &
+ MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
+@@ -2290,8 +2446,15 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ */
+ mpt_findImVolumes(ioc);
+
+- } else if (ioc->bus_type == FC) {
+- if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
++ /* Check, and possibly reset, the coalescing value
++ */
++ mpt_read_ioc_pg_1(ioc);
++
++ break;
++
++ case FC:
++ if ((ioc->pfacts[0].ProtocolFlags &
++ MPI_PORTFACTS_PROTOCOL_LAN) &&
+ (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
+ /*
+ * Pre-fetch the ports LAN MAC address!
+@@ -2300,11 +2463,14 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ (void) GetLanConfigPages(ioc);
+ a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
+ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
+- ioc->name, a[5], a[4], a[3], a[2], a[1], a[0]));
+-
++ "LanAddr = %02X:%02X:%02X"
++ ":%02X:%02X:%02X\n",
++ ioc->name, a[5], a[4],
++ a[3], a[2], a[1], a[0]));
+ }
+- } else {
++ break;
++
++ case SPI:
+ /* Get NVRAM and adapter maximums from SPP 0 and 2
+ */
+ mpt_GetScsiPortSettings(ioc, 0);
+@@ -2323,41 +2489,16 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ mpt_read_ioc_pg_1(ioc);
+
+ mpt_read_ioc_pg_4(ioc);
++
++ break;
+ }
+
+ GetIoUnitPage2(ioc);
+ mpt_get_manufacturing_pg_0(ioc);
+ }
+
+- /*
+- * Call each currently registered protocol IOC reset handler
+- * with post-reset indication.
+- * NOTE: If we're doing _IOC_BRINGUP, there can be no
+- * MptResetHandlers[] registered yet.
+- */
+- if (hard_reset_done) {
+- rc = handlers = 0;
+- for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
+- if ((ret == 0) && MptResetHandlers[cb_idx]) {
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Calling IOC post_reset handler #%d\n",
+- ioc->name, cb_idx));
+- rc += mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
+- handlers++;
+- }
+-
+- if (alt_ioc_ready && MptResetHandlers[cb_idx]) {
+- drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Calling IOC post_reset handler #%d\n",
+- ioc->alt_ioc->name, cb_idx));
+- rc += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
+- handlers++;
+- }
+- }
+- /* FIXME? Examine results here? */
+- }
+-
+ out:
++
+ if ((ret != 0) && irq_allocated) {
+ free_irq(ioc->pci_irq, ioc);
+ if (ioc->msi_enable)
+@@ -2366,7 +2507,6 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ return ret;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_detect_bound_ports - Search for matching PCI bus/dev_function
+ * @ioc: Pointer to MPT adapter structure
+@@ -2378,7 +2518,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
+ *
+ * If match on PCI dev_function +/-1 is found, bind the two MPT adapters
+ * using alt_ioc pointer fields in their %MPT_ADAPTER structures.
+- */
++ **/
+ static void
+ mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
+ {
+@@ -2389,8 +2529,8 @@ mpt_detect_bound_ports(MPT_ADAPTER *ioc,
+
+ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PCI device %s devfn=%x/%x,"
+ " searching for devfn match on %x or %x\n",
+- ioc->name, pci_name(pdev), pdev->bus->number,
+- pdev->devfn, func-1, func+1));
++ ioc->name, pci_name(pdev), pdev->bus->number,
++ pdev->devfn, func-1, func+1));
+
+ peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
+ if (!peer) {
+@@ -2404,16 +2544,16 @@ mpt_detect_bound_ports(MPT_ADAPTER *ioc,
+ if (_pcidev == peer) {
+ /* Paranoia checks */
+ if (ioc->alt_ioc != NULL) {
+- printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
+- ioc->name, ioc->alt_ioc->name);
++ printk(MYIOC_s_WARN_FMT "Oops, already bound (%s <==> %s)!\n",
++ ioc->name, ioc->name, ioc->alt_ioc->name);
+ break;
+ } else if (ioc_srch->alt_ioc != NULL) {
+- printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
+- ioc_srch->name, ioc_srch->alt_ioc->name);
++ printk(MYIOC_s_WARN_FMT "Oops, already bound (%s <==> %s)!\n",
++ ioc_srch->name, ioc_srch->name, ioc_srch->alt_ioc->name);
+ break;
+ }
+- dprintk(ioc, printk(MYIOC_s_INFO_FMT "FOUND! binding to %s\n",
+- ioc->name, ioc_srch->name));
++ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FOUND! binding %s <==> %s\n",
++ ioc->name, ioc->name, ioc_srch->name));
+ ioc_srch->alt_ioc = ioc;
+ ioc->alt_ioc = ioc_srch;
+ }
+@@ -2421,11 +2561,10 @@ mpt_detect_bound_ports(MPT_ADAPTER *ioc,
+ pci_dev_put(peer);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_adapter_disable - Disable misbehaving MPT adapter.
+ * @ioc: Pointer to MPT adapter structure
+- */
++ **/
+ static void
+ mpt_adapter_disable(MPT_ADAPTER *ioc)
+ {
+@@ -2433,26 +2572,43 @@ mpt_adapter_disable(MPT_ADAPTER *ioc)
+ int ret;
+
+ if (ioc->cached_fw != NULL) {
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Pushing FW onto "
+- "adapter\n", __func__, ioc->name));
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_adapter_disable: "
++ "Pushing FW onto adapter\n", ioc->name));
+ if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)
+ ioc->cached_fw, CAN_SLEEP)) < 0) {
+ printk(MYIOC_s_WARN_FMT
+- ": firmware downloadboot failure (%d)!\n",
+- ioc->name, ret);
++ ": firmware downloadboot failure (%d)!\n", ioc->name, ret);
+ }
+ }
+
++ /*
++ * Put the controller into ready state (if its not already)
++ */
++ if (mpt_GetIocState(ioc, 1) != MPI_IOC_STATE_READY) {
++ if(!SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET,
++ CAN_SLEEP)) {
++ if (mpt_GetIocState(ioc, 1) != MPI_IOC_STATE_READY)
++ printk(MYIOC_s_ERR_FMT "%s: IOC msg unit "
++ "reset failed to put ioc in ready state!\n",
++ ioc->name, __FUNCTION__);
++ } else
++ printk(MYIOC_s_ERR_FMT "%s: IOC msg unit reset "
++ "failed!\n", ioc->name, __FUNCTION__);
++ }
++
+ /* Disable adapter interrupts! */
++ synchronize_irq(ioc->pcidev->irq);
+ CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
+ ioc->active = 0;
++
+ /* Clear any lingering interrupt */
+ CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
++ CHIPREG_READ32(&ioc->chip->IntStatus);
+
+ if (ioc->alloc != NULL) {
+ sz = ioc->alloc_sz;
+- dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "free @ %p, sz=%d bytes\n",
+- ioc->name, ioc->alloc, ioc->alloc_sz));
++ dexitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free @ %p, sz=%d bytes\n",
++ ioc->name, ioc->alloc, ioc->alloc_sz));
+ pci_free_consistent(ioc->pcidev, sz,
+ ioc->alloc, ioc->alloc_dma);
+ ioc->reply_frames = NULL;
+@@ -2482,8 +2638,10 @@ mpt_adapter_disable(MPT_ADAPTER *ioc)
+ mpt_inactive_raid_list_free(ioc);
+ kfree(ioc->raid_data.pIocPg2);
+ kfree(ioc->raid_data.pIocPg3);
++ kfree(ioc->raid_data.pIocPg6);
+ ioc->spi_data.nvram = NULL;
+ ioc->raid_data.pIocPg3 = NULL;
++ ioc->raid_data.pIocPg6 = NULL;
+
+ if (ioc->spi_data.pIocPg4 != NULL) {
+ sz = ioc->spi_data.IocPg4Sz;
+@@ -2507,27 +2665,29 @@ mpt_adapter_disable(MPT_ADAPTER *ioc)
+ if((ret = mpt_host_page_access_control(ioc,
+ MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
+ printk(MYIOC_s_ERR_FMT
+- "host page buffers free failed (%d)!\n",
+- ioc->name, ret);
++ ": %s: host page buffers free failed (%d)!\n",
++ ioc->name, __FUNCTION__, ret);
+ }
+- dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "HostPageBuffer free @ %p, sz=%d bytes\n",
++ dexitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HostPageBuffer free @ %p, sz=%d bytes\n",
+ ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
+ pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
+- ioc->HostPageBuffer, ioc->HostPageBuffer_dma);
++ ioc->HostPageBuffer,
++ ioc->HostPageBuffer_dma);
+ ioc->HostPageBuffer = NULL;
+ ioc->HostPageBuffer_sz = 0;
+ ioc->alloc_total -= ioc->HostPageBuffer_sz;
+ }
++
++ pci_set_drvdata(ioc->pcidev, NULL);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_adapter_dispose - Free all resources associated with an MPT adapter
+ * @ioc: Pointer to MPT adapter structure
+ *
+ * This routine unregisters h/w resources and frees all alloc'd memory
+ * associated with a MPT adapter structure.
+- */
++ **/
+ static void
+ mpt_adapter_dispose(MPT_ADAPTER *ioc)
+ {
+@@ -2558,7 +2718,7 @@ mpt_adapter_dispose(MPT_ADAPTER *ioc)
+ #if defined(CONFIG_MTRR) && 0
+ if (ioc->mtrr_reg > 0) {
+ mtrr_del(ioc->mtrr_reg, 0, 0);
+- dprintk(ioc, printk(MYIOC_s_INFO_FMT "MTRR region de-registered\n", ioc->name));
++ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MTRR region de-registered\n", ioc->name));
+ }
+ #endif
+
+@@ -2566,8 +2726,8 @@ mpt_adapter_dispose(MPT_ADAPTER *ioc)
+ list_del(&ioc->list);
+
+ sz_last = ioc->alloc_total;
+- dprintk(ioc, printk(MYIOC_s_INFO_FMT "free'd %d of %d bytes\n",
+- ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
++ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free'd %d of %d bytes\n",
++ ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
+
+ if (ioc->alt_ioc)
+ ioc->alt_ioc->alt_ioc = NULL;
+@@ -2575,11 +2735,10 @@ mpt_adapter_dispose(MPT_ADAPTER *ioc)
+ kfree(ioc);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * MptDisplayIocCapabilities - Disply IOC's capabilities.
+ * @ioc: Pointer to MPT adapter structure
+- */
++ **/
+ static void
+ MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
+ {
+@@ -2618,7 +2777,6 @@ MptDisplayIocCapabilities(MPT_ADAPTER *i
+ printk("}\n");
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * MakeIocReady - Get IOC to a READY state, using KickStart if needed.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -2632,7 +2790,7 @@ MptDisplayIocCapabilities(MPT_ADAPTER *i
+ * -2 - Msg Unit Reset Failed
+ * -3 - IO Unit Reset Failed
+ * -4 - IOC owned by a PEER
+- */
++ **/
+ static int
+ MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
+ {
+@@ -2646,7 +2804,7 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
+
+ /* Get current [raw] IOC state */
+ ioc_state = mpt_GetIocState(ioc, 0);
+- dhsprintk(ioc, printk(MYIOC_s_INFO_FMT "MakeIocReady [raw] state=%08x\n", ioc->name, ioc_state));
++ dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MakeIocReady, [raw] state=%08x\n", ioc->name, ioc_state));
+
+ /*
+ * Check to see if IOC got left/stuck in doorbell handshake
+@@ -2659,8 +2817,11 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
+ }
+
+ /* Is it already READY? */
+- if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
++ if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY) {
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "IOC is in READY state\n",
++ ioc->name));
+ return 0;
++ }
+
+ /*
+ * Check to see if IOC is in FAULT state.
+@@ -2668,9 +2829,9 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
+ if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
+ statefault = 2;
+ printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
+- ioc->name);
+- printk(MYIOC_s_WARN_FMT " FAULT code = %04xh\n",
+- ioc->name, ioc_state & MPI_DOORBELL_DATA_MASK);
++ ioc->name);
++ printk(KERN_WARNING " FAULT code = %04xh\n",
++ ioc_state & MPI_DOORBELL_DATA_MASK);
+ }
+
+ /*
+@@ -2686,7 +2847,7 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
+ * Else, fall through to KickStart case
+ */
+ whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
++ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+ "whoinit 0x%x statefault %d force %d\n",
+ ioc->name, whoinit, statefault, force));
+ if (whoinit == MPI_WHOINIT_PCI_PEER)
+@@ -2733,15 +2894,15 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
+
+ ii++; cntdn--;
+ if (!cntdn) {
+- printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
+- ioc->name, (int)((ii+5)/HZ));
++ printk(MYIOC_s_ERR_FMT "Wait IOC_READY state (0x%x) timeout(%d)!\n",
++ ioc->name, ioc_state, (int)((ii+5)/HZ));
+ return -ETIME;
+ }
+
+ if (sleepFlag == CAN_SLEEP) {
+ msleep(1);
+ } else {
+- mdelay (1); /* 1 msec delay */
++ mdelay(1); /* 1 msec delay */
+ }
+
+ }
+@@ -2755,7 +2916,6 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
+ return hard_reset_done;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_GetIocState - Get the current state of a MPT adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -2763,7 +2923,7 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
+ *
+ * Returns all IOC Doorbell register bits if cooked==0, else just the
+ * Doorbell bits in MPI_IOC_STATE_MASK.
+- */
++ **/
+ u32
+ mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
+ {
+@@ -2779,7 +2939,6 @@ mpt_GetIocState(MPT_ADAPTER *ioc, int co
+ return cooked ? sc : s;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * GetIocFacts - Send IOCFacts request to MPT adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -2787,7 +2946,7 @@ mpt_GetIocState(MPT_ADAPTER *ioc, int co
+ * @reason: If recovery, only update facts.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
+ {
+@@ -2802,8 +2961,9 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+
+ /* IOC *must* NOT be in RESET state! */
+ if (ioc->last_state == MPI_IOC_STATE_RESET) {
+- printk(MYIOC_s_ERR_FMT "Can't get IOCFacts NOT READY! (%08x)\n",
+- ioc->name, ioc->last_state );
++ printk(KERN_ERR MYNAM ": ERROR - Can't get IOCFacts, %s NOT READY! (%08x)\n",
++ ioc->name,
++ ioc->last_state );
+ return -44;
+ }
+
+@@ -2820,7 +2980,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+ get_facts.Function = MPI_FUNCTION_IOC_FACTS;
+ /* Assert: All other get_facts fields are zero! */
+
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
+ "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
+ ioc->name, req_sz, reply_sz));
+
+@@ -2850,6 +3010,8 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+ }
+
+ facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
++ if (facts->MsgVersion == MPI_VERSION_01_05)
++ facts->HeaderVersion = le16_to_cpu(facts->HeaderVersion);
+ facts->MsgContext = le32_to_cpu(facts->MsgContext);
+ facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
+ facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
+@@ -2865,7 +3027,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+ * Old: u16{Major(4),Minor(4),SubMinor(8)}
+ * New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
+ */
+- if (facts->MsgVersion < 0x0102) {
++ if (facts->MsgVersion < MPI_VERSION_01_02) {
+ /*
+ * Handle old FC f/w style, convert to new...
+ */
+@@ -2877,9 +3039,11 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+ facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
+
+ facts->ProductID = le16_to_cpu(facts->ProductID);
++
+ if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
+ > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
+ ioc->ir_firmware = 1;
++
+ facts->CurrentHostMfaHighAddr =
+ le32_to_cpu(facts->CurrentHostMfaHighAddr);
+ facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
+@@ -2895,7 +3059,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+ * to 14 in MPI-1.01.0x.
+ */
+ if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
+- facts->MsgVersion > 0x0100) {
++ facts->MsgVersion > MPI_VERSION_01_00) {
+ facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
+ }
+
+@@ -2956,7 +3120,6 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * GetPortFacts - Send PortFacts request to MPT adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -2964,7 +3127,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
+ * @sleepFlag: Specifies whether the process can sleep
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
+ {
+@@ -2977,8 +3140,8 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
+
+ /* IOC *must* NOT be in RESET state! */
+ if (ioc->last_state == MPI_IOC_STATE_RESET) {
+- printk(MYIOC_s_ERR_FMT "Can't get PortFacts NOT READY! (%08x)\n",
+- ioc->name, ioc->last_state );
++ printk(MYIOC_s_ERR_FMT "Can't get PortFacts, "
++ " NOT READY! (%08x)\n", ioc->name, ioc->last_state );
+ return -4;
+ }
+
+@@ -2996,14 +3159,14 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
+ get_pfacts.PortNumber = portnum;
+ /* Assert: All other get_pfacts fields are zero! */
+
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending get PortFacts(%d) request\n",
+- ioc->name, portnum));
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "Sending get PortFacts(%d) request\n",
++ ioc->name, portnum));
+
+ /* No non-zero fields in the get_pfacts request are greater than
+ * 1 byte in size, so we can just fire it off as is.
+ */
+ ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
+- reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
++ reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
+ if (ii != 0)
+ return ii;
+
+@@ -3038,7 +3201,6 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * SendIocInit - Send IOCInit request to MPT adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -3047,7 +3209,7 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
+ * Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
+ {
+@@ -3077,7 +3239,8 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
+
+ ioc_init.MaxDevices = (U8)ioc->devices_per_bus;
+ ioc_init.MaxBuses = (U8)ioc->number_of_buses;
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts.MsgVersion=%x\n",
++
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts.MsgVersion=%x\n",
+ ioc->name, ioc->facts.MsgVersion));
+ if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
+ // set MsgVersion and HeaderVersion host driver was built with
+@@ -3091,7 +3254,7 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
+ }
+ ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz); /* in BYTES */
+
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
++ if (ioc->sg_addr_size == sizeof(u64)) {
+ /* Save the upper 32-bits of the request
+ * (reply) and sense buffers.
+ */
+@@ -3160,7 +3323,6 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
+ return r;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * SendPortEnable - Send PortEnable request to MPT adapter port.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -3170,7 +3332,7 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
+ * Send PortEnable to bring IOC to OPERATIONAL state.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
+ {
+@@ -3193,7 +3355,7 @@ SendPortEnable(MPT_ADAPTER *ioc, int por
+ /* port_enable.MsgFlags = 0; */
+ /* port_enable.MsgContext = 0; */
+
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Port(%d)Enable (req @ %p)\n",
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "Sending Port(%d)Enable (req @ %p)\n",
+ ioc->name, portnum, &port_enable));
+
+ /* RAID FW may take a long time to enable
+@@ -3273,7 +3435,6 @@ mpt_free_fw_memory(MPT_ADAPTER *ioc)
+ ioc->cached_fw = NULL;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -3286,7 +3447,7 @@ mpt_free_fw_memory(MPT_ADAPTER *ioc)
+ * on the bound IOC, the second image is discarded
+ * and memory is free'd. Both channels must upload to prevent
+ * IOC from running in degraded mode.
+- */
++ **/
+ static int
+ mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
+ {
+@@ -3294,22 +3455,19 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
+ FWUpload_t *prequest;
+ FWUploadReply_t *preply;
+ FWUploadTCSGE_t *ptcsge;
+- int sgeoffset;
+ u32 flagsLength;
+- int ii, sz, reply_sz;
++ int ii, reply_sz;
+ int cmdStatus;
++ int request_size;
+
+ /* If the image size is 0, we are done.
+ */
+- if ((sz = ioc->facts.FWImageSize) == 0)
++ if (!ioc->facts.FWImageSize)
+ return 0;
+
+ if (mpt_alloc_fw_memory(ioc, ioc->facts.FWImageSize) != 0)
+ return -ENOMEM;
+
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Image @ %p[%p], sz=%d[%x] bytes\n",
+- ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
+-
+ prequest = (sleepFlag == NO_SLEEP) ? kzalloc(ioc->req_sz, GFP_ATOMIC) :
+ kzalloc(ioc->req_sz, GFP_KERNEL);
+ if (!prequest) {
+@@ -3326,49 +3484,47 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
+
+ prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
+ prequest->Function = MPI_FUNCTION_FW_UPLOAD;
+-
+ ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
+ ptcsge->DetailsLength = 12;
+ ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
+- ptcsge->ImageSize = cpu_to_le32(sz);
++ ptcsge->ImageSize = cpu_to_le32(ioc->facts.FWImageSize);
+ ptcsge++;
+
+- sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
+-
+- flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
+- mpt_add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
+-
+- sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
+- ioc->name, prequest, sgeoffset));
++ flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | ioc->facts.FWImageSize;
++ ioc->add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
++ request_size = offsetof(FWUpload_t, SGL) + sizeof(FWUploadTCSGE_t) +
++ ioc->SGE_size;
++ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending FW Upload "
++ " (req @ %p) fw_size=%d mf_request_size=%d\n", ioc->name, prequest,
++ ioc->facts.FWImageSize, request_size));
+ DBG_DUMP_FW_REQUEST_FRAME(ioc, (u32 *)prequest);
+
+- ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
+- reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
++ ii = mpt_handshake_req_reply_wait(ioc, request_size, (u32*)prequest,
++ reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
+
+- dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Upload completed rc=%x \n", ioc->name, ii));
++ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FW Upload completed "
++ "rc=%x \n", ioc->name, ii));
+
+ cmdStatus = -EFAULT;
+ if (ii == 0) {
+ /* Handshake transfer was complete and successful.
+ * Check the Reply Frame.
+ */
+- int status, transfer_sz;
+- status = le16_to_cpu(preply->IOCStatus);
+- if (status == MPI_IOCSTATUS_SUCCESS) {
+- transfer_sz = le32_to_cpu(preply->ActualImageSize);
+- if (transfer_sz == sz)
+- cmdStatus = 0;
+- }
++ int status;
++ status = le16_to_cpu(preply->IOCStatus) &
++ MPI_IOCSTATUS_MASK;
++ if (status == MPI_IOCSTATUS_SUCCESS &&
++ ioc->facts.FWImageSize ==
++ le32_to_cpu(preply->ActualImageSize));
++ cmdStatus = 0;
+ }
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": do_upload cmdStatus=%d \n",
+- ioc->name, cmdStatus));
++ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "do_upload cmdStatus=%d \n",
++ ioc->name, cmdStatus));
+
+
+ if (cmdStatus) {
+-
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": fw upload failed, freeing image \n",
+- ioc->name));
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "fw upload failed, "
++ "freeing image \n", ioc->name));
+ mpt_free_fw_memory(ioc);
+ }
+ kfree(prequest);
+@@ -3376,7 +3532,6 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
+ return cmdStatus;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_downloadboot - DownloadBoot code
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -3389,7 +3544,7 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
+ * -1 FW Image size is 0
+ * -2 No valid cached_fw Pointer
+ * <0 for fw upload failure.
+- */
++ **/
+ static int
+ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
+ {
+@@ -3401,10 +3556,10 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+ u32 diagRwData;
+ u32 nextImage;
+ u32 load_addr;
+- u32 ioc_state=0;
++ u32 doorbell;
+
+ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
+- ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
++ ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
+
+ CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
+ CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
+@@ -3416,11 +3571,10 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+ CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
+
+ /* wait 1 msec */
+- if (sleepFlag == CAN_SLEEP) {
++ if (sleepFlag == CAN_SLEEP)
+ msleep(1);
+- } else {
+- mdelay (1);
+- }
++ else
++ mdelay(1);
+
+ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+ CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
+@@ -3433,11 +3587,10 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+ break;
+ }
+ /* wait .1 sec */
+- if (sleepFlag == CAN_SLEEP) {
++ if (sleepFlag == CAN_SLEEP)
+ msleep (100);
+- } else {
++ else
+ mdelay (100);
+- }
+ }
+
+ if ( count == 30 ) {
+@@ -3455,6 +3608,7 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+ CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
+
+ /* Set the DiagRwEn and Disable ARM bits */
++ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+ CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
+
+ fwSize = (pFwHeader->ImageSize + 3)/4;
+@@ -3468,13 +3622,12 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
+ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "LoadStart addr written 0x%x \n",
+- ioc->name, pFwHeader->LoadStartAddress));
++ ioc->name, pFwHeader->LoadStartAddress));
+
+ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write FW Image: 0x%x bytes @ %p\n",
+- ioc->name, fwSize*4, ptrFw));
+- while (fwSize--) {
++ ioc->name, fwSize*4, ptrFw));
++ while (fwSize--)
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
+- }
+
+ nextImage = pFwHeader->NextImageHeaderOffset;
+ while (nextImage) {
+@@ -3486,21 +3639,22 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+ ptrFw = (u32 *)pExtImage;
+
+ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
+- ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
++ ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
+
+- while (fwSize--) {
++ while (fwSize--)
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
+- }
+ nextImage = pExtImage->NextImageHeaderOffset;
+ }
+
+ /* Write the IopResetVectorRegAddr */
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n", ioc->name, pFwHeader->IopResetRegAddr));
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n",
++ ioc->name, pFwHeader->IopResetRegAddr));
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
+
+ /* Write the IopResetVectorValue */
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n",
++ ioc->name, pFwHeader->IopResetVectorValue));
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
+
+ /* Clear the internal flash bad bit - autoincrementing register,
+@@ -3517,75 +3671,75 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
+ CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
+
+- } else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
+- diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+- CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
+- MPI_DIAG_CLEAR_FLASH_BAD_SIG);
+-
+- /* wait 1 msec */
+- if (sleepFlag == CAN_SLEEP) {
+- msleep (1);
+- } else {
+- mdelay (1);
+- }
+ }
+
+ if (ioc->errata_flag_1064)
+ pci_disable_io_access(ioc->pcidev);
+
+ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot diag0val=%x, "
+- "turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
+- ioc->name, diag0val));
+- diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot now diag0val=%x\n",
+- ioc->name, diag0val));
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "diag0val=%x, turning off"
++ " PREVENT_IOC_BOOT and DISABLE_ARM\n", ioc->name, diag0val));
++ diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM);
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "diag0val=%x\n",
++ ioc->name, diag0val));
+ CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
+
+- /* Write 0xFF to reset the sequencer */
+- CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
++ if (ioc->bus_type == SAS ) {
++ /* wait 1 sec */
++ if (sleepFlag == CAN_SLEEP)
++ msleep(1000);
++ else
++ mdelay(1000);
+
+- if (ioc->bus_type == SAS) {
+- ioc_state = mpt_GetIocState(ioc, 0);
+- if ( (GetIocFacts(ioc, sleepFlag,
+- MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "GetIocFacts failed: IocState=%x\n",
+- ioc->name, ioc_state));
+- return -EFAULT;
++ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
++ ddlprintk(ioc, printk (MYIOC_s_DEBUG_FMT
++ "diag0val=%x, turning off RW_ENABLE\n", ioc->name,
++ diag0val));
++ diag0val &= ~(MPI_DIAG_RW_ENABLE);
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "now diag0val=%x\n", ioc->name, diag0val));
++ CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
++
++ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
++ if (diag0val & MPI_DIAG_FLASH_BAD_SIG) {
++ diag0val |= MPI_DIAG_CLEAR_FLASH_BAD_SIG;
++ CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
++ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+ }
++ diag0val &= ~(MPI_DIAG_DISABLE_ARM);
++ CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
++ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
++ CHIPREG_WRITE32(&ioc->chip->DiagRwAddress, 0x3f000004);
+ }
+
+- for (count=0; count<HZ*20; count++) {
+- if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "downloadboot successful! (count=%d) IocState=%x\n",
+- ioc->name, count, ioc_state));
+- if (ioc->bus_type == SAS) {
++ /* Write 0xFF to reset the sequencer */
++ CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
++
++ for (count = 0; count < 30; count ++) {
++ doorbell = CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_IOC_STATE_MASK;
++ if (doorbell == MPI_IOC_STATE_READY) {
++ if (ioc->bus_type == SAS)
+ return 0;
+- }
+ if ((SendIocInit(ioc, sleepFlag)) != 0) {
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "downloadboot: SendIocInit failed\n",
+- ioc->name));
++ ddlprintk(ioc, printk(MYIOC_s_WARN_FMT
++ "SendIocInit failed\n", ioc->name));
+ return -EFAULT;
+ }
+ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "downloadboot: SendIocInit successful\n",
+- ioc->name));
++ "SendIocInit successful\n", ioc->name));
+ return 0;
+ }
+- if (sleepFlag == CAN_SLEEP) {
+- msleep (10);
+- } else {
+- mdelay (10);
+- }
++ ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "looking for READY STATE:"
++ " doorbell=%x count=%d\n", ioc->name, doorbell, count));
++ if (sleepFlag == CAN_SLEEP)
++ msleep(1000);
++ else
++ mdelay(1000);
+ }
+- ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "downloadboot failed! IocState=%x\n",ioc->name, ioc_state));
++ ddlprintk(ioc, printk(MYIOC_s_WARN_FMT "downloadboot failed! count=%d\n", ioc->name, count));
+ return -EFAULT;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * KickStart - Perform hard reset of MPT adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -3610,7 +3764,7 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
+ * OR reset but failed to come READY
+ * -2 - no reset, could not enter DIAG mode
+ * -3 - reset but bad FW bit
+- */
++ **/
+ static int
+ KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
+ {
+@@ -3618,7 +3772,7 @@ KickStart(MPT_ADAPTER *ioc, int force, i
+ u32 ioc_state=0;
+ int cnt,cntdn;
+
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStarting!\n", ioc->name));
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": KickStart\n", ioc->name));
+ if (ioc->bus_type == SPI) {
+ /* Always issue a Msg Unit Reset first. This will clear some
+ * SCSI bus hang conditions.
+@@ -3636,14 +3790,15 @@ KickStart(MPT_ADAPTER *ioc, int force, i
+ if (hard_reset_done < 0)
+ return hard_reset_done;
+
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset successful!\n",
+- ioc->name));
++ /* may not have worked but hard_reset_done doesn't always signal failure */
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "Diagnostic reset completed!\n",
++ ioc->name));
+
+ cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 2; /* 2 seconds */
+ for (cnt=0; cnt<cntdn; cnt++) {
+ ioc_state = mpt_GetIocState(ioc, 1);
+ if ((ioc_state == MPI_IOC_STATE_READY) || (ioc_state == MPI_IOC_STATE_OPERATIONAL)) {
+- dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStart successful! (cnt=%d)\n",
++ dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "KickStart successful! (cnt=%d)\n",
+ ioc->name, cnt));
+ return hard_reset_done;
+ }
+@@ -3655,11 +3810,10 @@ KickStart(MPT_ADAPTER *ioc, int force, i
+ }
+
+ dinitprintk(ioc, printk(MYIOC_s_ERR_FMT "Failed to come READY after reset! IocState=%x\n",
+- ioc->name, mpt_GetIocState(ioc, 0)));
++ ioc->name, mpt_GetIocState(ioc, 0)));
+ return -1;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_diag_reset - Perform hard reset of the adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -3677,30 +3831,46 @@ KickStart(MPT_ADAPTER *ioc, int force, i
+ * 0 no reset performed because reset history bit set
+ * -2 enabling diagnostic mode failed
+ * -3 diagnostic reset failed
+- */
++ **/
+ static int
+ mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
+ {
+ u32 diag0val;
+- u32 doorbell;
++ u32 doorbell = 0;
+ int hard_reset_done = 0;
+ int count = 0;
+ u32 diag1val = 0;
+ MpiFwHeader_t *cached_fw; /* Pointer to FW */
++ u8 cb_idx;
+
+ /* Clear any existing interrupts */
+ CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
+
+ if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078) {
++
++ if (!ignore)
++ return 0;
++
+ drsprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: Doorbell=%p; 1078 reset "
+- "address=%p\n", ioc->name, __func__,
+- &ioc->chip->Doorbell, &ioc->chip->Reset_1078));
++ "address=%p\n", ioc->name, __FUNCTION__, &ioc->chip->Doorbell,
++ &ioc->chip->Reset_1078));
+ CHIPREG_WRITE32(&ioc->chip->Reset_1078, 0x07);
+ if (sleepFlag == CAN_SLEEP)
+ msleep(1);
+ else
+ mdelay(1);
+
++ /*
++ * Call each currently registered protocol IOC reset handler
++ * with pre-reset indication.
++ * NOTE: If we're doing _IOC_BRINGUP, there can be no
++ * MptResetHandlers[] registered yet.
++ */
++ for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
++ if (MptResetHandlers[cb_idx])
++ (*(MptResetHandlers[cb_idx]))(ioc, MPT_IOC_PRE_RESET);
++ }
++
+ for (count = 0; count < 60; count ++) {
+ doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
+ doorbell &= MPI_IOC_STATE_MASK;
+@@ -3709,9 +3879,15 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ "looking for READY STATE: doorbell=%x"
+ " count=%d\n",
+ ioc->name, doorbell, count));
+- if (doorbell == MPI_IOC_STATE_READY) {
++
++ if (doorbell == MPI_IOC_STATE_READY)
+ return 1;
+- }
++
++ /*
++ * Early out for hard fault
++ */
++ if (count && doorbell == MPI_IOC_STATE_FAULT)
++ break;
+
+ /* wait 1 sec */
+ if (sleepFlag == CAN_SLEEP)
+@@ -3719,16 +3895,20 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ else
+ mdelay(1000);
+ }
++
++ if (doorbell != MPI_IOC_STATE_READY)
++ printk(MYIOC_s_ERR_FMT "Failed to come READY after "
++ "reset! IocState=%x", ioc->name, doorbell);
+ return -1;
+ }
+
+ /* Use "Diagnostic reset" method! (only thing available!) */
+ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+
+- if (ioc->debug_level & MPT_DEBUG) {
++ if (ioc->debug_level & MPT_DEBUG_RESET) {
+ if (ioc->alt_ioc)
+ diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
+ ioc->name, diag0val, diag1val));
+ }
+
+@@ -3748,11 +3928,10 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
+
+ /* wait 100 msec */
+- if (sleepFlag == CAN_SLEEP) {
++ if (sleepFlag == CAN_SLEEP)
+ msleep (100);
+- } else {
++ else
+ mdelay (100);
+- }
+
+ count++;
+ if (count > 20) {
+@@ -3764,14 +3943,14 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+
+ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
+ ioc->name, diag0val));
+ }
+
+- if (ioc->debug_level & MPT_DEBUG) {
++ if (ioc->debug_level & MPT_DEBUG_RESET) {
+ if (ioc->alt_ioc)
+ diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
+ ioc->name, diag0val, diag1val));
+ }
+ /*
+@@ -3787,7 +3966,7 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ */
+ CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
+ hard_reset_done = 1;
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
+ ioc->name));
+
+ /*
+@@ -3796,25 +3975,13 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ * NOTE: If we're doing _IOC_BRINGUP, there can be no
+ * MptResetHandlers[] registered yet.
+ */
+- {
+- u8 cb_idx;
+- int r = 0;
+-
+- for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
+- if (MptResetHandlers[cb_idx]) {
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Calling IOC pre_reset handler #%d\n",
+- ioc->name, cb_idx));
+- r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
+- if (ioc->alt_ioc) {
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Calling alt-%s pre_reset handler #%d\n",
+- ioc->name, ioc->alt_ioc->name, cb_idx));
+- r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
+- }
++ 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 (ioc->alt_ioc) {
++ mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
+ }
+ }
+- /* FIXME? Examine results here? */
+ }
+
+ if (ioc->cached_fw)
+@@ -3834,20 +4001,18 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ break;
+ }
+
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
+ ioc->name, diag0val, count));
+ /* wait 1 sec */
+- if (sleepFlag == CAN_SLEEP) {
++ if (sleepFlag == CAN_SLEEP)
+ msleep (1000);
+- } else {
++ else
+ mdelay (1000);
+- }
+ }
+ if ((count = mpt_downloadboot(ioc, cached_fw, sleepFlag)) < 0) {
+ printk(MYIOC_s_WARN_FMT
+ "firmware downloadboot failure (%d)!\n", ioc->name, count);
+ }
+-
+ } else {
+ /* Wait for FW to reload and for board
+ * to go to the READY state.
+@@ -3859,25 +4024,38 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
+ doorbell &= MPI_IOC_STATE_MASK;
+
+- if (doorbell == MPI_IOC_STATE_READY) {
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "looking for READY STATE: doorbell=%x"
++ " count=%d\n", ioc->name, doorbell, count));
++
++ if (doorbell == MPI_IOC_STATE_READY)
++ break;
++
++ /*
++ * Early out for hard fault
++ */
++ if (count && doorbell == MPI_IOC_STATE_FAULT)
+ break;
+- }
+
+ /* wait 1 sec */
+- if (sleepFlag == CAN_SLEEP) {
++ if (sleepFlag == CAN_SLEEP)
+ msleep (1000);
+- } else {
++ else
+ mdelay (1000);
+- }
+ }
++
++ if (doorbell != MPI_IOC_STATE_READY)
++ printk(MYIOC_s_ERR_FMT "Failed to come READY "
++ "after reset! IocState=%x", ioc->name,
++ doorbell);
+ }
+ }
+
+ diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
+- if (ioc->debug_level & MPT_DEBUG) {
++ if (ioc->debug_level & MPT_DEBUG_RESET) {
+ if (ioc->alt_ioc)
+ diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
+ ioc->name, diag0val, diag1val));
+ }
+
+@@ -3898,11 +4076,10 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
+
+ /* wait 100 msec */
+- if (sleepFlag == CAN_SLEEP) {
++ if (sleepFlag == CAN_SLEEP)
+ msleep (100);
+- } else {
++ else
+ mdelay (100);
+- }
+
+ count++;
+ if (count > 20) {
+@@ -3933,11 +4110,11 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ return -3;
+ }
+
+- if (ioc->debug_level & MPT_DEBUG) {
++ if (ioc->debug_level & MPT_DEBUG_RESET) {
+ if (ioc->alt_ioc)
+ diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
+- ioc->name, diag0val, diag1val));
++ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
++ ioc->name, diag0val, diag1val));
+ }
+
+ /*
+@@ -3951,7 +4128,6 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ return hard_reset_done;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * SendIocReset - Send IOCReset request to MPT adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -3962,7 +4138,7 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
+ * Send IOCReset request to the MPT adapter.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
+ {
+@@ -3973,7 +4149,7 @@ SendIocReset(MPT_ADAPTER *ioc, u8 reset_
+ drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOC reset(0x%02x)!\n",
+ ioc->name, reset_type));
+ CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
+- if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
++ if ((r = WaitForDoorbellAck(ioc, 15, sleepFlag)) < 0)
+ return r;
+
+ /* FW ACK'd request, wait for READY state
+@@ -3988,15 +4164,15 @@ SendIocReset(MPT_ADAPTER *ioc, u8 reset_
+ if (sleepFlag != CAN_SLEEP)
+ count *= 10;
+
+- printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
+- ioc->name, (int)((count+5)/HZ));
++ printk(MYIOC_s_ERR_FMT "Wait IOC_READY state (0x%x) timeout(%d)!\n",
++ ioc->name, state, (int)((count+5)/HZ));
+ return -ETIME;
+ }
+
+ if (sleepFlag == CAN_SLEEP) {
+ msleep(1);
+ } else {
+- mdelay (1); /* 1 msec delay */
++ mdelay(1); /* 1 msec delay */
+ }
+ }
+
+@@ -4010,14 +4186,13 @@ SendIocReset(MPT_ADAPTER *ioc, u8 reset_
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * initChainBuffers - Allocate memory for and initialize chain buffers
+ * @ioc: Pointer to MPT_ADAPTER structure
+ *
+ * Allocates memory for and initializes chain buffers,
+ * chain buffer control arrays and spinlock.
+- */
++ **/
+ static int
+ initChainBuffers(MPT_ADAPTER *ioc)
+ {
+@@ -4059,24 +4234,30 @@ initChainBuffers(MPT_ADAPTER *ioc)
+ * num_sge = num sge in request frame + last chain buffer
+ * scale = num sge per chain buffer if no chain element
+ */
+- scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
+- if (sizeof(dma_addr_t) == sizeof(u64))
+- num_sge = scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
++ scale = ioc->req_sz/ ioc->SGE_size;
++ if (ioc->sg_addr_size == sizeof(u64))
++ num_sge = scale + (ioc->req_sz - 60) / ioc->SGE_size;
+ else
+- num_sge = 1+ scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
++ num_sge = 1+ scale + (ioc->req_sz - 64) / ioc->SGE_size;
+
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
++ if (ioc->sg_addr_size == sizeof(u64)) {
+ numSGE = (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
++ (ioc->req_sz - 60) / ioc->SGE_size;
+ } else {
+ numSGE = 1 + (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
++ (ioc->req_sz - 64) / ioc->SGE_size;
+ }
+ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "num_sge=%d numSGE=%d\n",
+ ioc->name, num_sge, numSGE));
+
+- if ( numSGE > MPT_SCSI_SG_DEPTH )
+- numSGE = MPT_SCSI_SG_DEPTH;
++ if (ioc->bus_type == FC) {
++ if (numSGE > MPT_SCSI_FC_SG_DEPTH)
++ numSGE = MPT_SCSI_FC_SG_DEPTH;
++ }
++ else {
++ if (numSGE > MPT_SCSI_SG_DEPTH)
++ numSGE = MPT_SCSI_SG_DEPTH;
++ }
+
+ num_chain = 1;
+ while (numSGE - num_sge > 0) {
+@@ -4111,7 +4292,6 @@ initChainBuffers(MPT_ADAPTER *ioc)
+ return num_chain;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * PrimeIocFifos - Initialize IOC request and reply FIFOs.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -4121,7 +4301,7 @@ initChainBuffers(MPT_ADAPTER *ioc)
+ * reply frames.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ PrimeIocFifos(MPT_ADAPTER *ioc)
+ {
+@@ -4130,13 +4310,36 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
+ dma_addr_t alloc_dma;
+ u8 *mem;
+ int i, reply_sz, sz, total_size, num_chain;
++ u64 dma_mask;
+
+- /* Prime reply FIFO... */
++ dma_mask = 0;
+
++ /* Prime reply FIFO... */
+ if (ioc->reply_frames == NULL) {
+ if ( (num_chain = initChainBuffers(ioc)) < 0)
+ return -1;
+
++ /*
++ * 1078 errata workaround for the 36GB limitation
++ */
++ if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078 &&
++ ioc->dma_mask > MPT_DMA_35BIT_MASK) {
++ if (!pci_set_dma_mask(ioc->pcidev, DMA_32BIT_MASK)
++ && !pci_set_consistent_dma_mask(ioc->pcidev,
++ DMA_32BIT_MASK)) {
++ dma_mask = MPT_DMA_35BIT_MASK;
++ d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "setting 35 bit addressing for "
++ "Request/Reply/Chain and Sense Buffers\n",
++ ioc->name));
++ } else {
++ d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "failed setting 35 bit addressing for "
++ "Request/Reply/Chain and Sense Buffers\n",
++ ioc->name));
++ }
++ }
++
+ total_size = reply_sz = (ioc->reply_sz * ioc->reply_depth);
+ dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d bytes, ReplyDepth=%d\n",
+ ioc->name, ioc->reply_sz, ioc->reply_depth));
+@@ -4274,9 +4477,16 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
+ alloc_dma += ioc->reply_sz;
+ }
+
++ if (dma_mask == MPT_DMA_35BIT_MASK && !pci_set_dma_mask(ioc->pcidev,
++ ioc->dma_mask) && !pci_set_consistent_dma_mask(ioc->pcidev,
++ ioc->dma_mask))
++ d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "restoring 64 bit addressing\n", ioc->name));
++
+ return 0;
+
+ out_fail:
++
+ if (ioc->alloc != NULL) {
+ sz = ioc->alloc_sz;
+ pci_free_consistent(ioc->pcidev,
+@@ -4293,10 +4503,16 @@ out_fail:
+ ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
+ ioc->sense_buf_pool = NULL;
+ }
++
++ if (dma_mask == MPT_DMA_35BIT_MASK && !pci_set_dma_mask(ioc->pcidev,
++ DMA_64BIT_MASK) && !pci_set_consistent_dma_mask(ioc->pcidev,
++ DMA_64BIT_MASK))
++ d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "restoring 64 bit addressing\n", ioc->name));
++
+ return -1;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_handshake_req_reply_wait - Send MPT request to and receive reply
+ * from IOC via doorbell handshake method.
+@@ -4314,7 +4530,7 @@ out_fail:
+ * greater than 1 byte in size.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
+ int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
+@@ -4408,7 +4624,6 @@ mpt_handshake_req_reply_wait(MPT_ADAPTER
+ return -failcnt;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * WaitForDoorbellAck - Wait for IOC doorbell handshake acknowledge
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -4420,7 +4635,7 @@ mpt_handshake_req_reply_wait(MPT_ADAPTER
+ * bit in its IntStatus register being clear.
+ *
+ * Returns a negative value on failure, else wait loop count.
+- */
++ **/
+ static int
+ WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
+ {
+@@ -4459,7 +4674,6 @@ WaitForDoorbellAck(MPT_ADAPTER *ioc, int
+ return -1;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * WaitForDoorbellInt - Wait for IOC to set its doorbell interrupt bit
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -4470,7 +4684,7 @@ WaitForDoorbellAck(MPT_ADAPTER *ioc, int
+ * (MPI_HIS_DOORBELL_INTERRUPT) to be set in the IntStatus register.
+ *
+ * Returns a negative value on failure, else wait loop count.
+- */
++ **/
+ static int
+ WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
+ {
+@@ -4481,18 +4695,18 @@ WaitForDoorbellInt(MPT_ADAPTER *ioc, int
+ cntdn = 1000 * howlong;
+ if (sleepFlag == CAN_SLEEP) {
+ while (--cntdn) {
++ msleep(1);
+ intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
+ if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
+ break;
+- msleep(1);
+ count++;
+ }
+ } else {
+ while (--cntdn) {
++ udelay (1000);
+ intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
+ if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
+ break;
+- udelay (1000);
+ count++;
+ }
+ }
+@@ -4508,7 +4722,6 @@ WaitForDoorbellInt(MPT_ADAPTER *ioc, int
+ return -1;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * WaitForDoorbellReply - Wait for and capture an IOC handshake reply.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -4520,7 +4733,7 @@ WaitForDoorbellInt(MPT_ADAPTER *ioc, int
+ * of 128 bytes of reply data.
+ *
+ * Returns a negative value on failure, else size of reply in WORDS.
+- */
++ **/
+ static int
+ WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
+ {
+@@ -4594,7 +4807,6 @@ WaitForDoorbellReply(MPT_ADAPTER *ioc, i
+ return u16cnt/2;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * GetLanConfigPages - Fetch LANConfig pages.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -4604,7 +4816,7 @@ WaitForDoorbellReply(MPT_ADAPTER *ioc, i
+ * -EPERM if not allowed due to ISR context
+ * -EAGAIN if no msg frames currently available
+ * -EFAULT for non-successful reply or no reply (timeout)
+- */
++ **/
+ static int
+ GetLanConfigPages(MPT_ADAPTER *ioc)
+ {
+@@ -4705,7 +4917,6 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
+ return rc;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mptbase_sas_persist_operation - Perform operation on SAS Persistent Table
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -4718,9 +4929,7 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
+ * NOTE: Don't use not this function during interrupt time.
+ *
+ * Returns 0 for success, non-zero error
+- */
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++ **/
+ int
+ mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
+ {
+@@ -4728,7 +4937,14 @@ mptbase_sas_persist_operation(MPT_ADAPTE
+ SasIoUnitControlReply_t *sasIoUnitCntrReply;
+ MPT_FRAME_HDR *mf = NULL;
+ MPIHeader_t *mpi_hdr;
++ int ret = 0;
++ unsigned long timeleft;
++
++ mutex_lock(&ioc->mptbase_cmds.mutex);
+
++ /* init the internal cmd struct */
++ memset(ioc->mptbase_cmds.reply, 0 , MPT_DEFAULT_FRAME_SIZE);
++ INITIALIZE_MGMT_STATUS(ioc->mptbase_cmds.status)
+
+ /* insure garbage is not sent to fw */
+ switch(persist_opcode) {
+@@ -4738,17 +4954,18 @@ mptbase_sas_persist_operation(MPT_ADAPTE
+ break;
+
+ default:
+- return -1;
+- break;
++ ret = -1;
++ goto out;
+ }
+
+- printk("%s: persist_opcode=%x\n",__func__, persist_opcode);
++ printk("%s: persist_opcode=%x\n",__FUNCTION__, persist_opcode);
+
+ /* Get a MF for this command.
+ */
+ if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
+- printk("%s: no msg frames!\n",__func__);
+- return -1;
++ printk("%s: no msg frames!\n",__FUNCTION__);
++ ret = -1;
++ goto out;
+ }
+
+ mpi_hdr = (MPIHeader_t *) mf;
+@@ -4758,31 +4975,44 @@ mptbase_sas_persist_operation(MPT_ADAPTE
+ sasIoUnitCntrReq->MsgContext = mpi_hdr->MsgContext;
+ sasIoUnitCntrReq->Operation = persist_opcode;
+
+- init_timer(&ioc->persist_timer);
+- ioc->persist_timer.data = (unsigned long) ioc;
+- ioc->persist_timer.function = mpt_timer_expired;
+- ioc->persist_timer.expires = jiffies + HZ*10 /* 10 sec */;
+- ioc->persist_wait_done=0;
+- add_timer(&ioc->persist_timer);
+ mpt_put_msg_frame(mpt_base_index, ioc, mf);
+- wait_event(mpt_waitq, ioc->persist_wait_done);
++ timeleft = wait_for_completion_timeout(&ioc->mptbase_cmds.done, 10*HZ);
++ if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ ret = -ETIME;
++ printk("%s: failed\n", __FUNCTION__);
++ if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
++ goto out;
++ if (!timeleft) {
++ printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
++ ioc->name, __FUNCTION__);
++ if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
++ mpt_HardResetHandler(ioc, CAN_SLEEP);
++ mpt_free_msg_frame(ioc, mf);
++ }
++ goto out;
++ }
++
++ if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
++ ret = -1;
++ goto out;
++ }
+
+ sasIoUnitCntrReply =
+- (SasIoUnitControlReply_t *)ioc->persist_reply_frame;
++ (SasIoUnitControlReply_t *)ioc->mptbase_cmds.reply;
+ if (le16_to_cpu(sasIoUnitCntrReply->IOCStatus) != MPI_IOCSTATUS_SUCCESS) {
+- printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
+- __func__,
+- sasIoUnitCntrReply->IOCStatus,
+- sasIoUnitCntrReply->IOCLogInfo);
+- return -1;
+- }
++ printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n", __FUNCTION__,
++ sasIoUnitCntrReply->IOCStatus, sasIoUnitCntrReply->IOCLogInfo);
++ printk("%s: failed\n",__FUNCTION__);
++ ret = -1;
++ } else
++ printk("%s: success\n",__FUNCTION__);
++ out:
+
+- printk("%s: success\n",__func__);
+- return 0;
++ CLEAR_MGMT_STATUS(ioc->mptbase_cmds.status)
++ mutex_unlock(&ioc->mptbase_cmds.mutex);
++ return ret;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-
+ static void
+ mptbase_raid_process_event_data(MPT_ADAPTER *ioc,
+ MpiEventDataRaid_t * pRaidEventData)
+@@ -4913,7 +5143,6 @@ mptbase_raid_process_event_data(MPT_ADAP
+ }
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * GetIoUnitPage2 - Retrieve BIOS version and boot order information.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -4923,7 +5152,7 @@ mptbase_raid_process_event_data(MPT_ADAP
+ * -EPERM if not allowed due to ISR context
+ * -EAGAIN if no msg frames currently available
+ * -EFAULT for non-successful reply or no reply (timeout)
+- */
++ **/
+ static int
+ GetIoUnitPage2(MPT_ADAPTER *ioc)
+ {
+@@ -4971,7 +5200,6 @@ GetIoUnitPage2(MPT_ADAPTER *ioc)
+ return rc;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
+ * @ioc: Pointer to a Adapter Strucutre
+@@ -4991,7 +5219,7 @@ GetIoUnitPage2(MPT_ADAPTER *ioc)
+ * Both valid
+ * Return 0
+ * CHECK - what type of locking mechanisms should be used????
+- */
++ **/
+ static int
+ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
+ {
+@@ -5051,8 +5279,8 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
+ ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
+ rc = 1;
+ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Unable to read PortPage0 minSyncFactor=%x\n",
+- ioc->name, ioc->spi_data.minSyncFactor));
++ "Unable to read PortPage0 minSyncFactor=%x\n",
++ ioc->name, ioc->spi_data.minSyncFactor));
+ } else {
+ /* Save the Port Page 0 data
+ */
+@@ -5062,8 +5290,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
+
+ if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 ) {
+ ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "noQas due to Capabilities=%x\n",
++ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "noQas due to Capabilities=%x\n",
+ ioc->name, pPP0->Capabilities));
+ }
+ ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
+@@ -5072,8 +5299,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
+ ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
+ data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
+ ioc->spi_data.minSyncFactor = (u8) (data >> 8);
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "PortPage0 minSyncFactor=%x\n",
++ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PortPage0 minSyncFactor=%x\n",
+ ioc->name, ioc->spi_data.minSyncFactor));
+ } else {
+ ioc->spi_data.maxSyncOffset = 0;
+@@ -5089,8 +5315,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
+
+ if (ioc->spi_data.minSyncFactor < MPT_ULTRA) {
+ ioc->spi_data.minSyncFactor = MPT_ULTRA;
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "HVD or SE detected, minSyncFactor=%x\n",
++ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HVD or SE detected, minSyncFactor=%x\n",
+ ioc->name, ioc->spi_data.minSyncFactor));
+ }
+ }
+@@ -5195,7 +5420,6 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
+ return rc;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_readScsiDevicePageHeaders - save version and length of SDP1
+ * @ioc: Pointer to a Adapter Strucutre
+@@ -5203,7 +5427,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
+ *
+ * Return: -EFAULT if read of config page header fails
+ * or 0 if success.
+- */
++ **/
+ static int
+ mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
+ {
+@@ -5246,9 +5470,73 @@ mpt_readScsiDevicePageHeaders(MPT_ADAPTE
+ return 0;
+ }
+
++static void
++mpt_read_ioc_pg_6(MPT_ADAPTER *ioc)
++{
++ CONFIGPARMS cfg;
++ ConfigPageHeader_t header;
++ IOCPage6_t *pIoc6=NULL;
++ dma_addr_t ioc6_dma;
++ int iocpage6sz;
++ void *mem;
++
++ /* Free the old page
++ */
++ if (ioc->raid_data.pIocPg6) {
++ kfree(ioc->raid_data.pIocPg6);
++ ioc->raid_data.pIocPg6 = NULL;
++ }
++
++ /* There is at least one physical disk.
++ * Read and save IOC Page 3
++ */
++ header.PageVersion = 0;
++ header.PageLength = 0;
++ header.PageNumber = 6;
++ header.PageType = MPI_CONFIG_PAGETYPE_IOC;
++ cfg.cfghdr.hdr = &header;
++ cfg.physAddr = -1;
++ cfg.pageAddr = 0;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0;
++ cfg.timeout = 0;
++ if (mpt_config(ioc, &cfg) != 0)
++ goto out;
++
++ if (header.PageLength == 0)
++ goto out;
++
++ /* Read Header good, alloc memory
++ */
++ iocpage6sz = header.PageLength * 4;
++ pIoc6 = pci_alloc_consistent(ioc->pcidev, iocpage6sz, &ioc6_dma);
++ if (!pIoc6)
++ goto out;
++
++ /* Read the Page and save the data
++ * into malloc'd memory.
++ */
++ cfg.physAddr = ioc6_dma;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ if (mpt_config(ioc, &cfg) != 0)
++ goto out;
++
++ mem = kmalloc(iocpage6sz, GFP_ATOMIC);
++ if (!mem)
++ goto out;
++
++ memcpy(mem, pIoc6, iocpage6sz);
++ ioc->raid_data.pIocPg6 = mem;
++
++ out:
++ if (pIoc6)
++ pci_free_consistent(ioc->pcidev, iocpage6sz, pIoc6, ioc6_dma);
++}
++
+ /**
+- * mpt_inactive_raid_list_free - This clears this link list.
+- * @ioc : pointer to per adapter structure
++ * mpt_inactive_raid_list_free - This clears this link list.
++ * @ioc : pointer to per adapter structure
++ *
+ **/
+ static void
+ mpt_inactive_raid_list_free(MPT_ADAPTER *ioc)
+@@ -5258,21 +5546,23 @@ mpt_inactive_raid_list_free(MPT_ADAPTER
+ if (list_empty(&ioc->raid_data.inactive_list))
+ return;
+
+- mutex_lock(&ioc->raid_data.inactive_list_mutex);
++ down(&ioc->raid_data.inactive_list_mutex);
+ list_for_each_entry_safe(component_info, pNext,
+ &ioc->raid_data.inactive_list, list) {
+ list_del(&component_info->list);
+ kfree(component_info);
+ }
+- mutex_unlock(&ioc->raid_data.inactive_list_mutex);
++ up(&ioc->raid_data.inactive_list_mutex);
+ }
+
+ /**
+- * mpt_inactive_raid_volumes - sets up link list of phy_disk_nums for devices belonging in an inactive volume
+- *
+- * @ioc : pointer to per adapter structure
+- * @channel : volume channel
+- * @id : volume target id
++ * mpt_inactive_raid_volumes - sets up link list of phy_disk_nums
++ * for devices belonging in an inactive volume
++ *
++ * @ioc : pointer to per adapter structure
++ * @channel : volume channel
++ * @id : volume target id
++ *
+ **/
+ static void
+ mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
+@@ -5281,10 +5571,12 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
+ ConfigPageHeader_t hdr;
+ dma_addr_t dma_handle;
+ pRaidVolumePage0_t buffer = NULL;
+- int i;
++ int i, j;
+ RaidPhysDiskPage0_t phys_disk;
++ RaidPhysDiskPage1_t *phys_disk_1;
+ struct inactive_raid_component_info *component_info;
+ int handle_inactive_volumes;
++ int num_paths, device_is_online;
+
+ memset(&cfg, 0 , sizeof(CONFIGPARMS));
+ memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
+@@ -5323,14 +5615,37 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
+ if (!handle_inactive_volumes)
+ goto out;
+
+- mutex_lock(&ioc->raid_data.inactive_list_mutex);
++ down(&ioc->raid_data.inactive_list_mutex);
+ for (i = 0; i < buffer->NumPhysDisks; i++) {
+ if(mpt_raid_phys_disk_pg0(ioc,
+ buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
+ continue;
+
++ if (phys_disk.PhysDiskStatus.State !=
++ MPI_PHYSDISK0_STATUS_ONLINE)
++ continue;
++
++ /* check to see if device is online by checking phys_disk_pg1 */
++ device_is_online = 0;
++ num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
++ buffer->PhysDisk[i].PhysDiskNum);
++ if (num_paths < 2)
++ continue;
++ phys_disk_1 = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
++ (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
++ if (!phys_disk_1)
++ continue;
++ mpt_raid_phys_disk_pg1(ioc, buffer->PhysDisk[i].PhysDiskNum,
++ phys_disk_1);
++ for (j = 0; j < num_paths && !device_is_online; j++)
++ if (!phys_disk_1->Path[j].Flags)
++ device_is_online = 1;
++ kfree(phys_disk_1);
++ if (!device_is_online)
++ continue;
++
+ if ((component_info = kmalloc(sizeof (*component_info),
+- GFP_KERNEL)) == NULL)
++ GFP_KERNEL)) == NULL)
+ continue;
+
+ component_info->volumeID = id;
+@@ -5343,7 +5658,7 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
+ list_add_tail(&component_info->list,
+ &ioc->raid_data.inactive_list);
+ }
+- mutex_unlock(&ioc->raid_data.inactive_list_mutex);
++ up(&ioc->raid_data.inactive_list_mutex);
+
+ out:
+ if (buffer)
+@@ -5363,7 +5678,7 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
+ * -ENOMEM if pci_alloc failed
+ **/
+ int
+-mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk)
++mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, RaidPhysDiskPage0_t *phys_disk)
+ {
+ CONFIGPARMS cfg;
+ ConfigPageHeader_t hdr;
+@@ -5373,7 +5688,9 @@ mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc,
+
+ memset(&cfg, 0 , sizeof(CONFIGPARMS));
+ memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
++ memset(phys_disk, 0, sizeof(RaidPhysDiskPage0_t));
+
++ hdr.PageVersion = MPI_RAIDPHYSDISKPAGE0_PAGEVERSION;
+ hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
+ cfg.cfghdr.hdr = &hdr;
+ cfg.physAddr = -1;
+@@ -5420,6 +5737,181 @@ mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc,
+ }
+
+ /**
++ * mpt_raid_phys_disk_get_num_paths - returns number paths associated to this phys_num
++ * @ioc: Pointer to a Adapter Structure
++ * @phys_disk_num: io unit unique phys disk num generated by the ioc
++ *
++ * Return:
++ * returns number paths
++ **/
++int
++mpt_raid_phys_disk_get_num_paths(MPT_ADAPTER *ioc, u8 phys_disk_num)
++{
++ CONFIGPARMS cfg;
++ ConfigPageHeader_t hdr;
++ dma_addr_t dma_handle;
++ pRaidPhysDiskPage1_t buffer = NULL;
++ int rc;
++
++ memset(&cfg, 0 , sizeof(CONFIGPARMS));
++ memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
++
++ hdr.PageVersion = MPI_RAIDPHYSDISKPAGE1_PAGEVERSION;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
++ hdr.PageNumber = 1;
++ cfg.cfghdr.hdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ rc = 0;
++ goto out;
++ }
++
++ if (!hdr.PageLength) {
++ rc = 0;
++ goto out;
++ }
++
++ buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
++ &dma_handle);
++
++ if (!buffer) {
++ rc = 0;
++ goto out;
++ }
++
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = phys_disk_num;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ rc = 0;
++ goto out;
++ }
++
++ rc = buffer->NumPhysDiskPaths;
++ out:
++
++ if (buffer)
++ pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
++ dma_handle);
++
++ return rc;
++}
++
++/**
++ * mpt_raid_phys_disk_pg1 - returns phys disk page 1
++ * @ioc: Pointer to a Adapter Structure
++ * @phys_disk_num: io unit unique phys disk num generated by the ioc
++ * @phys_disk: requested payload data returned
++ *
++ * Return:
++ * 0 on success
++ * -EFAULT if read of config page header fails or data pointer not NULL
++ * -ENOMEM if pci_alloc failed
++ **/
++int
++mpt_raid_phys_disk_pg1(MPT_ADAPTER *ioc, u8 phys_disk_num, RaidPhysDiskPage1_t *phys_disk)
++{
++ CONFIGPARMS cfg;
++ ConfigPageHeader_t hdr;
++ dma_addr_t dma_handle;
++ pRaidPhysDiskPage1_t buffer = NULL;
++ int rc;
++ int i;
++ __le64 sas_address;
++
++ memset(&cfg, 0 , sizeof(CONFIGPARMS));
++ memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
++ rc = 0;
++
++ hdr.PageVersion = MPI_RAIDPHYSDISKPAGE1_PAGEVERSION;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
++ hdr.PageNumber = 1;
++ cfg.cfghdr.hdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ rc = -EFAULT;
++ goto out;
++ }
++
++ if (!hdr.PageLength) {
++ rc = -EFAULT;
++ goto out;
++ }
++
++ buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
++ &dma_handle);
++
++ if (!buffer) {
++ rc = -ENOMEM;
++ goto out;
++ }
++
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ cfg.pageAddr = phys_disk_num;
++
++ if (mpt_config(ioc, &cfg) != 0) {
++ rc = -EFAULT;
++ goto out;
++ }
++
++ phys_disk->NumPhysDiskPaths = buffer->NumPhysDiskPaths;
++ phys_disk->PhysDiskNum = phys_disk_num;
++ for (i = 0; i < phys_disk->NumPhysDiskPaths; i++) {
++ phys_disk->Path[i].PhysDiskID = buffer->Path[i].PhysDiskID;
++ phys_disk->Path[i].PhysDiskBus = buffer->Path[i].PhysDiskBus;
++ phys_disk->Path[i].OwnerIdentifier = buffer->Path[i].OwnerIdentifier;
++ phys_disk->Path[i].Flags = le16_to_cpu(buffer->Path[i].Flags);
++ memcpy(&sas_address, &buffer->Path[i].WWID, sizeof(__le64));
++ sas_address = le64_to_cpu(sas_address);
++ memcpy(&phys_disk->Path[i].WWID, &sas_address, sizeof(__le64));
++ memcpy(&sas_address, &buffer->Path[i].OwnerWWID, sizeof(__le64));
++ sas_address = le64_to_cpu(sas_address);
++ memcpy(&phys_disk->Path[i].OwnerWWID, &sas_address, sizeof(__le64));
++ }
++
++ out:
++
++ if (buffer)
++ pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
++ dma_handle);
++
++ return rc;
++}
++
++/**
++ * mpt_sort_ioc_pg2 - compare function for sorting volumes
++ * in ascending order
++ * @a: ioc_pg2 raid volume page
++ * @b: ioc_pg2 raid volume page
++ *
++ * Return:
++ * 0 same, 1 (a is bigger), -1 (b is bigger)
++ **/
++static int
++mpt_sort_ioc_pg2(const void *a, const void *b)
++{
++ ConfigPageIoc2RaidVol_t * volume_a = (ConfigPageIoc2RaidVol_t *)a;
++ ConfigPageIoc2RaidVol_t * volume_b = (ConfigPageIoc2RaidVol_t *)b;
++
++ if (volume_a->VolumeBus == volume_b->VolumeBus) {
++ if (volume_a->VolumeID == volume_b->VolumeID)
++ return 0;
++ if (volume_a->VolumeID < volume_b->VolumeID)
++ return -1;
++ return 1;
++ }
++ if (volume_a->VolumeBus < volume_b->VolumeBus)
++ return -1;
++ return 1;
++}
++
++/**
+ * mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
+ * @ioc: Pointer to a Adapter Strucutre
+ * @portnum: IOC port number
+@@ -5482,16 +5974,22 @@ mpt_findImVolumes(MPT_ADAPTER *ioc)
+ if (!mem)
+ goto out;
+
++ /*
++ * sort volumes in ascending order
++ */
++ sort(pIoc2->RaidVolume, pIoc2->NumActiveVolumes,
++ sizeof(ConfigPageIoc2RaidVol_t), mpt_sort_ioc_pg2, NULL);
+ memcpy(mem, (u8 *)pIoc2, iocpage2sz);
+ ioc->raid_data.pIocPg2 = (IOCPage2_t *) mem;
+
+- mpt_read_ioc_pg_3(ioc);
+-
+ for (i = 0; i < pIoc2->NumActiveVolumes ; i++)
+ mpt_inactive_raid_volumes(ioc,
+ pIoc2->RaidVolume[i].VolumeBus,
+ pIoc2->RaidVolume[i].VolumeID);
+
++ mpt_read_ioc_pg_3(ioc);
++ mpt_read_ioc_pg_6(ioc);
++
+ out:
+ pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
+
+@@ -5651,6 +6149,9 @@ mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
+ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+ if (mpt_config(ioc, &cfg) == 0) {
+
++#if defined(CPQ_CIM)
++ ioc->pci_slot_number = pIoc1->PCISlotNum;
++#endif
+ tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
+ if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
+ tmp = le32_to_cpu(pIoc1->CoalescingTimeout);
+@@ -5671,19 +6172,16 @@ mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
+
+ cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
+ if (mpt_config(ioc, &cfg) == 0) {
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Reset NVRAM Coalescing Timeout to = %d\n",
++ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset NVRAM Coalescing Timeout to = %d\n",
+ ioc->name, MPT_COALESCING_TIMEOUT));
+ } else {
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Reset NVRAM Coalescing Timeout Failed\n",
+- ioc->name));
++ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset NVRAM Coalescing Timeout Failed\n",
++ ioc->name));
+ }
+
+ } else {
+- dprintk(ioc, printk(MYIOC_s_WARN_FMT
+- "Reset of Current Coalescing Timeout Failed!\n",
+- ioc->name));
++ dprintk(ioc, printk(MYIOC_s_WARN_FMT "Reset of Current Coalescing Timeout Failed!\n",
++ ioc->name));
+ }
+ }
+
+@@ -5740,43 +6238,39 @@ mpt_get_manufacturing_pg_0(MPT_ADAPTER *
+ pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * SendEventNotification - Send EventNotification (on or off) request to adapter
+ * @ioc: Pointer to MPT_ADAPTER structure
+ * @EvSwitch: Event switch flags
+- */
++ * @sleepFlag: Specifies whether the process can sleep
++ **/
+ static int
+-SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
++SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch, int sleepFlag)
+ {
+- EventNotification_t *evnp;
+-
+- evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
+- if (evnp == NULL) {
+- devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
+- ioc->name));
+- return 0;
+- }
+- memset(evnp, 0, sizeof(*evnp));
++ EventNotification_t evn;
++ MPIDefaultReply_t reply_buf;
+
+- devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventNotification (%d) request %p\n", ioc->name, EvSwitch, evnp));
++ memset(&evn, 0, sizeof(EventNotification_t));
++ memset(&reply_buf, 0, sizeof(MPIDefaultReply_t));
+
+- evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
+- evnp->ChainOffset = 0;
+- evnp->MsgFlags = 0;
+- evnp->Switch = EvSwitch;
++ evn.Function = MPI_FUNCTION_EVENT_NOTIFICATION;
++ evn.Switch = EvSwitch;
++ evn.MsgContext = cpu_to_le32(mpt_base_index << 16);
+
+- mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
++ devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "Sending EventNotification (%d) request %p\n",
++ ioc->name, EvSwitch, &evn));
+
+- return 0;
++ return mpt_handshake_req_reply_wait(ioc, sizeof(EventNotification_t),
++ (u32*)&evn, sizeof(MPIDefaultReply_t), (u16*)&reply_buf, 30,
++ sleepFlag);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * SendEventAck - Send EventAck request to MPT adapter.
+ * @ioc: Pointer to MPT_ADAPTER structure
+ * @evnp: Pointer to original EventNotification request
+- */
++ **/
+ static int
+ SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
+ {
+@@ -5784,7 +6278,7 @@ SendEventAck(MPT_ADAPTER *ioc, EventNoti
+
+ if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
+ dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
+- ioc->name,__func__));
++ ioc->name,__FUNCTION__));
+ return -1;
+ }
+
+@@ -5803,7 +6297,6 @@ SendEventAck(MPT_ADAPTER *ioc, EventNoti
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_config - Generic function to issue config message
+ * @ioc: Pointer to an adapter structure
+@@ -5816,35 +6309,62 @@ SendEventAck(MPT_ADAPTER *ioc, EventNoti
+ * -EPERM if not allowed due to ISR context
+ * -EAGAIN if no msg frames currently available
+ * -EFAULT for non-successful reply or no reply (timeout)
+- */
++ **/
+ int
+ mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
+ {
+ Config_t *pReq;
++ ConfigReply_t *pReply;
+ ConfigExtendedPageHeader_t *pExtHdr = NULL;
+ MPT_FRAME_HDR *mf;
+- unsigned long flags;
+- int ii, rc;
++ int ii;
+ int flagsLength;
+- int in_isr;
++ long timeout;
++ int ret;
++ u8 page_type = 0, extend_page;
++ unsigned long timeleft;
++ unsigned long flags;
++ u8 issue_hard_reset = 0;
++ u8 retry_count = 0;
+
+- /* Prevent calling wait_event() (below), if caller happens
+- * to be in ISR context, because that is fatal!
+- */
+- in_isr = in_interrupt();
+- if (in_isr) {
+- dcprintk(ioc, printk(MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
+- ioc->name));
++ if (in_interrupt())
+ return -EPERM;
++
++ /* don't send a config page during diag reset */
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
++ if (ioc->ioc_reset_in_progress) {
++ dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: busy with host reset\n", ioc->name, __FUNCTION__));
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
++ return -EBUSY;
++ }
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
++
++ /* don't send if no chance of success */
++ if (!ioc->active ||
++ mpt_GetIocState(ioc, 1) != MPI_IOC_STATE_OPERATIONAL) {
++ dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: ioc not operational, %d, %xh\n",
++ ioc->name, __FUNCTION__, ioc->active,
++ mpt_GetIocState(ioc, 0)));
++ return -EFAULT;
+ }
+
++ retry_config:
++ mutex_lock(&ioc->mptbase_cmds.mutex);
++ /* init the internal cmd struct */
++ memset(ioc->mptbase_cmds.reply, 0 , MPT_DEFAULT_FRAME_SIZE);
++ INITIALIZE_MGMT_STATUS(ioc->mptbase_cmds.status)
++
+ /* Get and Populate a free Frame
+ */
+ if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
+- dcprintk(ioc, printk(MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
+- ioc->name));
+- return -EAGAIN;
++ dcprintk(ioc, printk(MYIOC_s_WARN_FMT
++ "mpt_config: no msg frames!\n", ioc->name));
++ ret = -EAGAIN;
++ goto out;
+ }
++
+ pReq = (Config_t *)mf;
+ pReq->Action = pCfg->action;
+ pReq->Reserved = 0;
+@@ -5870,7 +6390,9 @@ mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS
+ pReq->ExtPageType = pExtHdr->ExtPageType;
+ pReq->Header.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
+
+- /* Page Length must be treated as a reserved field for the extended header. */
++ /* Page Length must be treated as a reserved field for the
++ * extended header.
++ */
+ pReq->Header.PageLength = 0;
+ }
+
+@@ -5883,126 +6405,126 @@ mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS
+ else
+ flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
+
+- if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
++ if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) ==
++ MPI_CONFIG_PAGETYPE_EXTENDED) {
+ flagsLength |= pExtHdr->ExtPageLength * 4;
+-
+- dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
+- ioc->name, pReq->ExtPageType, pReq->Header.PageNumber, pReq->Action));
+- }
+- else {
++ page_type = pReq->ExtPageType;
++ extend_page = 1;
++ } else {
+ flagsLength |= pCfg->cfghdr.hdr->PageLength * 4;
+-
+- dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
+- ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));
++ page_type = pReq->Header.PageType;
++ extend_page = 0;
+ }
+
+- mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
++ dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "Sending Config request type 0x%x, page 0x%x and action %d\n",
++ ioc->name, page_type, pReq->Header.PageNumber, pReq->Action));
+
+- /* Append pCfg pointer to end of mf
+- */
+- *((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) = (void *) pCfg;
+-
+- /* Initalize the timer
+- */
+- init_timer(&pCfg->timer);
+- pCfg->timer.data = (unsigned long) ioc;
+- pCfg->timer.function = mpt_timer_expired;
+- pCfg->wait_done = 0;
+-
+- /* Set the timer; ensure 10 second minimum */
+- if (pCfg->timeout < 10)
+- pCfg->timer.expires = jiffies + HZ*10;
+- else
+- pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
+-
+- /* Add to end of Q, set timer and then issue this command */
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- list_add_tail(&pCfg->linkage, &ioc->configQ);
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+-
+- add_timer(&pCfg->timer);
++ ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
++ timeout = (pCfg->timeout < 15) ? HZ*15 : HZ*pCfg->timeout;
+ mpt_put_msg_frame(mpt_base_index, ioc, mf);
+- wait_event(mpt_waitq, pCfg->wait_done);
+-
+- /* mf has been freed - do not access */
+-
+- rc = pCfg->status;
++ timeleft = wait_for_completion_timeout(&ioc->mptbase_cmds.done, timeout);
++ if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ ret = -ETIME;
++ dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "Failed Sending Config request type 0x%x, page 0x%x,"
++ " action %d, status %xh, time left %ld\n\n",
++ ioc->name, page_type, pReq->Header.PageNumber,
++ pReq->Action, ioc->mptbase_cmds.status, timeleft));
++ if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
++ goto out;
++ if (!timeleft)
++ issue_hard_reset = 1;
++ goto out;
++ }
+
+- return rc;
+-}
++ if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
++ ret = -1;
++ goto out;
++ }
++ pReply = (ConfigReply_t *)ioc->mptbase_cmds.reply;
++ ret = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
++ if (ret == MPI_IOCSTATUS_SUCCESS) {
++ if (extend_page) {
++ pCfg->cfghdr.ehdr->ExtPageLength =
++ le16_to_cpu(pReply->ExtPageLength);
++ pCfg->cfghdr.ehdr->ExtPageType =
++ pReply->ExtPageType;
++ }
++ pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
++ pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
++ pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
++ pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/**
+- * mpt_timer_expired - Callback for timer process.
+- * Used only internal config functionality.
+- * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
+- */
+-static void
+-mpt_timer_expired(unsigned long data)
+-{
+- MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;
++ }
+
+- dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired! \n", ioc->name));
++ if (retry_count)
++ printk(MYIOC_s_INFO_FMT "Retry completed ret=0x%x timeleft=%ld\n",
++ ioc->name, ret, timeleft);
+
+- /* Perform a FW reload */
+- if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
+- printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
++ dcprintk(ioc, printk(KERN_DEBUG "IOCStatus=%04xh, IOCLogInfo=%08xh\n",
++ ret, le32_to_cpu(pReply->IOCLogInfo)));
+
+- /* No more processing.
+- * Hard reset clean-up will wake up
+- * process and free all resources.
+- */
+- dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired complete!\n", ioc->name));
++ out:
+
+- return;
++ CLEAR_MGMT_STATUS(ioc->mptbase_cmds.status)
++ mutex_unlock(&ioc->mptbase_cmds.mutex);
++ if (issue_hard_reset) {
++ issue_hard_reset = 0;
++ printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
++ ioc->name, __FUNCTION__);
++ if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
++ mpt_HardResetHandler(ioc, CAN_SLEEP);
++ mpt_free_msg_frame(ioc, mf);
++ /* attempt one retry for a timed out command */
++ if (!retry_count) {
++ printk(MYIOC_s_INFO_FMT
++ "Attempting Retry Config request type 0x%x, page 0x%x,"
++ " action %d\n", ioc->name, page_type,
++ pCfg->cfghdr.hdr->PageNumber, pCfg->action);
++ retry_count++;
++ goto retry_config;
++ }
++ }
++ return ret;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/**
+- * mpt_ioc_reset - Base cleanup for hard reset
+- * @ioc: Pointer to the adapter structure
+- * @reset_phase: Indicates pre- or post-reset functionality
+- *
+- * Remark: Frees resources with internally generated commands.
+- */
+-static int
+-mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
+-{
+- CONFIGPARMS *pCfg;
+- unsigned long flags;
+-
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- ": IOC %s_reset routed to MPT base driver!\n",
+- ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
+- reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
+-
+- if (reset_phase == MPT_IOC_SETUP_RESET) {
+- ;
+- } else if (reset_phase == MPT_IOC_PRE_RESET) {
+- /* If the internal config Q is not empty -
+- * delete timer. MF resources will be freed when
+- * the FIFO's are primed.
+- */
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- list_for_each_entry(pCfg, &ioc->configQ, linkage)
+- del_timer(&pCfg->timer);
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+-
+- } else {
+- CONFIGPARMS *pNext;
+-
+- /* Search the configQ for internal commands.
+- * Flush the Q, and wake up all suspended threads.
+- */
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- list_for_each_entry_safe(pCfg, pNext, &ioc->configQ, linkage) {
+- list_del(&pCfg->linkage);
+-
+- pCfg->status = MPT_CONFIG_ERROR;
+- pCfg->wait_done = 1;
+- wake_up(&mpt_waitq);
++/**
++ * mpt_ioc_reset - Base cleanup for hard reset
++ * @ioc: Pointer to the adapter structure
++ * @reset_phase: Indicates pre- or post-reset functionality
++ *
++ * Remark: Frees resources with internally generated commands.
++ **/
++static int
++mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
++{
++ switch(reset_phase) {
++ case MPT_IOC_SETUP_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
++ ioc->taskmgmt_quiesce_io = 1;
++ break;
++ case MPT_IOC_PRE_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
++ break;
++ case MPT_IOC_POST_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
++/* wake up mptbase_cmds */
++ if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->mptbase_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
++ complete(&ioc->mptbase_cmds.done);
++ }
++/* wake up taskmgmt_cmds */
++ if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
++ complete(&ioc->taskmgmt_cmds.done);
+ }
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
++ break;
++ default:
++ break;
+ }
+
+ return 1; /* currently means nothing really */
+@@ -6010,16 +6532,11 @@ mpt_ioc_reset(MPT_ADAPTER *ioc, int rese
+
+
+ #ifdef CONFIG_PROC_FS /* { */
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
+- * procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
+- */
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int
+ procmpt_create(void)
+ {
+@@ -6040,12 +6557,11 @@ procmpt_create(void)
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static void
+ procmpt_destroy(void)
+ {
+@@ -6054,7 +6570,6 @@ procmpt_destroy(void)
+ remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * procmpt_summary_read - Handle read request of a summary file
+ * @buf: Pointer to area to write information
+@@ -6066,7 +6581,7 @@ procmpt_destroy(void)
+ *
+ * Handles read request from /proc/mpt/summary or /proc/mpt/iocN/summary.
+ * Returns number of characters written to process performing the read.
+- */
++ **/
+ static int
+ procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
+ {
+@@ -6098,7 +6613,6 @@ procmpt_summary_read(char *buf, char **s
+ MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * procmpt_version_read - Handle read request from /proc/mpt/version.
+ * @buf: Pointer to area to write information
+@@ -6109,7 +6623,7 @@ procmpt_summary_read(char *buf, char **s
+ * @data: Pointer
+ *
+ * Returns number of characters written to process performing the read.
+- */
++ **/
+ static int
+ procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
+ {
+@@ -6154,7 +6668,6 @@ procmpt_version_read(char *buf, char **s
+ MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
+ * @buf: Pointer to area to write information
+@@ -6165,7 +6678,7 @@ procmpt_version_read(char *buf, char **s
+ * @data: Pointer
+ *
+ * Returns number of characters written to process performing the read.
+- */
++ **/
+ static int
+ procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
+ {
+@@ -6251,7 +6764,6 @@ procmpt_iocinfo_read(char *buf, char **s
+
+ #endif /* CONFIG_PROC_FS } */
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ static void
+ mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
+ {
+@@ -6267,7 +6779,6 @@ mpt_get_fw_exp_ver(char *buf, MPT_ADAPTE
+ }
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -6278,7 +6789,7 @@ mpt_get_fw_exp_ver(char *buf, MPT_ADAPTE
+ *
+ * This routine writes (english readable) ASCII text, which represents
+ * a summary of IOC information, to a buffer.
+- */
++ **/
+ void
+ mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
+ {
+@@ -6319,6 +6830,220 @@ mpt_print_ioc_summary(MPT_ADAPTER *ioc,
+ /*
+ * Reset Handling
+ */
++
++/**
++ * mpt_set_taskmgmt_in_progress_flag - set flags associated with task managment
++ * @ioc: Pointer to MPT_ADAPTER structure
++ *
++ * Returns 0 for SUCCESS or -1 if FAILED.
++ *
++ * If -1 is return, then it was not possible to set the flags
++ **/
++int
++mpt_set_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc)
++{
++ unsigned long flags;
++ int retval;
++
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
++ if (ioc->ioc_reset_in_progress || ioc->taskmgmt_in_progress ||
++ (ioc->alt_ioc && ioc->alt_ioc->taskmgmt_in_progress)) {
++ retval = -1;
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
++ goto out;
++ }
++ retval = 0;
++ ioc->taskmgmt_in_progress = 1;
++ ioc->taskmgmt_quiesce_io = 1;
++ if (ioc->alt_ioc) {
++ ioc->alt_ioc->taskmgmt_in_progress = 1;
++ ioc->alt_ioc->taskmgmt_quiesce_io = 1;
++ }
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
++
++ out:
++ return retval;
++}
++
++/**
++ * mpt_clear_taskmgmt_in_progress_flag - clear flags associated with task managment
++ * @ioc: Pointer to MPT_ADAPTER structure
++ *
++ **/
++void
++mpt_clear_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc)
++{
++ unsigned long flags;
++
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
++ ioc->taskmgmt_in_progress = 0;
++ ioc->taskmgmt_quiesce_io = 0;
++ if (ioc->alt_ioc) {
++ ioc->alt_ioc->taskmgmt_in_progress = 0;
++ ioc->alt_ioc->taskmgmt_quiesce_io = 0;
++ }
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
++}
++
++/**
++ * mpt_halt_firmware - Halts the firmware if it is operational and panic
++ * the kernel
++ * @ioc: Pointer to MPT_ADAPTER structure
++ *
++ **/
++void
++mpt_halt_firmware(MPT_ADAPTER *ioc)
++{
++ u32 ioc_raw_state;
++
++ ioc_raw_state = mpt_GetIocState(ioc, 0);
++
++ if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
++ printk(MYIOC_s_ERR_FMT "IOC is in FAULT state (%04xh)!!!\n",
++ ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
++ if(mpt_fwfault_debug == 2)
++ for(;;);
++ else
++ panic("%s: IOC Fault (%04xh)!!!\n",ioc->name,
++ ioc_raw_state & MPI_DOORBELL_DATA_MASK);
++ } else {
++ CHIPREG_WRITE32(&ioc->chip->Doorbell, 0xC0FFEE00);
++ if(mpt_fwfault_debug == 2) {
++ printk("%s: Firmware is halted due to command timeout\n"
++ ,ioc->name);
++ for(;;);
++ }
++ else
++ panic("%s: Firmware is halted due to command timeout\n",
++ ioc->name);
++ }
++}
++
++/**
++ * 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;
++ }
++
++ 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);
++ }
++
++ /* 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 */
++ if ((rc = GetIocFacts(ioc, sleepFlag,
++ MPT_HOSTEVENT_IOC_RECOVER)) == 0)
++ break;
++ if (sleepFlag == CAN_SLEEP) {
++ msleep(100);
++ } else {
++ mdelay(100);
++ }
++ }
++ if (ii == 5)
++ goto out;
++
++ if ((rc = PrimeIocFifos(ioc)) != 0)
++ goto out;
++
++ if ((rc = SendIocInit(ioc, sleepFlag)) != 0)
++ goto out;
++
++ if ((rc = SendEventNotification(ioc, 1, sleepFlag)) != 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_HardResetHandler - Generic reset handler
+@@ -6335,12 +7060,14 @@ mpt_print_ioc_summary(MPT_ADAPTER *ioc,
+ * FW reload/initialization failed.
+ *
+ * Returns 0 for SUCCESS or -1 if FAILED.
+- */
++ **/
+ int
+ mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
+ {
+- int rc;
++ int rc;
++ u8 cb_idx;
+ unsigned long flags;
++ unsigned long time_count;
+
+ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler Entered!\n", ioc->name));
+ #ifdef MFCNT
+@@ -6348,67 +7075,82 @@ mpt_HardResetHandler(MPT_ADAPTER *ioc, i
+ printk("MF count 0x%x !\n", ioc->mfcnt);
+ #endif
+
++ if(mpt_fwfault_debug)
++ mpt_halt_firmware(ioc);
++
+ /* Reset the adapter. Prevent more than 1 call to
+ * mpt_do_ioc_recovery at any instant in time.
+ */
+- spin_lock_irqsave(&ioc->diagLock, flags);
+- if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
+- spin_unlock_irqrestore(&ioc->diagLock, flags);
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
++ if (ioc->ioc_reset_in_progress) {
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+ return 0;
+- } else {
+- ioc->diagPending = 1;
+ }
+- spin_unlock_irqrestore(&ioc->diagLock, flags);
++ ioc->ioc_reset_in_progress = 1;
++ if (ioc->alt_ioc)
++ ioc->alt_ioc->ioc_reset_in_progress = 1;
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+
+- /* FIXME: If do_ioc_recovery fails, repeat....
+- */
+
+ /* The SCSI driver needs to adjust timeouts on all current
+ * commands prior to the diagnostic reset being issued.
+ * Prevents timeouts occurring during a diagnostic reset...very bad.
+ * For all other protocol drivers, this is a no-op.
+ */
+- {
+- u8 cb_idx;
+- int r = 0;
+-
+- for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
+- if (MptResetHandlers[cb_idx]) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling IOC reset_setup handler #%d\n",
+- ioc->name, cb_idx));
+- r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
+- if (ioc->alt_ioc) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling alt-%s setup reset handler #%d\n",
+- ioc->name, ioc->alt_ioc->name, cb_idx));
+- r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
+- }
+- }
++ 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);
++ if (ioc->alt_ioc)
++ mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
+ }
+ }
+
++ time_count = jiffies;
+ if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
+- printk(MYIOC_s_WARN_FMT "Cannot recover rc = %d!\n", ioc->name, rc);
++ printk(KERN_WARNING MYNAM ": WARNING - (%d) Cannot recover %s\n",
++ rc, ioc->name);
++ } else {
++ if (ioc->hard_resets < -1)
++ ioc->hard_resets++;
+ }
+- ioc->reload_fw = 0;
+- if (ioc->alt_ioc)
+- ioc->alt_ioc->reload_fw = 0;
+
+- spin_lock_irqsave(&ioc->diagLock, flags);
+- ioc->diagPending = 0;
+- if (ioc->alt_ioc)
+- ioc->alt_ioc->diagPending = 0;
+- spin_unlock_irqrestore(&ioc->diagLock, flags);
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
++ ioc->ioc_reset_in_progress = 0;
++ ioc->taskmgmt_quiesce_io = 0;
++ ioc->taskmgmt_in_progress = 0;
++ if (ioc->alt_ioc) {
++ ioc->alt_ioc->ioc_reset_in_progress = 0;
++ ioc->alt_ioc->taskmgmt_quiesce_io = 0;
++ ioc->alt_ioc->taskmgmt_in_progress = 0;
++ }
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
++ 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);
++ if (ioc->alt_ioc)
++ mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
++ }
++ }
+
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler: completed (%d seconds): %s\n",
++ ioc->name, jiffies_to_msecs(jiffies - time_count)/1000,
++ ((rc == 0) ? "SUCCESS" : "FAILED")));
+ return rc;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++#ifdef CONFIG_FUSION_LOGGING
+ static void
+-EventDescriptionStr(u8 event, u32 evData0, char *evStr)
++mpt_display_event_info(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply)
+ {
+ char *ds = NULL;
++ u32 evData0;
++ int ii;
++ u8 event;
++ char *evStr = ioc->evStr;
++
++ event = le32_to_cpu(pEventReply->Event) & 0xFF;
++ evData0 = le32_to_cpu(pEventReply->Data[0]);
+
+ switch(event) {
+ case MPI_EVENT_NONE:
+@@ -6442,9 +7184,9 @@ EventDescriptionStr(u8 event, u32 evData
+ if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
+ ds = "Loop State(LIP) Change";
+ else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
+- ds = "Loop State(LPE) Change"; /* ??? */
++ ds = "Loop State(LPE) Change";
+ else
+- ds = "Loop State(LPB) Change"; /* ??? */
++ ds = "Loop State(LPB) Change";
+ break;
+ case MPI_EVENT_LOGOUT:
+ ds = "Logout";
+@@ -6540,6 +7282,11 @@ EventDescriptionStr(u8 event, u32 evData
+ "SAS Device Status Change: Internal Device "
+ "Reset : id=%d channel=%d", id, channel);
+ break;
++ case MPI_EVENT_SAS_DEV_STAT_RC_CMPL_INTERNAL_DEV_RESET:
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "SAS Device Status Change: Internal Device "
++ "Reset Completed: id=%d channel=%d", id, channel);
++ break;
+ case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
+ snprintf(evStr, EVENT_DESCR_STR_SZ,
+ "SAS Device Status Change: Internal Task "
+@@ -6560,6 +7307,11 @@ EventDescriptionStr(u8 event, u32 evData
+ "SAS Device Status Change: Internal Query "
+ "Task : id=%d channel=%d", id, channel);
+ break;
++ case MPI_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "SAS Device Status Change: Async Notification "
++ "Task : id=%d channel=%d", id, channel);
++ break;
+ default:
+ snprintf(evStr, EVENT_DESCR_STR_SZ,
+ "SAS Device Status Change: Unknown: "
+@@ -6644,28 +7396,65 @@ EventDescriptionStr(u8 event, u32 evData
+ }
+ case MPI_EVENT_IR2:
+ {
++ u8 id = (u8)(evData0);
++ u8 channel = (u8)(evData0 >> 8);
++ u8 phys_num = (u8)(evData0 >> 24);
+ u8 ReasonCode = (u8)(evData0 >> 16);
++
+ switch (ReasonCode) {
+ case MPI_EVENT_IR2_RC_LD_STATE_CHANGED:
+- ds = "IR2: LD State Changed";
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: LD State Changed: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
+ break;
+ case MPI_EVENT_IR2_RC_PD_STATE_CHANGED:
+- ds = "IR2: PD State Changed";
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: PD State Changed "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
+ break;
+ case MPI_EVENT_IR2_RC_BAD_BLOCK_TABLE_FULL:
+- ds = "IR2: Bad Block Table Full";
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: Bad Block Table Full: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
+ break;
+ case MPI_EVENT_IR2_RC_PD_INSERTED:
+- ds = "IR2: PD Inserted";
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: PD Inserted: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
+ break;
+ case MPI_EVENT_IR2_RC_PD_REMOVED:
+- ds = "IR2: PD Removed";
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: PD Removed: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
+ break;
+ case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
+- ds = "IR2: Foreign CFG Detected";
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: Foreign CFG Detected: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
+ break;
+ case MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR:
+- ds = "IR2: Rebuild Medium Error";
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: Rebuild Medium Error: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
++ break;
++ case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: Dual Port Added: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
++ break;
++ case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
++ snprintf(evStr, EVENT_DESCR_STR_SZ,
++ "IR2: Dual Port Removed: "
++ "id=%d channel=%d phys_num=%d",
++ id, channel, phys_num);
+ break;
+ default:
+ ds = "IR2";
+@@ -6689,25 +7478,46 @@ EventDescriptionStr(u8 event, u32 evData
+ {
+ u8 phy_num = (u8)(evData0);
+ u8 port_num = (u8)(evData0 >> 8);
+- u8 port_width = (u8)(evData0 >> 16);
++ u8 num_phys = (u8)(evData0 >> 16);
+ u8 primative = (u8)(evData0 >> 24);
++ char *primative_str = NULL;
++
++ switch (primative) {
++ case MPI_EVENT_PRIMITIVE_CHANGE:
++ primative_str = "change";
++ break;
++ case MPI_EVENT_PRIMITIVE_EXPANDER:
++ primative_str = "expander";
++ break;
++ case MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT:
++ primative_str = "asyn event";
++ break;
++ default:
++ primative_str = "reserved";
++ break;
++ }
+ snprintf(evStr, EVENT_DESCR_STR_SZ,
+- "SAS Broadcase Primative: phy=%d port=%d "
+- "width=%d primative=0x%02x",
+- phy_num, port_num, port_width, primative);
++ "SAS Broadcast Primative: phy=%d port=%d "
++ "num_phys=%d primative=%s (0x%02x)",
++ phy_num, port_num, num_phys, primative_str, primative);
+ break;
+ }
+
+ case MPI_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE:
+ {
+ u8 reason = (u8)(evData0);
+- u8 port_num = (u8)(evData0 >> 8);
+- u16 handle = le16_to_cpu(evData0 >> 16);
+
+- snprintf(evStr, EVENT_DESCR_STR_SZ,
+- "SAS Initiator Device Status Change: reason=0x%02x "
+- "port=%d handle=0x%04x",
+- reason, port_num, handle);
++ switch (reason) {
++ case MPI_EVENT_SAS_INIT_RC_ADDED:
++ ds = "SAS Initiator Status Change: Added";
++ break;
++ case MPI_EVENT_SAS_INIT_RC_REMOVED:
++ ds = "SAS Initiator Status Change: Deleted";
++ break;
++ default:
++ ds = "SAS Initiator Status Change";
++ break;
++ }
+ break;
+ }
+
+@@ -6755,6 +7565,24 @@ EventDescriptionStr(u8 event, u32 evData
+ break;
+ }
+
++ case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
++ {
++ u8 reason = (u8)(evData0);
++
++ switch (reason) {
++ case MPI_EVENT_SAS_EXP_RC_ADDED:
++ ds = "Expander Status Change: Added";
++ break;
++ case MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING:
++ ds = "Expander Status Change: Deleted";
++ break;
++ default:
++ ds = "Expander Status Change";
++ break;
++ }
++ break;
++ }
++
+ /*
+ * MPT base "custom" events may be added here...
+ */
+@@ -6764,9 +7592,21 @@ EventDescriptionStr(u8 event, u32 evData
+ }
+ if (ds)
+ strncpy(evStr, ds, EVENT_DESCR_STR_SZ);
++
++
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "MPT event:(%02Xh) : %s\n",
++ ioc->name, event, evStr));
++
++ devtverboseprintk(ioc, printk(KERN_DEBUG MYNAM
++ ": Event data:\n"));
++ for (ii = 0; ii < le16_to_cpu(pEventReply->EventDataLength); ii++)
++ devtverboseprintk(ioc, printk(" %08x",
++ le32_to_cpu(pEventReply->Data[ii])));
++ devtverboseprintk(ioc, printk(KERN_DEBUG "\n"));
+ }
++#endif
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * ProcessEventNotification - Route EventNotificationReply to all event handlers
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -6776,43 +7616,30 @@ EventDescriptionStr(u8 event, u32 evData
+ * Routes a received EventNotificationReply to all currently registered
+ * event handlers.
+ * Returns sum of event handlers return values.
+- */
++ **/
+ static int
+ ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
+ {
+ u16 evDataLen;
+ u32 evData0 = 0;
+-// u32 evCtx;
+ int ii;
+ u8 cb_idx;
+ int r = 0;
+ int handlers = 0;
+- char evStr[EVENT_DESCR_STR_SZ];
+ u8 event;
+
++
+ /*
+ * Do platform normalization of values
+ */
+ event = le32_to_cpu(pEventReply->Event) & 0xFF;
+-// evCtx = le32_to_cpu(pEventReply->EventContext);
+ evDataLen = le16_to_cpu(pEventReply->EventDataLength);
+- if (evDataLen) {
++ if (evDataLen)
+ evData0 = le32_to_cpu(pEventReply->Data[0]);
+- }
+-
+- EventDescriptionStr(event, evData0, evStr);
+- devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event:(%02Xh) : %s\n",
+- ioc->name,
+- event,
+- evStr));
+
+ #ifdef CONFIG_FUSION_LOGGING
+- devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- ": Event data:\n", ioc->name));
+- for (ii = 0; ii < evDataLen; ii++)
+- devtverboseprintk(ioc, printk(" %08x",
+- le32_to_cpu(pEventReply->Data[ii])));
+- devtverboseprintk(ioc, printk("\n"));
++ if (evDataLen)
++ mpt_display_event_info(ioc, pEventReply);
+ #endif
+
+ /*
+@@ -6867,8 +7694,8 @@ ProcessEventNotification(MPT_ADAPTER *io
+ */
+ for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
+ if (MptEvHandlers[cb_idx]) {
+- devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Routing Event to event handler #%d\n",
+- ioc->name, cb_idx));
++ devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "Routing Event to event handler #%d\n", ioc->name, cb_idx));
+ r += (*(MptEvHandlers[cb_idx]))(ioc, pEventReply);
+ handlers++;
+ }
+@@ -6935,7 +7762,6 @@ mpt_fc_log_info(MPT_ADAPTER *ioc, u32 lo
+ ioc->name, log_info, desc, (log_info & 0xFFFFFF));
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_spi_log_info - Log information returned from SCSI Parallel IOC.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -6943,7 +7769,7 @@ mpt_fc_log_info(MPT_ADAPTER *ioc, u32 lo
+ * @log_info: U32 LogInfo word from the IOC
+ *
+ * Refer to lsi/sp_log.h.
+- */
++ **/
+ static void
+ mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
+ {
+@@ -6953,8 +7779,6 @@ mpt_spi_log_info(MPT_ADAPTER *ioc, u32 l
+ switch (info) {
+ case 0x00010000:
+ desc = "bug! MID not found";
+- if (ioc->reload_fw == 0)
+- ioc->reload_fw++;
+ break;
+
+ case 0x00020000:
+@@ -7149,7 +7973,6 @@ mpt_spi_log_info(MPT_ADAPTER *ioc, u32 l
+ "Compatibility Error: IME Size Limited to < 2TB", /* 3Dh */
+ };
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_sas_log_info - Log information returned from SAS IOC.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -7229,7 +8052,6 @@ union loginfo_type {
+ sas_loginfo.dw.code, sas_loginfo.dw.subcode);
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mpt_iocstatus_info_config - IOCSTATUS information for config pages
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -7531,8 +8353,7 @@ mpt_iocstatus_info(MPT_ADAPTER *ioc, u32
+ if (!desc)
+ return;
+
+- dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n",
+- ioc->name, status, desc));
++ dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n", ioc->name, status, desc));
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+@@ -7543,6 +8364,7 @@ EXPORT_SYMBOL(mpt_resume);
+ EXPORT_SYMBOL(mpt_suspend);
+ #endif
+ EXPORT_SYMBOL(ioc_list);
++EXPORT_SYMBOL(mpt_proc_root_dir);
+ EXPORT_SYMBOL(mpt_register);
+ EXPORT_SYMBOL(mpt_deregister);
+ EXPORT_SYMBOL(mpt_event_register);
+@@ -7555,25 +8377,29 @@ EXPORT_SYMBOL(mpt_get_msg_frame);
+ EXPORT_SYMBOL(mpt_put_msg_frame);
+ EXPORT_SYMBOL(mpt_put_msg_frame_hi_pri);
+ EXPORT_SYMBOL(mpt_free_msg_frame);
+-EXPORT_SYMBOL(mpt_add_sge);
+ EXPORT_SYMBOL(mpt_send_handshake_request);
+ EXPORT_SYMBOL(mpt_verify_adapter);
+ EXPORT_SYMBOL(mpt_GetIocState);
+ EXPORT_SYMBOL(mpt_print_ioc_summary);
+ EXPORT_SYMBOL(mpt_HardResetHandler);
++EXPORT_SYMBOL(mpt_SoftResetHandler);
+ EXPORT_SYMBOL(mpt_config);
+ EXPORT_SYMBOL(mpt_findImVolumes);
+ EXPORT_SYMBOL(mpt_alloc_fw_memory);
+ EXPORT_SYMBOL(mpt_free_fw_memory);
+ EXPORT_SYMBOL(mptbase_sas_persist_operation);
+ EXPORT_SYMBOL(mpt_raid_phys_disk_pg0);
++EXPORT_SYMBOL(mpt_raid_phys_disk_pg1);
++EXPORT_SYMBOL(mpt_raid_phys_disk_get_num_paths);
++EXPORT_SYMBOL(mpt_set_taskmgmt_in_progress_flag);
++EXPORT_SYMBOL(mpt_clear_taskmgmt_in_progress_flag);
++EXPORT_SYMBOL(mpt_halt_firmware);
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * fusion_init - Fusion MPT base driver initialization routine.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int __init
+ fusion_init(void)
+ {
+@@ -7592,7 +8418,7 @@ fusion_init(void)
+ /* Register ourselves (mptbase) in order to facilitate
+ * EventNotification handling.
+ */
+- mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);
++ mpt_base_index = mpt_register(mptbase_reply, MPTBASE_DRIVER);
+
+ /* Register for hard reset handling callbacks.
+ */
+@@ -7604,17 +8430,15 @@ fusion_init(void)
+ return 0;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * fusion_exit - Perform driver unload cleanup.
+ *
+ * This routine frees all resources associated with each MPT adapter
+ * and removes all %MPT_PROCFS_MPTBASEDIR entries.
+- */
++ **/
+ static void __exit
+ fusion_exit(void)
+ {
+-
+ mpt_reset_deregister(mpt_base_index);
+
+ #ifdef CONFIG_PROC_FS
+--- a/drivers/message/fusion/mptbase.h
++++ b/drivers/message/fusion/mptbase.h
+@@ -49,10 +49,6 @@
+ #define MPTBASE_H_INCLUDED
+ /*{-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
+-#include <linux/kernel.h>
+-#include <linux/pci.h>
+-#include <linux/mutex.h>
+-
+ #include "lsi/mpi_type.h"
+ #include "lsi/mpi.h" /* Fusion MPI(nterface) basic defs */
+ #include "lsi/mpi_ioc.h" /* Fusion MPT IOC(ontroller) defs */
+@@ -76,9 +72,13 @@
+ #define COPYRIGHT "Copyright (c) 1999-2008 " MODULEAUTHOR
+ #endif
+
+-#define MPT_LINUX_VERSION_COMMON "3.04.07"
+-#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-3.04.07"
++#define MPT_LINUX_VERSION_COMMON "4.00.43.00"
++#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-4.00.43.00"
+ #define WHAT_MAGIC_STRING "@" "(" "#" ")"
++#define MPT_LINUX_MAJOR_VERSION 4
++#define MPT_LINUX_MINOR_VERSION 00
++#define MPT_LINUX_BUILD_VERSION 43
++#define MPT_LINUX_RELEASE_VERSION 00
+
+ #define show_mptmod_ver(s,ver) \
+ printk(KERN_INFO "%s %s\n", s, ver);
+@@ -87,6 +87,8 @@
+ /*
+ * Fusion MPT(linux) driver configurable stuff...
+ */
++#define MPT_POLLING_INTERVAL 1000 /* in milliseconds */
++
+ #define MPT_MAX_ADAPTERS 18
+ #define MPT_MAX_PROTOCOL_DRIVERS 16
+ #define MPT_MAX_BUS 1 /* Do not change */
+@@ -134,6 +136,8 @@
+
+ #define MPT_COALESCING_TIMEOUT 0x10
+
++#define MPT_DMA_35BIT_MASK 0x00000007ffffffffULL
++
+ /*
+ * SCSI transfer rate defines.
+ */
+@@ -173,10 +177,21 @@
+ #define MPT_SCSI_SG_DEPTH 40
+ #endif
+
++#ifdef CONFIG_FUSION_MAX_FC_SGE
++#if CONFIG_FUSION_MAX_FC_SGE < 16
++#define MPT_SCSI_FC_SG_DEPTH 16
++#elif CONFIG_FUSION_MAX_FC_SGE > 256
++#define MPT_SCSI_FC_SG_DEPTH 256
++#else
++#define MPT_SCSI_FC_SG_DEPTH CONFIG_FUSION_MAX_FC_SGE
++#endif
++#else
++#define MPT_SCSI_FC_SG_DEPTH 40
++#endif
++
+ /* debug print string length used for events and iocstatus */
+-# define EVENT_DESCR_STR_SZ 100
++# define EVENT_DESCR_STR_SZ 100
+
+-#define MPT_POLLING_INTERVAL 1000 /* in milliseconds */
+
+ #ifdef __KERNEL__ /* { */
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+@@ -224,7 +239,6 @@ typedef struct _ATTO_CONFIG_PAGE_SCSI_PO
+ } fATTO_CONFIG_PAGE_SCSI_PORT_2, MPI_POINTER PTR_ATTO_CONFIG_PAGE_SCSI_PORT_2,
+ ATTO_SCSIPortPage2_t, MPI_POINTER pATTO_SCSIPortPage2_t;
+
+-
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /*
+ * MPT protocol driver defs...
+@@ -372,8 +386,8 @@ typedef struct _VirtTarget {
+ struct scsi_target *starget;
+ u8 tflags;
+ u8 ioc_id;
+- u8 id;
+- u8 channel;
++ u8 id; /* logical target id */
++ u8 channel; /* logical channel number */
+ u8 minSyncFactor; /* 0xFF is async */
+ u8 maxOffset; /* 0 if async */
+ u8 maxWidth; /* 0 if narrow, 1 if wide */
+@@ -381,7 +395,7 @@ typedef struct _VirtTarget {
+ u8 raidVolume; /* set, if RAID Volume */
+ u8 type; /* byte 0 of Inquiry data */
+ u8 deleted; /* target in process of being removed */
+- u32 num_luns;
++ int num_luns;
+ } VirtTarget;
+
+ typedef struct _VirtDevice {
+@@ -427,42 +441,33 @@ do { \
+ } while (0)
+
+
+-/*
+- * IOCTL structure and associated defines
+- */
+-
+-#define MPT_IOCTL_STATUS_DID_IOCRESET 0x01 /* IOC Reset occurred on the current*/
+-#define MPT_IOCTL_STATUS_RF_VALID 0x02 /* The Reply Frame is VALID */
+-#define MPT_IOCTL_STATUS_TIMER_ACTIVE 0x04 /* The timer is running */
+-#define MPT_IOCTL_STATUS_SENSE_VALID 0x08 /* Sense data is valid */
+-#define MPT_IOCTL_STATUS_COMMAND_GOOD 0x10 /* Command Status GOOD */
+-#define MPT_IOCTL_STATUS_TMTIMER_ACTIVE 0x20 /* The TM timer is running */
+-#define MPT_IOCTL_STATUS_TM_FAILED 0x40 /* User TM request failed */
+-
+-#define MPTCTL_RESET_OK 0x01 /* Issue Bus Reset */
+-
+-typedef struct _MPT_IOCTL {
+- struct _MPT_ADAPTER *ioc;
+- u8 ReplyFrame[MPT_DEFAULT_FRAME_SIZE]; /* reply frame data */
+- u8 sense[MPT_SENSE_BUFFER_ALLOC];
+- int wait_done; /* wake-up value for this ioc */
+- u8 rsvd;
+- u8 status; /* current command status */
+- u8 reset; /* 1 if bus reset allowed */
+- u8 id; /* target for reset */
+- struct mutex ioctl_mutex;
+-} MPT_IOCTL;
+-
+-#define MPT_SAS_MGMT_STATUS_RF_VALID 0x02 /* The Reply Frame is VALID */
+-#define MPT_SAS_MGMT_STATUS_COMMAND_GOOD 0x10 /* Command Status GOOD */
+-#define MPT_SAS_MGMT_STATUS_TM_FAILED 0x40 /* User TM request failed */
++#define MPT_MGMT_STATUS_RF_VALID 0x01 /* The Reply Frame is VALID */
++#define MPT_MGMT_STATUS_COMMAND_GOOD 0x02 /* Command Status GOOD */
++#define MPT_MGMT_STATUS_PENDING 0x04 /* command is pending */
++#define MPT_MGMT_STATUS_DID_IOCRESET 0x08 /* IOC Reset occurred on the current*/
++#define MPT_MGMT_STATUS_SENSE_VALID 0x10 /* valid sense info */
++#define MPT_MGMT_STATUS_TIMER_ACTIVE 0x20 /* obsolete */
++#define MPT_MGMT_STATUS_FREE_MF 0x40 /* free the mf from complete routine */
++
++
++#define INITIALIZE_MGMT_STATUS(status) \
++ status = MPT_MGMT_STATUS_PENDING;
++#define CLEAR_MGMT_STATUS(status) \
++ status = 0;
++#define CLEAR_MGMT_PENDING_STATUS(status) \
++ status &= ~MPT_MGMT_STATUS_PENDING;
++#define SET_MGMT_MSG_CONTEXT(msg_context, value) \
++ msg_context = value;
+
+-typedef struct _MPT_SAS_MGMT {
++typedef struct _MPT_MGMT {
+ struct mutex mutex;
+ struct completion done;
+ u8 reply[MPT_DEFAULT_FRAME_SIZE]; /* reply frame data */
++ u8 sense[MPT_SENSE_BUFFER_ALLOC];
+ u8 status; /* current command status */
+-}MPT_SAS_MGMT;
++ int completion_code;
++ u32 msg_context;
++}MPT_MGMT;
+
+ /*
+ * Event Structure and define
+@@ -534,7 +539,8 @@ struct inactive_raid_component_info {
+ typedef struct _RaidCfgData {
+ IOCPage2_t *pIocPg2; /* table of Raid Volumes */
+ IOCPage3_t *pIocPg3; /* table of physical disks */
+- struct mutex inactive_list_mutex;
++ IOCPage6_t *pIocPg6; /* table of IR static data */
++ struct semaphore inactive_list_mutex;
+ struct list_head inactive_list; /* link list for physical
+ disk that belong in
+ inactive volumes */
+@@ -564,6 +570,9 @@ struct mptfc_rport_info
+ u8 flags;
+ };
+
++typedef void (*MPT_ADD_SGE)(char *pAddr, u32 flagslength, dma_addr_t dma_addr);
++typedef void (*MPT_ADD_CHAIN)(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr);
++
+ /*
+ * Adapter Structure - pci_dev specific. Maximum: MPT_MAX_ADAPTERS
+ */
+@@ -573,6 +582,9 @@ typedef struct _MPT_ADAPTER
+ int pci_irq; /* This irq */
+ char name[MPT_NAME_LENGTH]; /* "iocN" */
+ char prod_name[MPT_NAME_LENGTH]; /* "LSIFC9x9" */
++#ifdef CONFIG_FUSION_LOGGING
++ char evStr[EVENT_DESCR_STR_SZ]; /* used in mpt_display_event_info */
++#endif
+ char board_name[16];
+ char board_assembly[16];
+ char board_tracer[16];
+@@ -584,8 +596,8 @@ typedef struct _MPT_ADAPTER
+ SYSIF_REGS __iomem *chip; /* == c8817000 (mmap) */
+ SYSIF_REGS __iomem *pio_chip; /* Programmed IO (downloadboot) */
+ u8 bus_type;
+- u32 mem_phys; /* == f4020000 (mmap) */
+- u32 pio_mem_phys; /* Programmed IO (downloadboot) */
++ unsigned long mem_phys; /* == f4020000 (mmap) */
++ unsigned long pio_mem_phys; /* Programmed IO (downloadboot) */
+ int mem_size; /* mmap memory size */
+ int number_of_buses;
+ int devices_per_bus;
+@@ -600,6 +612,8 @@ typedef struct _MPT_ADAPTER
+ int reply_depth; /* Num Allocated reply frames */
+ int reply_sz; /* Reply frame size */
+ int num_chain; /* Number of chain buffers */
++ MPT_ADD_SGE add_sge; /* Pointer to add_sge function */
++ MPT_ADD_CHAIN add_chain; /* Pointer to add_chain function */
+ /* Pool of buffers for chaining. ReqToChain
+ * and ChainToChain track index of chain buffers.
+ * ChainBuffer (DMA) virt/phys addresses.
+@@ -628,31 +642,27 @@ typedef struct _MPT_ADAPTER
+ dma_addr_t sense_buf_pool_dma;
+ u32 sense_buf_low_dma;
+ u8 *HostPageBuffer; /* SAS - host page buffer support */
+- u32 HostPageBuffer_sz;
+- dma_addr_t HostPageBuffer_dma;
++ u32 HostPageBuffer_sz;
++ dma_addr_t HostPageBuffer_dma;
+ int mtrr_reg;
+ struct pci_dev *pcidev; /* struct pci_dev pointer */
+- int bars; /* bitmask of BAR's that must be configured */
+- int msi_enable;
++ int bars; /* bitmask of BAR's that must be configured */
++ int msi_enable;
+ u8 __iomem *memmap; /* mmap address */
+ struct Scsi_Host *sh; /* Scsi Host pointer */
+- SpiCfgData spi_data; /* Scsi config. data */
+- RaidCfgData raid_data; /* Raid config. data */
+- SasCfgData sas_data; /* Sas config. data */
+- FcCfgData fc_data; /* Fc config. data */
+- MPT_IOCTL *ioctl; /* ioctl data pointer */
++ SpiCfgData spi_data; /* Scsi config. data */
++ RaidCfgData raid_data; /* Raid config. data */
++ SasCfgData sas_data; /* Sas config. data */
++ FcCfgData fc_data; /* Fc config. data */
+ struct proc_dir_entry *ioc_dentry;
+ struct _MPT_ADAPTER *alt_ioc; /* ptr to 929 bound adapter port */
+- spinlock_t diagLock; /* diagnostic reset lock */
+- int diagPending;
+ u32 biosVersion; /* BIOS version from IO Unit Page 2 */
+ int eventTypes; /* Event logging parameters */
+ int eventContext; /* Next event context */
+ int eventLogSize; /* Max number of cached events */
+ struct _mpt_ioctl_events *events; /* pointer to event log */
+ u8 *cached_fw; /* Pointer to FW */
+- dma_addr_t cached_fw_dma;
+- struct list_head configQ; /* linked list of config. requests */
++ dma_addr_t cached_fw_dma;
+ int hs_reply_idx;
+ #ifndef MFCNT
+ u32 pad0;
+@@ -665,13 +675,16 @@ typedef struct _MPT_ADAPTER
+ IOCFactsReply_t facts;
+ PortFactsReply_t pfacts[2];
+ FCPortPage0_t fc_port_page0[2];
+- struct timer_list persist_timer; /* persist table timer */
+- int persist_wait_done; /* persist completion flag */
+- u8 persist_reply_frame[MPT_DEFAULT_FRAME_SIZE]; /* persist reply */
+ LANPage0_t lan_cnfg_page0;
+ LANPage1_t lan_cnfg_page1;
++#if defined(CPQ_CIM)
++ u32 csmi_change_count; /* count to track all IR
++ events for CSMI */
++ u8 pci_slot_number; /* ioc page 1 - pci slot number */
++#endif
+
+ u8 ir_firmware; /* =1 if IR firmware detected */
++
+ /*
+ * Description: errata_flag_1064
+ * If a PCIX read occurs within 1 or 2 cycles after the chip receives
+@@ -682,25 +695,46 @@ typedef struct _MPT_ADAPTER
+ int aen_event_read_flag; /* flag to indicate event log was read*/
+ u8 FirstWhoInit;
+ u8 upload_fw; /* If set, do a fw upload */
+- u8 reload_fw; /* Force a FW Reload on next reset */
+ u8 NBShiftFactor; /* NB Shift Factor based on Block Size (Facts) */
+- u8 pad1[4];
+ u8 DoneCtx;
+ u8 TaskCtx;
+ u8 InternalCtx;
+- spinlock_t initializing_hba_lock;
+- int initializing_hba_lock_flag;
+ struct list_head list;
+ struct net_device *netdev;
+ struct list_head sas_topology;
+ struct mutex sas_topology_mutex;
+- struct mutex sas_discovery_mutex;
+- u8 sas_discovery_runtime;
+- u8 sas_discovery_ignore_events;
++ u8 disable_hotplug_remove;
++
++ struct workqueue_struct *fw_event_q;
++ struct list_head fw_event_list;
++ spinlock_t fw_event_lock;
++ u8 fw_events_off; /* if '1', then ignore events */
++ char fw_event_q_name[20];
++
++ struct mptsas_portinfo *hba_port_info; /* port_info object for the host */
++ u64 hba_port_sas_addr;
++ u16 hba_port_num_phy;
++ struct list_head sas_device_info_list;
++ struct semaphore sas_device_info_mutex;
++ u8 old_sas_discovery_protocal;
++ u8 sas_discovery_quiesce_io;
+ int sas_index; /* index refrencing */
+- MPT_SAS_MGMT sas_mgmt;
+- struct work_struct sas_persist_task;
++ MPT_MGMT sas_mgmt;
++ MPT_MGMT internal_cmds;
++ MPT_MGMT mptbase_cmds; /* for sending config pages */
++ MPT_MGMT taskmgmt_cmds;
++ MPT_MGMT ioctl_cmds; /* ioctl data pointer */
++ spinlock_t taskmgmt_lock; /* diagnostic reset lock */
++ int taskmgmt_in_progress;
++ u8 taskmgmt_quiesce_io;
++ u8 ioc_reset_in_progress;
++#if defined(CPQ_CIM)
++ u8 num_ports;
++#endif
+
++ char reset_work_q_name[20];
++ struct workqueue_struct *reset_work_q;
++ struct delayed_work fault_reset_work;
+ struct work_struct fc_setup_reset_work;
+ struct list_head fc_rports;
+ struct work_struct fc_lsc_work;
+@@ -709,14 +743,27 @@ typedef struct _MPT_ADAPTER
+ struct work_struct fc_rescan_work;
+ char fc_rescan_work_q_name[20];
+ struct workqueue_struct *fc_rescan_work_q;
++ unsigned long hard_resets; /* driver forced bus resets count */
++ unsigned long soft_resets; /* fw/external bus resets count */
++ unsigned long timeouts; /* cmd timeouts */
+ struct scsi_cmnd **ScsiLookup;
+ spinlock_t scsi_lookup_lock;
+-
+- char reset_work_q_name[20];
+- struct workqueue_struct *reset_work_q;
+- struct delayed_work fault_reset_work;
+- spinlock_t fault_reset_work_lock;
+-
++ int sdev_queue_depth; /* sdev queue depth */
++ u64 dma_mask;
++ u32 broadcast_aen_busy;
++#if defined(DIAG_BUFFER_SUPPORT)
++ u8 *DiagBuffer[MPI_DIAG_BUF_TYPE_COUNT];
++ u32 DataSize[MPI_DIAG_BUF_TYPE_COUNT];
++ u32 DiagBuffer_sz[MPI_DIAG_BUF_TYPE_COUNT];
++ dma_addr_t DiagBuffer_dma[MPI_DIAG_BUF_TYPE_COUNT];
++ u8 TraceLevel[MPI_DIAG_BUF_TYPE_COUNT];
++ u8 DiagBuffer_Status[MPI_DIAG_BUF_TYPE_COUNT];
++ u32 UniqueId[MPI_DIAG_BUF_TYPE_COUNT];
++ u32 ExtendedType[MPI_DIAG_BUF_TYPE_COUNT];
++ u32 ProductSpecific[MPI_DIAG_BUF_TYPE_COUNT][4];
++#endif
++ u8 sg_addr_size;
++ u8 SGE_size;
+ } MPT_ADAPTER;
+
+ /*
+@@ -753,13 +800,12 @@ typedef struct _mpt_sge {
+ dma_addr_t Address;
+ } MptSge_t;
+
+-#define mpt_addr_size() \
+- ((sizeof(dma_addr_t) == sizeof(u64)) ? MPI_SGE_FLAGS_64_BIT_ADDRESSING : \
+- MPI_SGE_FLAGS_32_BIT_ADDRESSING)
+-
+-#define mpt_msg_flags() \
+- ((sizeof(dma_addr_t) == sizeof(u64)) ? MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64 : \
+- MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_32)
++#define mpt_msg_flags(ioc) \
++ (ioc->sg_addr_size == sizeof(u64)) ? MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64 : \
++ MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_32
++
++#define MPT_SGE_FLAGS_64_BIT_ADDRESSING \
++ (MPI_SGE_FLAGS_64_BIT_ADDRESSING << MPI_SGE_FLAGS_SHIFT)
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /*
+@@ -778,26 +824,10 @@ typedef struct _mpt_sge {
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
+-#define SCSI_STD_SENSE_BYTES 18
+-#define SCSI_STD_INQUIRY_BYTES 36
+-#define SCSI_MAX_INQUIRY_BYTES 96
+-
+ /*
+ * MPT_SCSI_HOST defines - Used by the IOCTL and the SCSI drivers
+ * Private to the driver.
+ */
+-/* LOCAL structure and fields used when processing
+- * internally generated commands. These include:
+- * bus scan, dv and config requests.
+- */
+-typedef struct _MPT_LOCAL_REPLY {
+- ConfigPageHeader_t header;
+- int completion;
+- u8 sense[SCSI_STD_SENSE_BYTES];
+- u8 scsiStatus;
+- u8 skip;
+- u32 pad;
+-} MPT_LOCAL_REPLY;
+
+ #define MPT_HOST_BUS_UNKNOWN (0xFF)
+ #define MPT_HOST_TOO_MANY_TM (0x05)
+@@ -813,13 +843,6 @@ typedef struct _MPT_LOCAL_REPLY {
+ #define MPT_NVRAM_WIDE_DISABLE (0x00100000)
+ #define MPT_NVRAM_BOOT_CHOICE (0x00200000)
+
+-/* The TM_STATE variable is used to provide strict single threading of TM
+- * requests as well as communicate TM error conditions.
+- */
+-#define TM_STATE_NONE (0)
+-#define TM_STATE_IN_PROGRESS (1)
+-#define TM_STATE_ERROR (2)
+-
+ typedef enum {
+ FC,
+ SPI,
+@@ -828,63 +851,28 @@ typedef enum {
+
+ typedef struct _MPT_SCSI_HOST {
+ MPT_ADAPTER *ioc;
+- int port;
+- u32 pad0;
+- MPT_LOCAL_REPLY *pLocal; /* used for internal commands */
+- struct timer_list timer;
+- /* Pool of memory for holding SCpnts before doing
+- * OS callbacks. freeQ is the free pool.
+- */
+- u8 tmPending;
+- u8 resetPending;
+- u8 negoNvram; /* DV disabled, nego NVRAM */
+- u8 pad1;
+- u8 tmState;
+- u8 rsvd[2];
+- MPT_FRAME_HDR *cmdPtr; /* Ptr to nonOS request */
+- struct scsi_cmnd *abortSCpnt;
+- MPT_LOCAL_REPLY localReply; /* internal cmd reply struct */
+- unsigned long hard_resets; /* driver forced bus resets count */
+- unsigned long soft_resets; /* fw/external bus resets count */
+- unsigned long timeouts; /* cmd timeouts */
+ ushort sel_timeout[MPT_MAX_FC_DEVICES];
+ char *info_kbuf;
+- wait_queue_head_t scandv_waitq;
+- int scandv_wait_done;
+ long last_queue_full;
+- u16 tm_iocstatus;
+ u16 spi_pending;
+ struct list_head target_reset_list;
+ } MPT_SCSI_HOST;
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /*
+- * More Dynamic Multi-Pathing stuff...
+- */
+-
+-/* Forward decl, a strange C thing, to prevent gcc compiler warnings */
+-struct scsi_cmnd;
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
+ * Generic structure passed to the base mpt_config function.
+ */
+ typedef struct _x_config_parms {
+- struct list_head linkage; /* linked list */
+- struct timer_list timer; /* timer function for this request */
+ union {
+ ConfigExtendedPageHeader_t *ehdr;
+ ConfigPageHeader_t *hdr;
+ } cfghdr;
+ dma_addr_t physAddr;
+- int wait_done; /* wait for this request */
+ u32 pageAddr; /* properly formatted */
++ u16 status;
+ u8 action;
+ u8 dir;
+ u8 timeout; /* seconds */
+- u8 pad1;
+- u16 status;
+- u16 pad2;
+ } CONFIGPARMS;
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+@@ -909,29 +897,37 @@ extern MPT_FRAME_HDR *mpt_get_msg_frame(
+ extern void mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf);
+ extern void mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf);
+ extern void mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf);
+-extern void mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr);
+-
+ extern int mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag);
+ 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_SoftResetHandler(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);
+ extern int mpt_findImVolumes(MPT_ADAPTER *ioc);
+ extern int mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
+ extern int mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk);
++extern int mpt_raid_phys_disk_pg1(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage1_t phys_disk);
++extern int mpt_raid_phys_disk_get_num_paths(MPT_ADAPTER *ioc, u8 phys_disk_num);
++
++extern int mpt_set_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc);
++extern void mpt_clear_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc);
++extern void mpt_halt_firmware(MPT_ADAPTER *ioc);
+
+ /*
+ * Public data decl's...
+ */
+ extern struct list_head ioc_list;
++extern struct proc_dir_entry *mpt_proc_root_dir;
++extern int mpt_debug_level;
++extern int mpt_fwfault_debug;
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ #endif /* } __KERNEL__ */
+
+-#ifdef CONFIG_64BIT
++#if defined(__alpha__) || defined(__sparc_v9__) || defined(__ia64__) || defined(__x86_64__) || defined(__powerpc64__)
+ #define CAST_U32_TO_PTR(x) ((void *)(u64)x)
+ #define CAST_PTR_TO_U32(x) ((u32)(u64)x)
+ #else
+@@ -956,7 +952,6 @@ extern struct list_head ioc_list;
+ #define MPT_SGE_FLAGS_END_OF_BUFFER (0x40000000)
+ #define MPT_SGE_FLAGS_LOCAL_ADDRESS (0x08000000)
+ #define MPT_SGE_FLAGS_DIRECTION (0x04000000)
+-#define MPT_SGE_FLAGS_ADDRESSING (mpt_addr_size() << MPI_SGE_FLAGS_SHIFT)
+ #define MPT_SGE_FLAGS_END_OF_LIST (0x01000000)
+
+ #define MPT_SGE_FLAGS_TRANSACTION_ELEMENT (0x00000000)
+@@ -969,14 +964,12 @@ extern struct list_head ioc_list;
+ MPT_SGE_FLAGS_END_OF_BUFFER | \
+ MPT_SGE_FLAGS_END_OF_LIST | \
+ MPT_SGE_FLAGS_SIMPLE_ELEMENT | \
+- MPT_SGE_FLAGS_ADDRESSING | \
+ MPT_TRANSFER_IOC_TO_HOST)
+ #define MPT_SGE_FLAGS_SSIMPLE_WRITE \
+ (MPT_SGE_FLAGS_LAST_ELEMENT | \
+ MPT_SGE_FLAGS_END_OF_BUFFER | \
+ MPT_SGE_FLAGS_END_OF_LIST | \
+ MPT_SGE_FLAGS_SIMPLE_ELEMENT | \
+- MPT_SGE_FLAGS_ADDRESSING | \
+ MPT_TRANSFER_HOST_TO_IOC)
+
+ /*}-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+--- a/drivers/message/fusion/mptctl.c
++++ b/drivers/message/fusion/mptctl.c
+@@ -45,6 +45,7 @@
+ */
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
++#include <linux/version.h>
+ #include <linux/kernel.h>
+ #include <linux/module.h>
+ #include <linux/errno.h>
+@@ -71,6 +72,15 @@
+ #include "mptbase.h"
+ #include "mptctl.h"
+
++#if defined(CPQ_CIM)
++#include "mptsas.h"
++#include "csmi/csmisas.h"
++#endif // CPQ_CIM
++
++#if defined(DIAG_BUFFER_SUPPORT)
++#include "rejected_ioctls/diag_buffer.h"
++#endif
++
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ #define my_NAME "Fusion MPT misc device (ioctl) driver"
+ #define my_VERSION MPT_LINUX_VERSION_COMMON
+@@ -84,6 +94,7 @@ MODULE_VERSION(my_VERSION);
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
+ static u8 mptctl_id = MPT_MAX_PROTOCOL_DRIVERS;
++static u8 mptctl_taskmgmt_id = MPT_MAX_PROTOCOL_DRIVERS;
+
+ static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
+
+@@ -112,6 +123,42 @@ static int mptctl_do_reset(unsigned long
+ static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
+ static int mptctl_hp_targetinfo(unsigned long arg);
+
++#if defined(CPQ_CIM)
++/* csmisas proto's*/
++static int csmisas_get_driver_info(unsigned long arg);
++static int csmisas_get_cntlr_status(unsigned long arg);
++static int csmisas_get_cntlr_config(unsigned long arg);
++static int csmisas_get_phy_info(unsigned long arg);
++static int csmisas_get_scsi_address(unsigned long arg);
++static int csmisas_get_link_errors(unsigned long arg);
++static int csmisas_smp_passthru(unsigned long arg);
++static int csmisas_firmware_download(unsigned long arg);
++static int csmisas_get_raid_info(unsigned long arg);
++static int csmisas_get_raid_config(unsigned long arg);
++static int csmisas_get_raid_features(unsigned long arg);
++static int csmisas_set_raid_control(unsigned long arg);
++static int csmisas_get_raid_element(unsigned long arg);
++static int csmisas_set_raid_operation(unsigned long arg);
++static int csmisas_set_phy_info(unsigned long arg);
++static int csmisas_ssp_passthru(unsigned long arg);
++static int csmisas_stp_passthru(unsigned long arg);
++static int csmisas_get_sata_signature(unsigned long arg);
++static int csmisas_get_device_address(unsigned long arg);
++static int csmisas_task_managment(unsigned long arg);
++static int csmisas_phy_control(unsigned long arg);
++static int csmisas_get_connector_info(unsigned long arg);
++static int csmisas_get_location(unsigned long arg);
++#endif // CPQ_CIM
++
++#if defined(DIAG_BUFFER_SUPPORT)
++/* diag_buffer proto's */
++static int mptctl_register_diag_buffer(unsigned long arg);
++static int mptctl_release_diag_buffer(unsigned long arg);
++static int mptctl_unregister_diag_buffer(unsigned long arg);
++static int mptctl_query_diag_buffer(unsigned long arg);
++static int mptctl_read_diag_buffer(unsigned long arg);
++#endif // DIAG_BUFFER_SUPPORT
++
+ static int mptctl_probe(struct pci_dev *, const struct pci_device_id *);
+ static void mptctl_remove(struct pci_dev *);
+
+@@ -127,10 +174,6 @@ static MptSge_t *kbuf_alloc_2_sgl(int by
+ 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 void mptctl_timeout_expired (MPT_IOCTL *ioctl);
+-static int mptctl_bus_reset(MPT_IOCTL *ioctl);
+-static int mptctl_set_tm_flags(MPT_SCSI_HOST *hd);
+-static void mptctl_free_tm_flags(MPT_ADAPTER *ioc);
+
+ /*
+ * Reset Handler cleanup function
+@@ -183,10 +226,10 @@ mptctl_syscall_down(MPT_ADAPTER *ioc, in
+ int rc = 0;
+
+ if (nonblock) {
+- if (!mutex_trylock(&ioc->ioctl->ioctl_mutex))
++ if (!mutex_trylock(&ioc->ioctl_cmds.mutex))
+ rc = -EAGAIN;
+ } else {
+- if (mutex_lock_interruptible(&ioc->ioctl->ioctl_mutex))
++ if (mutex_lock_interruptible(&ioc->ioctl_cmds.mutex))
+ rc = -ERESTARTSYS;
+ }
+ return rc;
+@@ -202,131 +245,104 @@ mptctl_syscall_down(MPT_ADAPTER *ioc, in
+ static int
+ mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
+ {
+- char *sense_data;
+- int sz, req_index;
+- u16 iocStatus;
+- u8 cmd;
+-
+- if (req)
+- cmd = req->u.hdr.Function;
+- else
+- return 1;
+- dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tcompleting mpi function (0x%02X), req=%p, "
+- "reply=%p\n", ioc->name, req->u.hdr.Function, req, reply));
+-
+- if (ioc->ioctl) {
++ char *sense_data;
++ int req_index;
++ int sz;
+
+- if (reply==NULL) {
++ if (!req)
++ return 0;
+
+- dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_reply() NULL Reply "
+- "Function=%x!\n", ioc->name, cmd));
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "completing mpi function "
++ "(0x%02X), req=%p, reply=%p\n", ioc->name, req->u.hdr.Function,
++ req, reply));
+
+- ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
+- ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
++ /*
++ * Handling continuation of the same reply. Processing the first
++ * reply, and eating the other replys that come later.
++ */
++ if (ioc->ioctl_cmds.msg_context != req->u.hdr.MsgContext)
++ goto out_continuation;
+
+- /* We are done, issue wake up
+- */
+- ioc->ioctl->wait_done = 1;
+- wake_up (&mptctl_wait);
+- return 1;
++ ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
+
+- }
++ if (!reply)
++ goto out;
+
+- /* Copy the reply frame (which much exist
+- * for non-SCSI I/O) to the IOC structure.
+- */
+- memcpy(ioc->ioctl->ReplyFrame, reply,
+- min(ioc->reply_sz, 4*reply->u.reply.MsgLength));
+- ioc->ioctl->status |= MPT_IOCTL_STATUS_RF_VALID;
++ ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
++ sz = min(ioc->reply_sz, 4*reply->u.reply.MsgLength);
++ memcpy(ioc->ioctl_cmds.reply, reply, sz);
+
+- /* Set the command status to GOOD if IOC Status is GOOD
+- * OR if SCSI I/O cmd and data underrun or recovered error.
+- */
+- iocStatus = le16_to_cpu(reply->u.reply.IOCStatus) & MPI_IOCSTATUS_MASK;
+- if (iocStatus == MPI_IOCSTATUS_SUCCESS)
+- ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
+-
+- if (iocStatus || reply->u.reply.IOCLogInfo)
+- dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tiocstatus (0x%04X), "
+- "loginfo (0x%08X)\n", ioc->name,
+- iocStatus,
+- le32_to_cpu(reply->u.reply.IOCLogInfo)));
+-
+- if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
+- (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
+-
+- if (reply->u.sreply.SCSIStatus || reply->u.sreply.SCSIState)
+- dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "\tscsi_status (0x%02x), scsi_state (0x%02x), "
+- "tag = (0x%04x), transfer_count (0x%08x)\n", ioc->name,
+- reply->u.sreply.SCSIStatus,
+- reply->u.sreply.SCSIState,
+- le16_to_cpu(reply->u.sreply.TaskTag),
+- le32_to_cpu(reply->u.sreply.TransferCount)));
+-
+- ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
+-
+- if ((iocStatus == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN) ||
+- (iocStatus == MPI_IOCSTATUS_SCSI_RECOVERED_ERROR)) {
+- ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
+- }
+- }
++ if (reply->u.reply.IOCStatus || reply->u.reply.IOCLogInfo)
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "iocstatus (0x%04X), loginfo (0x%08X)\n", ioc->name,
++ le16_to_cpu(reply->u.reply.IOCStatus),
++ le32_to_cpu(reply->u.reply.IOCLogInfo)));
++
++ if ((req->u.hdr.Function == MPI_FUNCTION_SCSI_IO_REQUEST) ||
++ (req->u.hdr.Function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
++
++ if (reply->u.sreply.SCSIStatus || reply->u.sreply.SCSIState)
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "scsi_status (0x%02x), scsi_state (0x%02x), "
++ "tag = (0x%04x), transfer_count (0x%08x)\n", ioc->name,
++ reply->u.sreply.SCSIStatus,
++ reply->u.sreply.SCSIState,
++ le16_to_cpu(reply->u.sreply.TaskTag),
++ le32_to_cpu(reply->u.sreply.TransferCount)));
+
+- /* Copy the sense data - if present
+- */
+- if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) &&
+- (reply->u.sreply.SCSIState &
+- MPI_SCSI_STATE_AUTOSENSE_VALID)){
++ if (reply->u.sreply.SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
+ sz = req->u.scsireq.SenseBufferLength;
+ req_index =
+ le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
+- sense_data =
+- ((u8 *)ioc->sense_buf_pool +
++ sense_data = ((u8 *)ioc->sense_buf_pool +
+ (req_index * MPT_SENSE_BUFFER_ALLOC));
+- memcpy(ioc->ioctl->sense, sense_data, sz);
+- ioc->ioctl->status |= MPT_IOCTL_STATUS_SENSE_VALID;
++ memcpy(ioc->ioctl_cmds.sense, sense_data, sz);
++ ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_SENSE_VALID;
+ }
++ }
+
+- if (cmd == MPI_FUNCTION_SCSI_TASK_MGMT)
+- mptctl_free_tm_flags(ioc);
+-
+- /* We are done, issue wake up
+- */
+- ioc->ioctl->wait_done = 1;
+- wake_up (&mptctl_wait);
++ out:
++ /* We are done, issue wake up
++ */
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ if (req->u.hdr.Function == MPI_FUNCTION_SCSI_TASK_MGMT)
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ ioc->ioctl_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
++ complete(&ioc->ioctl_cmds.done);
+ }
++
++ out_continuation:
++ if (reply && (reply->u.reply.MsgFlags &
++ MPI_MSGFLAGS_CONTINUATION_REPLY))
++ return 0;
+ return 1;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/* mptctl_timeout_expired
+- *
+- * Expecting an interrupt, however timed out.
+- *
+- */
+-static void mptctl_timeout_expired (MPT_IOCTL *ioctl)
++static int
++mptctl_taskmgmt_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
+ {
+- int rc = 1;
++ if (!mf)
++ return 0;
+
+- dctlprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT ": Timeout Expired! Host %d\n",
+- ioctl->ioc->name, ioctl->ioc->id));
+- if (ioctl == NULL)
+- return;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed (mf=%p, mr=%p)\n",
++ ioc->name, mf, mr));
+
+- ioctl->wait_done = 0;
+- if (ioctl->reset & MPTCTL_RESET_OK)
+- rc = mptctl_bus_reset(ioctl);
+-
+- if (rc) {
+- /* Issue a reset for this device.
+- * The IOC is not responding.
+- */
+- dctlprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "Calling HardReset! \n",
+- ioctl->ioc->name));
+- mpt_HardResetHandler(ioctl->ioc, CAN_SLEEP);
+- }
+- return;
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
++
++ if (!mr)
++ goto out;
+
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
++ memcpy(ioc->taskmgmt_cmds.reply, mr,
++ min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
++ out:
++ if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
++ complete(&ioc->taskmgmt_cmds.done);
++ return 1;
++ }
++ return 0;
+ }
+
+ /* mptctl_bus_reset
+@@ -334,132 +350,181 @@ static void mptctl_timeout_expired (MPT_
+ * Bus reset code.
+ *
+ */
+-static int mptctl_bus_reset(MPT_IOCTL *ioctl)
++static int
++mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
+ {
+ MPT_FRAME_HDR *mf;
+ SCSITaskMgmt_t *pScsiTm;
+- MPT_SCSI_HOST *hd;
++ SCSITaskMgmtReply_t *pScsiTmReply;
+ int ii;
+- int retval=0;
+-
+-
+- ioctl->reset &= ~MPTCTL_RESET_OK;
+-
+- if (ioctl->ioc->sh == NULL)
++ int retval;
++ unsigned long timeout;
++ 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;
++ }
+
+- hd = shost_priv(ioctl->ioc->sh);
+- if (hd == NULL)
++ mutex_lock(&ioc->taskmgmt_cmds.mutex);
++ if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
+ return -EPERM;
++ }
+
+- /* Single threading ....
+- */
+- if (mptctl_set_tm_flags(hd) != 0)
+- return -EPERM;
++ retval = 0;
+
+ /* Send request
+ */
+- if ((mf = mpt_get_msg_frame(mptctl_id, ioctl->ioc)) == NULL) {
+- dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt, no msg frames!!\n",
+- ioctl->ioc->name));
+-
+- mptctl_free_tm_flags(ioctl->ioc);
+- return -ENOMEM;
++ if ((mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc)) == NULL) {
++ 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;
+ }
+
+- dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt request @ %p\n",
+- ioctl->ioc->name, mf));
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
++ ioc->name, mf));
+
+ pScsiTm = (SCSITaskMgmt_t *) mf;
+- pScsiTm->TargetID = ioctl->id;
+- pScsiTm->Bus = hd->port; /* 0 */
+- pScsiTm->ChainOffset = 0;
++ memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
+ pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
+- pScsiTm->Reserved = 0;
+ pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS;
+- pScsiTm->Reserved1 = 0;
+ pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
+-
++ pScsiTm->TargetID = 0;
++ pScsiTm->Bus = 0;
++ pScsiTm->ChainOffset = 0;
++ pScsiTm->Reserved = 0;
++ pScsiTm->Reserved1 = 0;
++ pScsiTm->TaskMsgContext = 0;
+ for (ii= 0; ii < 8; ii++)
+ pScsiTm->LUN[ii] = 0;
+-
+ for (ii=0; ii < 7; ii++)
+ pScsiTm->Reserved2[ii] = 0;
+
+- pScsiTm->TaskMsgContext = 0;
+- dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT
+- "mptctl_bus_reset: issued.\n", ioctl->ioc->name));
+-
+- DBG_DUMP_TM_REQUEST_FRAME(ioctl->ioc, (u32 *)mf);
++ switch (ioc->bus_type) {
++ case FC:
++ timeout = 40;
++ break;
++ case SAS:
++ timeout = 30;
++ break;
++ case SPI:
++ default:
++ timeout = 2;
++ break;
++ }
+
+- ioctl->wait_done=0;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
++ ioc->name, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, timeout));
+
+- if ((ioctl->ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
+- (ioctl->ioc->facts.MsgVersion >= MPI_VERSION_01_05))
+- mpt_put_msg_frame_hi_pri(mptctl_id, ioctl->ioc, mf);
++ 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))
++ mpt_put_msg_frame_hi_pri(mptctl_taskmgmt_id, ioc, mf);
+ else {
+- retval = mpt_send_handshake_request(mptctl_id, ioctl->ioc,
+- sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
++ retval = mpt_send_handshake_request(mptctl_taskmgmt_id, ioc,
++ sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
+ if (retval != 0) {
+- dfailprintk(ioctl->ioc, printk(MYIOC_s_ERR_FMT "_send_handshake FAILED!"
+- " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
+- hd->ioc, mf));
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt send_handshake FAILED!"
++ " (ioc %p, mf %p, rc=%d) \n", ioc->name,
++ ioc, mf, retval));
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
+ goto mptctl_bus_reset_done;
+ }
+ }
+
+ /* Now wait for the command to complete */
+- ii = wait_event_timeout(mptctl_wait,
+- ioctl->wait_done == 1,
+- HZ*5 /* 5 second timeout */);
+-
+- if(ii <=0 && (ioctl->wait_done != 1 )) {
+- mpt_free_msg_frame(hd->ioc, mf);
+- ioctl->wait_done = 0;
+- retval = -1; /* return failure */
++ 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));
++ mpt_free_msg_frame(ioc, mf);
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
++ retval = 0;
++ else
++ retval = -1; /* return failure */
++ goto mptctl_bus_reset_done;
+ }
+
+-mptctl_bus_reset_done:
+-
+- mptctl_free_tm_flags(ioctl->ioc);
+- return retval;
+-}
+-
+-static int
+-mptctl_set_tm_flags(MPT_SCSI_HOST *hd) {
+- unsigned long flags;
+-
+- spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
++ 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;
++ }
+
+- if (hd->tmState == TM_STATE_NONE) {
+- hd->tmState = TM_STATE_IN_PROGRESS;
+- hd->tmPending = 1;
+- spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
+- } else {
+- spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
+- return -EBUSY;
++ pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "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,
++ le16_to_cpu(pScsiTmReply->IOCStatus),
++ le32_to_cpu(pScsiTmReply->IOCLogInfo),
++ pScsiTmReply->ResponseCode,
++ le32_to_cpu(pScsiTmReply->TerminationCount)));
++
++ iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
++
++ if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
++ iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED ||
++ iocstatus == MPI_IOCSTATUS_SUCCESS)
++ retval = 0;
++ else {
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt failed\n", ioc->name));
++ retval = -1; /* return failure */
+ }
+
+- return 0;
++
++ mptctl_bus_reset_done:
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ return retval;
+ }
+
+ static void
+-mptctl_free_tm_flags(MPT_ADAPTER *ioc)
++mptctl_timeout_expired(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
+ {
+- MPT_SCSI_HOST * hd;
+ unsigned long flags;
+
+- hd = shost_priv(ioc->sh);
+- if (hd == NULL)
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": %s\n",
++ ioc->name, __FUNCTION__));
++
++ 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);
+
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+
+- hd->tmState = TM_STATE_NONE;
+- hd->tmPending = 0;
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
++ if (!mptctl_bus_reset(ioc, mf->u.hdr.Function))
++ return;
+
+- 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)
++ if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
++ mpt_HardResetHandler(ioc, CAN_SLEEP);
++ mpt_free_msg_frame(ioc, mf);
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+@@ -472,22 +537,23 @@ mptctl_free_tm_flags(MPT_ADAPTER *ioc)
+ static int
+ mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
+ {
+- MPT_IOCTL *ioctl = ioc->ioctl;
+- dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOC %s_reset routed to IOCTL driver!\n", ioc->name,
+- reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
+- reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
+-
+- if(ioctl == NULL)
+- return 1;
+-
+ switch(reset_phase) {
+ case MPT_IOC_SETUP_RESET:
+- ioctl->status |= MPT_IOCTL_STATUS_DID_IOCRESET;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
++ break;
++ case MPT_IOC_PRE_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
+ break;
+ case MPT_IOC_POST_RESET:
+- ioctl->status &= ~MPT_IOCTL_STATUS_DID_IOCRESET;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
++ complete(&ioc->ioctl_cmds.done);
++ }
+ break;
+- case MPT_IOC_PRE_RESET:
+ default:
+ break;
+ }
+@@ -505,7 +571,7 @@ mptctl_event_process(MPT_ADAPTER *ioc, E
+ event = le32_to_cpu(pEvReply->Event) & 0xFF;
+
+ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s() called\n",
+- ioc->name, __func__));
++ ioc->name, __FUNCTION__));
+ if(async_queue == NULL)
+ return 1;
+
+@@ -548,15 +614,11 @@ static int
+ mptctl_fasync(int fd, struct file *filep, int mode)
+ {
+ MPT_ADAPTER *ioc;
+- int ret;
+
+- lock_kernel();
+ list_for_each_entry(ioc, &ioc_list, list)
+ ioc->aen_event_read_flag=0;
+
+- ret = fasync_helper(fd, filep, mode, &async_queue);
+- unlock_kernel();
+- return ret;
++ return fasync_helper(fd, filep, mode, &async_queue);
+ }
+
+ static int
+@@ -582,6 +644,7 @@ __mptctl_ioctl(struct file *file, unsign
+ int ret;
+ MPT_ADAPTER *iocp = NULL;
+
++
+ if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
+ printk(KERN_ERR MYNAM "%s::mptctl_ioctl() @%d - "
+ "Unable to copy mpt_ioctl_header data @ %p\n",
+@@ -596,17 +659,12 @@ __mptctl_ioctl(struct file *file, unsign
+ iocnumX = khdr.iocnum & 0xFF;
+ if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
+ (iocp == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnumX);
+ return -ENODEV;
+ }
+
+- if (!iocp->active) {
+- printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - Controller disabled.\n",
+- __FILE__, __LINE__);
+- return -EFAULT;
+- }
+-
+ /* Handle those commands that are just returning
+ * information stored in the driver.
+ * These commands should never time out and are unaffected
+@@ -626,6 +684,25 @@ __mptctl_ioctl(struct file *file, unsign
+ return mptctl_eventreport(arg);
+ } else if (cmd == MPTFWREPLACE) {
+ return mptctl_replace_fw(arg);
++#if defined(DIAG_BUFFER_SUPPORT)
++/* diag_buffer static data calls*/
++ } else if (cmd == MPTDIAGQUERY) {
++ return mptctl_query_diag_buffer(arg);
++ } else if (cmd == MPTDIAGUNREGISTER) {
++ return mptctl_unregister_diag_buffer(arg);
++#endif
++
++#if defined(CPQ_CIM)
++/* csmisas static data calls*/
++ } else if (cmd == CC_CSMI_SAS_GET_DRIVER_INFO) {
++ return csmisas_get_driver_info(arg);
++ } else if (cmd == CC_CSMI_SAS_GET_CNTLR_STATUS) {
++ return csmisas_get_cntlr_status(arg);
++ } else if (cmd == CC_CSMI_SAS_GET_SCSI_ADDRESS) {
++ return csmisas_get_scsi_address(arg);
++ } else if (cmd == CC_CSMI_SAS_GET_DEVICE_ADDRESS){
++ return csmisas_get_device_address(arg);
++#endif // CPQ_CIM
+ }
+
+ /* All of these commands require an interrupt or
+@@ -634,6 +711,8 @@ __mptctl_ioctl(struct file *file, unsign
+ if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
+ return ret;
+
++// dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT ": mptctl_ioctl()\n", iocp->name));
++
+ if (cmd == MPTFWDOWNLOAD)
+ ret = mptctl_fw_download(arg);
+ else if (cmd == MPTCOMMAND)
+@@ -644,10 +723,61 @@ __mptctl_ioctl(struct file *file, unsign
+ ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
+ else if (cmd == HP_GETTARGETINFO)
+ ret = mptctl_hp_targetinfo(arg);
++#if defined(CPQ_CIM)
++/* csmisas requiring fw calls*/
++ else if (cmd == CC_CSMI_SAS_GET_CNTLR_CONFIG)
++ ret = csmisas_get_cntlr_config(arg);
++ else if (cmd == CC_CSMI_SAS_GET_PHY_INFO)
++ ret = csmisas_get_phy_info(arg);
++ else if (cmd == CC_CSMI_SAS_GET_SATA_SIGNATURE)
++ ret = csmisas_get_sata_signature(arg);
++ else if (cmd == CC_CSMI_SAS_GET_LINK_ERRORS)
++ ret = csmisas_get_link_errors(arg);
++ else if (cmd == CC_CSMI_SAS_SMP_PASSTHRU)
++ ret = csmisas_smp_passthru(arg);
++ else if (cmd == CC_CSMI_SAS_SSP_PASSTHRU)
++ ret = csmisas_ssp_passthru(arg);
++ else if (cmd == CC_CSMI_SAS_FIRMWARE_DOWNLOAD)
++ ret = csmisas_firmware_download(arg);
++ else if (cmd == CC_CSMI_SAS_GET_RAID_INFO)
++ ret = csmisas_get_raid_info(arg);
++ else if (cmd == CC_CSMI_SAS_GET_RAID_CONFIG)
++ ret = csmisas_get_raid_config(arg);
++ else if (cmd == CC_CSMI_SAS_GET_RAID_FEATURES)
++ ret = csmisas_get_raid_features(arg);
++ else if (cmd == CC_CSMI_SAS_SET_RAID_CONTROL)
++ ret = csmisas_set_raid_control(arg);
++ else if (cmd == CC_CSMI_SAS_GET_RAID_ELEMENT)
++ ret = csmisas_get_raid_element(arg);
++ else if (cmd == CC_CSMI_SAS_SET_RAID_OPERATION)
++ ret = csmisas_set_raid_operation(arg);
++ else if (cmd == CC_CSMI_SAS_SET_PHY_INFO)
++ ret = csmisas_set_phy_info(arg);
++ else if (cmd == CC_CSMI_SAS_STP_PASSTHRU)
++ ret = csmisas_stp_passthru(arg);
++ else if (cmd == CC_CSMI_SAS_TASK_MANAGEMENT)
++ ret = csmisas_task_managment(arg);
++ else if (cmd == CC_CSMI_SAS_PHY_CONTROL)
++ ret = csmisas_phy_control(arg);
++ else if (cmd == CC_CSMI_SAS_GET_CONNECTOR_INFO)
++ ret = csmisas_get_connector_info(arg);
++ else if (cmd == CC_CSMI_SAS_GET_LOCATION)
++ ret = csmisas_get_location(arg);
++#endif // CPQ_CIM
++
++#if defined(DIAG_BUFFER_SUPPORT)
++/* diag_buffer requiring fw calls*/
++ else if (cmd == MPTDIAGREGISTER)
++ ret = mptctl_register_diag_buffer(arg);
++ else if (cmd == MPTDIAGRELEASE)
++ ret = mptctl_release_diag_buffer(arg);
++ else if (cmd == MPTDIAGREADBUFFER)
++ ret = mptctl_read_diag_buffer(arg);
++#endif // DIAG_BUFFER_SUPPORT
+ else
+ ret = -EINVAL;
+
+- mutex_unlock(&iocp->ioctl->ioctl_mutex);
++ mutex_unlock(&iocp->ioctl_cmds.mutex);
+
+ return ret;
+ }
+@@ -676,6 +806,7 @@ static int mptctl_do_reset(unsigned long
+ }
+
+ if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s@%d::mptctl_do_reset - ioc%d not found!\n",
+ __FILE__, __LINE__, krinfo.hdr.iocnum);
+ return -ENODEV; /* (-6) No such device or address */
+@@ -763,10 +894,11 @@ mptctl_do_fw_download(int ioc, char __us
+ int sge_offset = 0;
+ u16 iocstat;
+ pFWDownloadReply_t ReplyMsg = NULL;
++ unsigned long timeleft;
+
+ if (mpt_verify_adapter(ioc, &iocp) < 0) {
+- printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n",
+- ioc);
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
++ printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n", ioc);
+ return -ENODEV; /* (-6) No such device or address */
+ } else {
+
+@@ -847,10 +979,10 @@ mptctl_do_fw_download(int ioc, char __us
+ * 64 4
+ */
+ maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) - sizeof(FWDownloadTCSGE_t))
+- / (sizeof(dma_addr_t) + sizeof(u32));
++ / iocp->SGE_size;
+ if (numfrags > maxfrags) {
+ ret = -EMLINK;
+- goto fwdl_out;
++ goto fwdl_out;
+ }
+
+ dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: sgl buffer = %p, sgfrags = %d\n",
+@@ -875,19 +1007,19 @@ mptctl_do_fw_download(int ioc, char __us
+ if (nib == 0 || nib == 3) {
+ ;
+ } else if (sgIn->Address) {
+- mpt_add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
++ iocp->add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
+ n++;
+ if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
+ printk(MYIOC_s_ERR_FMT "%s@%d::_ioctl_fwdl - "
+- "Unable to copy f/w buffer hunk#%d @ %p\n",
+- iocp->name, __FILE__, __LINE__, n, ufwbuf);
++ "Unable to copy f/w buffer hunk#%d @ %p\n",
++ iocp->name, __FILE__, __LINE__, n, ufwbuf);
+ goto fwdl_out;
+ }
+ fw_bytes_copied += bl->len;
+ }
+ sgIn++;
+ bl++;
+- sgOut += (sizeof(dma_addr_t) + sizeof(u32));
++ sgOut += iocp->SGE_size;
+ }
+
+ DBG_DUMP_FW_DOWNLOAD(iocp, (u32 *)mf, numfrags);
+@@ -896,16 +1028,27 @@ mptctl_do_fw_download(int ioc, char __us
+ * Finally, perform firmware download.
+ */
+ ReplyMsg = NULL;
++ SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, dlmsg->MsgContext);
++ INITIALIZE_MGMT_STATUS(iocp->ioctl_cmds.status)
+ mpt_put_msg_frame(mptctl_id, iocp, mf);
+
+ /* Now wait for the command to complete */
+- ret = wait_event_timeout(mptctl_wait,
+- iocp->ioctl->wait_done == 1,
+- HZ*60);
+-
+- if(ret <=0 && (iocp->ioctl->wait_done != 1 )) {
+- /* Now we need to reset the board */
+- mptctl_timeout_expired(iocp->ioctl);
++ timeleft = wait_for_completion_timeout(&iocp->ioctl_cmds.done, HZ*60);
++ if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ ret = -ETIME;
++ printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __FUNCTION__);
++ if (iocp->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(iocp, mf);
++ goto fwdl_out;
++ }
++ if (!timeleft)
++ mptctl_timeout_expired(iocp, mf);
++ goto fwdl_out;
++ }
++
++ if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
++ printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __FUNCTION__);
++ mpt_free_msg_frame(iocp, mf);
+ ret = -ENODATA;
+ goto fwdl_out;
+ }
+@@ -913,31 +1056,34 @@ mptctl_do_fw_download(int ioc, char __us
+ if (sgl)
+ kfree_sgl(sgl, sgl_dma, buflist, iocp);
+
+- ReplyMsg = (pFWDownloadReply_t)iocp->ioctl->ReplyFrame;
++ ReplyMsg = (pFWDownloadReply_t)iocp->ioctl_cmds.reply;
+ iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
+ if (iocstat == MPI_IOCSTATUS_SUCCESS) {
+- printk(MYIOC_s_INFO_FMT "F/W update successfull!\n", iocp->name);
++ printk(MYIOC_s_INFO_FMT ": F/W update successfully sent!\n", iocp->name);
+ return 0;
+ } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
+- printk(MYIOC_s_WARN_FMT "Hmmm... F/W download not supported!?!\n",
+- iocp->name);
++ printk(MYIOC_s_WARN_FMT "Hmmm... doesn't support F/W download?\n",
++ iocp->name);
+ printk(MYIOC_s_WARN_FMT "(time to go bang on somebodies door)\n",
+- iocp->name);
++ iocp->name);
+ return -EBADRQC;
+ } else if (iocstat == MPI_IOCSTATUS_BUSY) {
+ printk(MYIOC_s_WARN_FMT "IOC_BUSY!\n", iocp->name);
+ printk(MYIOC_s_WARN_FMT "(try again later?)\n", iocp->name);
+ return -EBUSY;
+ } else {
+- printk(MYIOC_s_WARN_FMT "ioctl_fwdl() returned [bad] status = %04xh\n",
+- iocp->name, iocstat);
++ printk(MYIOC_s_WARN_FMT "returned [bad] status = %04xh\n",
++ iocp->name, iocstat);
+ printk(MYIOC_s_WARN_FMT "(bad VooDoo)\n", iocp->name);
+ return -ENOMSG;
+ }
+ return 0;
+
+ fwdl_out:
+- kfree_sgl(sgl, sgl_dma, buflist, iocp);
++
++ CLEAR_MGMT_STATUS(iocp->ioctl_cmds.status);
++ SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, 0);
++ kfree_sgl(sgl, sgl_dma, buflist, iocp);
+ return ret;
+ }
+
+@@ -1008,7 +1154,7 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
+ *
+ */
+ sgl = sglbuf;
+- sg_spill = ((ioc->req_sz - sge_offset)/(sizeof(dma_addr_t) + sizeof(u32))) - 1;
++ sg_spill = ((ioc->req_sz - sge_offset)/ioc->SGE_size) - 1;
+ while (bytes_allocd < bytes) {
+ this_alloc = min(alloc_sz, bytes-bytes_allocd);
+ buflist[buflist_ent].len = this_alloc;
+@@ -1019,9 +1165,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
+ alloc_sz = alloc_sz / 2;
+ if (alloc_sz == 0) {
+ printk(MYIOC_s_WARN_FMT "-SG: No can do - "
+- "not enough memory! :-(\n", ioc->name);
++ "not enough memory! :-(\n", ioc->name);
+ printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
+- ioc->name, numfrags);
++ ioc->name, numfrags);
+ goto free_and_fail;
+ }
+ continue;
+@@ -1029,7 +1175,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
+ dma_addr_t dma_addr;
+
+ bytes_allocd += this_alloc;
+- sgl->FlagsLength = (0x10000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|this_alloc);
++ sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
++ if (ioc->sg_addr_size == sizeof(u64))
++ sgl->FlagsLength |= MPT_SGE_FLAGS_64_BIT_ADDRESSING;
+ dma_addr = pci_map_single(ioc->pcidev, buflist[buflist_ent].kptr, this_alloc, dir);
+ sgl->Address = dma_addr;
+
+@@ -1044,8 +1192,8 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
+
+ /* Need to chain? */
+ if (fragcnt == sg_spill) {
+- printk(MYIOC_s_WARN_FMT
+- "-SG: No can do - " "Chain required! :-(\n", ioc->name);
++ printk(MYIOC_s_WARN_FMT "-SG: No can do - "
++ "Chain required! :-(\n", ioc->name);
+ printk(MYIOC_s_WARN_FMT "(freeing %d frags)\n", ioc->name, numfrags);
+ goto free_and_fail;
+ }
+@@ -1054,9 +1202,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
+ if (numfrags*8 > MAX_SGL_BYTES){
+ /* GRRRRR... */
+ printk(MYIOC_s_WARN_FMT "-SG: No can do - "
+- "too many SG frags! :-(\n", ioc->name);
++ "too many SG frags! :-(\n", ioc->name);
+ printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
+- ioc->name, numfrags);
++ ioc->name, numfrags);
+ goto free_and_fail;
+ }
+ }
+@@ -1213,6 +1361,7 @@ mptctl_getiocinfo (unsigned long arg, un
+
+ if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ kfree(karg);
+@@ -1222,8 +1371,8 @@ mptctl_getiocinfo (unsigned long arg, un
+ /* Verify the data transfer size is correct. */
+ if (karg->hdr.maxDataSize != data_size) {
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
+- "Structure size mismatch. Command not completed.\n",
+- ioc->name, __FILE__, __LINE__);
++ "Structure size mismatch. Command not completed.\n",
++ ioc->name, __FILE__, __LINE__);
+ kfree(karg);
+ return -EFAULT;
+ }
+@@ -1275,6 +1424,8 @@ mptctl_getiocinfo (unsigned long arg, un
+ 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;
+@@ -1346,6 +1497,7 @@ mptctl_gettargetinfo (unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+@@ -1362,8 +1514,8 @@ mptctl_gettargetinfo (unsigned long arg)
+ port = karg.hdr.port;
+
+ if (maxWordsLeft <= 0) {
+- printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
+- ioc->name, __FILE__, __LINE__);
++ printk(MYIOC_s_ERR_FMT "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
++ ioc->name, __FILE__, __LINE__);
+ return -ENOMEM;
+ }
+
+@@ -1383,8 +1535,8 @@ mptctl_gettargetinfo (unsigned long arg)
+ */
+ pmem = kzalloc(numBytes, GFP_KERNEL);
+ if (!pmem) {
+- printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
+- ioc->name, __FILE__, __LINE__);
++ printk(MYIOC_s_ERR_FMT "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
++ ioc->name, __FILE__, __LINE__);
+ return -ENOMEM;
+ }
+ pdata = (int *) pmem;
+@@ -1396,6 +1548,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;
+@@ -1460,6 +1614,7 @@ mptctl_readtest (unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+@@ -1521,6 +1676,7 @@ mptctl_eventquery (unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+@@ -1560,6 +1716,7 @@ mptctl_eventenable (unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+@@ -1573,8 +1730,7 @@ mptctl_eventenable (unsigned long arg)
+ int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
+ ioc->events = kzalloc(sz, GFP_KERNEL);
+ if (!ioc->events) {
+- printk(MYIOC_s_ERR_FMT
+- ": ERROR - Insufficient memory to add adapter!\n",
++ printk(MYIOC_s_ERR_FMT "Insufficient memory to add adapter!\n",
+ ioc->name);
+ return -ENOMEM;
+ }
+@@ -1609,13 +1765,14 @@ mptctl_eventreport (unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+ }
++
+ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
+ ioc->name));
+-
+ numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
+ maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
+
+@@ -1663,6 +1820,7 @@ mptctl_replace_fw (unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+@@ -1694,8 +1852,8 @@ mptctl_replace_fw (unsigned long arg)
+ */
+ if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
+- "Unable to read in mpt_ioctl_replace_fw image "
+- "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
++ "Unable to read in mpt_ioctl_replace_fw image "
++ "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
+ mpt_free_fw_memory(ioc);
+ return -EFAULT;
+ }
+@@ -1712,7 +1870,7 @@ mptctl_replace_fw (unsigned long arg)
+ *
+ * Outputs: None.
+ * Return: 0 if successful
+- * -EBUSY if previous command timeout and IOC reset is not complete.
++ * -EBUSY if previous command timout and IOC reset is not complete.
+ * -EFAULT if data unavailable
+ * -ENODEV if no such device/adapter
+ * -ETIME if timer expires
+@@ -1737,6 +1895,7 @@ mptctl_mpt_command (unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+@@ -1752,7 +1911,7 @@ mptctl_mpt_command (unsigned long arg)
+ *
+ * Outputs: None.
+ * Return: 0 if successful
+- * -EBUSY if previous command timeout and IOC reset is not complete.
++ * -EBUSY if previous command timout and IOC reset is not complete.
+ * -EFAULT if data unavailable
+ * -ENODEV if no such device/adapter
+ * -ETIME if timer expires
+@@ -1775,8 +1934,11 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ int sz, rc = 0;
+ int msgContext;
+ u16 req_idx;
+- ulong timeout;
++ unsigned long timeout;
++ unsigned long timeleft;
+ struct scsi_device *sdev;
++ unsigned long flags;
++ u8 function;
+
+ /* bufIn and bufOut are used for user to kernel space transfers
+ */
+@@ -1785,28 +1947,28 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+ }
+- if (!ioc->ioctl) {
+- printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
+- "No memory available during driver init.\n",
+- __FILE__, __LINE__);
+- return -ENOMEM;
+- } else if (ioc->ioctl->status & MPT_IOCTL_STATUS_DID_IOCRESET) {
++
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
++ if (ioc->ioc_reset_in_progress) {
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+ printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
+- "Busy with IOC Reset \n", __FILE__, __LINE__);
++ "Busy with diagnostic reset\n", __FILE__, __LINE__);
+ return -EBUSY;
+ }
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+
+ /* Verify that the final request frame will not be too large.
+ */
+ sz = karg.dataSgeOffset * 4;
+ if (karg.dataInSize > 0)
+- sz += sizeof(dma_addr_t) + sizeof(u32);
++ sz += ioc->SGE_size;
+ if (karg.dataOutSize > 0)
+- sz += sizeof(dma_addr_t) + sizeof(u32);
++ sz += ioc->SGE_size;
+
+ if (sz > ioc->req_sz) {
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+@@ -1832,18 +1994,19 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+ "Unable to read MF from mpt_ioctl_command struct @ %p\n",
+ ioc->name, __FILE__, __LINE__, mfPtr);
++ function = -1;
+ rc = -EFAULT;
+ goto done_free_mem;
+ }
+ hdr->MsgContext = cpu_to_le32(msgContext);
+-
++ function = hdr->Function;
+
+ /* Verify that this request is allowed.
+ */
+ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
+- ioc->name, hdr->Function, mf));
++ ioc->name, function, mf));
+
+- switch (hdr->Function) {
++ switch (function) {
+ case MPI_FUNCTION_IOC_FACTS:
+ case MPI_FUNCTION_PORT_FACTS:
+ karg.dataOutSize = karg.dataInSize = 0;
+@@ -1898,7 +2061,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ }
+
+ pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
+- pScsiReq->MsgFlags |= mpt_msg_flags();
++ pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
+
+
+ /* verify that app has not requested
+@@ -1920,6 +2083,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ 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))
+@@ -1940,9 +2105,6 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ pScsiReq->Control = cpu_to_le32(scsidir | qtag);
+ pScsiReq->DataLength = cpu_to_le32(dataSize);
+
+- ioc->ioctl->reset = MPTCTL_RESET_OK;
+- ioc->ioctl->id = pScsiReq->TargetID;
+-
+ } else {
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+ "SCSI driver is not loaded. \n",
+@@ -1955,7 +2117,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ case MPI_FUNCTION_SMP_PASSTHROUGH:
+ /* Check mf->PassthruFlags to determine if
+ * transfer is ImmediateMode or not.
+- * Immediate mode returns data in the ReplyFrame.
++ * Immediate mode returns data in the reply.
+ * Else, we are sending request and response data
+ * in two SGLs at the end of the mf.
+ */
+@@ -1984,7 +2146,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ int dataSize;
+
+ pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
+- pScsiReq->MsgFlags |= mpt_msg_flags();
++ pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
+
+
+ /* verify that app has not requested
+@@ -2019,8 +2181,6 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ pScsiReq->Control = cpu_to_le32(scsidir | qtag);
+ pScsiReq->DataLength = cpu_to_le32(dataSize);
+
+- ioc->ioctl->reset = MPTCTL_RESET_OK;
+- ioc->ioctl->id = pScsiReq->TargetID;
+ } else {
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+ "SCSI driver is not loaded. \n",
+@@ -2031,20 +2191,15 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ break;
+
+ case MPI_FUNCTION_SCSI_TASK_MGMT:
+- {
+- MPT_SCSI_HOST *hd = NULL;
+- if ((ioc->sh == NULL) || ((hd = shost_priv(ioc->sh)) == NULL)) {
+- printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+- "SCSI driver not loaded or SCSI host not found. \n",
+- ioc->name, __FILE__, __LINE__);
+- rc = -EFAULT;
+- goto done_free_mem;
+- } else if (mptctl_set_tm_flags(hd) != 0) {
+- rc = -EPERM;
+- goto done_free_mem;
+- }
+- }
++ {
++ SCSITaskMgmt_t *pScsiTm;
++ pScsiTm = (SCSITaskMgmt_t *)mf;
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tTaskType=0x%x MsgFlags=0x%x "
++ "TaskMsgContext=0x%x id=%d channel=%d\n", ioc->name, pScsiTm->TaskType,
++ le32_to_cpu(pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
++ pScsiTm->TargetID, pScsiTm->Bus));
+ break;
++ }
+
+ case MPI_FUNCTION_IOC_INIT:
+ {
+@@ -2054,7 +2209,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ /* Verify that all entries in the IOC INIT match
+ * existing setup (and in LE format).
+ */
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
++ if (ioc->sg_addr_size == sizeof(u64)) {
+ high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
+ sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
+ } else {
+@@ -2062,6 +2217,11 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ sense_high= 0;
+ }
+
++ if (!pInit->MaxDevices && !pInit->MaxBuses) {
++ pInit->MaxDevices = ioc->facts.MaxDevices;
++ pInit->MaxBuses = ioc->facts.MaxBuses;
++ }
++
+ if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
+ (pInit->MaxBuses != ioc->facts.MaxBuses) ||
+ (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
+@@ -2102,7 +2262,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+ "Illegal request (function 0x%x) \n",
+- ioc->name, __FILE__, __LINE__, hdr->Function);
++ ioc->name, __FILE__, __LINE__, function);
+ rc = -EFAULT;
+ goto done_free_mem;
+ }
+@@ -2128,8 +2288,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ if (karg.dataInSize > 0) {
+ flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+ MPI_SGE_FLAGS_END_OF_BUFFER |
+- MPI_SGE_FLAGS_DIRECTION |
+- mpt_addr_size() )
++ MPI_SGE_FLAGS_DIRECTION )
+ << MPI_SGE_FLAGS_SHIFT;
+ } else {
+ flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
+@@ -2146,8 +2305,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ /* Set up this SGE.
+ * Copy to MF and to sglbuf
+ */
+- mpt_add_sge(psge, flagsLength, dma_addr_out);
+- psge += (sizeof(u32) + sizeof(dma_addr_t));
++ ioc->add_sge(psge, flagsLength, dma_addr_out);
++ psge += ioc->SGE_size;
+
+ /* Copy user data to kernel space.
+ */
+@@ -2180,17 +2339,24 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ /* Set up this SGE
+ * Copy to MF and to sglbuf
+ */
+- mpt_add_sge(psge, flagsLength, dma_addr_in);
++ ioc->add_sge(psge, flagsLength, dma_addr_in);
+ }
+ }
+ } else {
+ /* Add a NULL SGE
+ */
+- mpt_add_sge(psge, flagsLength, (dma_addr_t) -1);
++ ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
+ }
+
+- ioc->ioctl->wait_done = 0;
+- if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
++ INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
++ if (function == MPI_FUNCTION_SCSI_TASK_MGMT) {
++
++ mutex_lock(&ioc->taskmgmt_cmds.mutex);
++ if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ goto done_free_mem;
++ }
+
+ DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
+
+@@ -2198,53 +2364,57 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
+ mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
+ else {
+- rc =mpt_send_handshake_request(mptctl_id, ioc,
+- sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
++ rc = mpt_send_handshake_request(mptctl_id, ioc,
++ sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
+ if (rc != 0) {
+ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "_send_handshake FAILED! (ioc %p, mf %p)\n",
++ "send_handshake FAILED! (ioc %p, mf %p)\n",
+ ioc->name, ioc, mf));
+- mptctl_free_tm_flags(ioc);
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
+ rc = -ENODATA;
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
+ goto done_free_mem;
+ }
+ }
+-
+ } else
+ mpt_put_msg_frame(mptctl_id, ioc, mf);
+
+ /* Now wait for the command to complete */
+ timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
+- timeout = wait_event_timeout(mptctl_wait,
+- ioc->ioctl->wait_done == 1,
+- HZ*timeout);
+-
+- if(timeout <=0 && (ioc->ioctl->wait_done != 1 )) {
+- /* Now we need to reset the board */
+-
+- if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT)
+- mptctl_free_tm_flags(ioc);
+-
+- mptctl_timeout_expired(ioc->ioctl);
+- rc = -ENODATA;
++ timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done, HZ*timeout);
++ if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ rc = -ETIME;
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
++ ioc->name, __FUNCTION__));
++ if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ goto done_free_mem;
++ }
++ if (!timeleft) {
++ mptctl_timeout_expired(ioc, mf);
++ mf = NULL;
++ }
+ goto done_free_mem;
+ }
+
++ if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++
+ mf = NULL;
+
+ /* If a valid reply frame, copy to the user.
+ * Offset 2: reply length in U32's
+ */
+- if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID) {
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
+ if (karg.maxReplyBytes < ioc->reply_sz) {
+- sz = min(karg.maxReplyBytes, 4*ioc->ioctl->ReplyFrame[2]);
++ sz = min(karg.maxReplyBytes, 4*ioc->ioctl_cmds.reply[2]);
+ } else {
+- sz = min(ioc->reply_sz, 4*ioc->ioctl->ReplyFrame[2]);
++ sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
+ }
+-
+ if (sz > 0) {
+ if (copy_to_user(karg.replyFrameBufPtr,
+- &ioc->ioctl->ReplyFrame, sz)){
++ ioc->ioctl_cmds.reply, sz)){
+ printk(MYIOC_s_ERR_FMT
+ "%s@%d::mptctl_do_mpt_command - "
+ "Unable to write out reply frame %p\n",
+@@ -2257,10 +2427,10 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+
+ /* If valid sense data, copy to user.
+ */
+- if (ioc->ioctl->status & MPT_IOCTL_STATUS_SENSE_VALID) {
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
+ sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
+ if (sz > 0) {
+- if (copy_to_user(karg.senseDataPtr, ioc->ioctl->sense, sz)) {
++ if (copy_to_user(karg.senseDataPtr, ioc->ioctl_cmds.sense, sz)) {
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+ "Unable to write sense data to user %p\n",
+ ioc->name, __FILE__, __LINE__,
+@@ -2274,9 +2444,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+ /* If the overall status is _GOOD and data in, copy data
+ * to user.
+ */
+- if ((ioc->ioctl->status & MPT_IOCTL_STATUS_COMMAND_GOOD) &&
+- (karg.dataInSize > 0) && (bufIn.kptr)) {
+-
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
++ (karg.dataInSize > 0) && (bufIn.kptr)) {
+ if (copy_to_user(karg.dataInBufPtr,
+ bufIn.kptr, karg.dataInSize)) {
+ printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
+@@ -2289,9 +2458,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
+
+ done_free_mem:
+
+- ioc->ioctl->status &= ~(MPT_IOCTL_STATUS_COMMAND_GOOD |
+- MPT_IOCTL_STATUS_SENSE_VALID |
+- MPT_IOCTL_STATUS_RF_VALID );
++ CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
+
+ /* Free the allocated memory.
+ */
+@@ -2320,7 +2488,7 @@ done_free_mem:
+ * Outputs: None.
+ * Return: 0 if successful
+ * -EFAULT if data unavailable
+- * -EBUSY if previous command timeout and IOC reset is not complete.
++ * -EBUSY if previous command timout and IOC reset is not complete.
+ * -ENODEV if no such device/adapter
+ * -ETIME if timer expires
+ * -ENOMEM if memory allocation error
+@@ -2331,16 +2499,17 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ hp_host_info_t __user *uarg = (void __user *) arg;
+ MPT_ADAPTER *ioc;
+ struct pci_dev *pdev;
+- char *pbuf=NULL;
++ char *pbuf=NULL;
+ dma_addr_t buf_dma;
+ hp_host_info_t karg;
+- CONFIGPARMS cfg;
+- ConfigPageHeader_t hdr;
+ int iocnum;
+- int rc, cim_rev;
++ int cim_rev;
+ ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
+ MPT_FRAME_HDR *mf = NULL;
+ MPIHeader_t *mpi_hdr;
++ unsigned long timeleft;
++ int retval;
++ u32 MsgContext;
+
+ /* Reset long to int. Should affect IA64 and SPARC only
+ */
+@@ -2360,13 +2529,14 @@ mptctl_hp_hostinfo(unsigned long arg, un
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+ }
++
+ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
+ ioc->name));
+-
+ /* Fill in the data and return the structure to the calling
+ * program
+ */
+@@ -2406,42 +2576,9 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
+ karg.fw_version[11] = '\0';
+
+- /* Issue a config request to get the device serial number
+- */
+- hdr.PageVersion = 0;
+- hdr.PageLength = 0;
+- hdr.PageNumber = 0;
+- hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
+- cfg.cfghdr.hdr = &hdr;
+- cfg.physAddr = -1;
+- cfg.pageAddr = 0;
+- cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+- cfg.dir = 0; /* read */
+- cfg.timeout = 10;
++ strncpy(karg.serial_number, ioc->board_tracer, 16);
+
+- strncpy(karg.serial_number, " ", 24);
+- if (mpt_config(ioc, &cfg) == 0) {
+- if (cfg.cfghdr.hdr->PageLength > 0) {
+- /* Issue the second config page request */
+- cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+-
+- pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
+- if (pbuf) {
+- cfg.physAddr = buf_dma;
+- if (mpt_config(ioc, &cfg) == 0) {
+- ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
+- if (strlen(pdata->BoardTracerNumber) > 1) {
+- strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
+- karg.serial_number[24-1]='\0';
+- }
+- }
+- pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
+- pbuf = NULL;
+- }
+- }
+- }
+- rc = mpt_GetIocState(ioc, 1);
+- switch (rc) {
++ switch (mpt_GetIocState(ioc, 1)) {
+ case MPI_IOC_STATE_OPERATIONAL:
+ karg.ioc_status = HP_STATUS_OK;
+ break;
+@@ -2468,12 +2605,12 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ karg.soft_resets = 0;
+ karg.timeouts = 0;
+ if (ioc->sh != NULL) {
+- MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
++ MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
+
+ if (hd && (cim_rev == 1)) {
+- karg.hard_resets = hd->hard_resets;
+- karg.soft_resets = hd->soft_resets;
+- karg.timeouts = hd->timeouts;
++ karg.hard_resets = ioc->hard_resets;
++ karg.soft_resets = ioc->soft_resets;
++ karg.timeouts = ioc->timeouts;
+ }
+ }
+
+@@ -2482,16 +2619,18 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ */
+ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
+ dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
+- ioc->name,__func__));
++ ioc->name,__FUNCTION__));
++ retval = -ENOMEM;
+ goto out;
+ }
+
+ IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
+ mpi_hdr = (MPIHeader_t *) mf;
++ MsgContext = mpi_hdr->MsgContext;
+ memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
+ IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
+ IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
+- IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
++ IstwiRWRequest->MsgContext = MsgContext;
+ IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
+ IstwiRWRequest->NumAddressBytes = 0x01;
+ IstwiRWRequest->DataLength = cpu_to_le16(0x04);
+@@ -2501,28 +2640,30 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ IstwiRWRequest->DeviceAddr = 0xB0;
+
+ pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
+- if (!pbuf)
++ if (!pbuf) {
++ retval = -ENOMEM;
+ goto out;
+- mpt_add_sge((char *)&IstwiRWRequest->SGL,
+- (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
++ }
++ ioc->add_sge((char *)&IstwiRWRequest->SGL, (MPT_SGE_FLAGS_SSIMPLE_READ|4),buf_dma);
+
+- ioc->ioctl->wait_done = 0;
++ retval = 0;
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, IstwiRWRequest->MsgContext);
++ INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
+ mpt_put_msg_frame(mptctl_id, ioc, mf);
+-
+- rc = wait_event_timeout(mptctl_wait,
+- ioc->ioctl->wait_done == 1,
+- HZ*MPT_IOCTL_DEFAULT_TIMEOUT /* 10 sec */);
+-
+- if(rc <=0 && (ioc->ioctl->wait_done != 1 )) {
+- /*
+- * Now we need to reset the board
+- */
+- mpt_free_msg_frame(ioc, mf);
+- mptctl_timeout_expired(ioc->ioctl);
++ timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done, HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
++ if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ retval = -ETIME;
++ printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __FUNCTION__);
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(ioc, mf);
++ goto out;
++ }
++ if (!timeleft)
++ mptctl_timeout_expired(ioc, mf);
+ goto out;
+ }
+
+- /*
++ /*
+ *ISTWI Data Definition
+ * pbuf[0] = FW_VERSION = 0x4
+ * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
+@@ -2531,10 +2672,13 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ * bays have drives in them
+ * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
+ */
+- if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID)
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
+ karg.rsvd = *(u32 *)pbuf;
+
+ out:
++ CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
++
+ if (pbuf)
+ pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
+
+@@ -2547,7 +2691,7 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ return -EFAULT;
+ }
+
+- return 0;
++ return retval;
+
+ }
+
+@@ -2557,7 +2701,7 @@ mptctl_hp_hostinfo(unsigned long arg, un
+ * Outputs: None.
+ * Return: 0 if successful
+ * -EFAULT if data unavailable
+- * -EBUSY if previous command timeout and IOC reset is not complete.
++ * -EBUSY if previous command timout and IOC reset is not complete.
+ * -ENODEV if no such device/adapter
+ * -ETIME if timer expires
+ * -ENOMEM if memory allocation error
+@@ -2587,13 +2731,14 @@ mptctl_hp_targetinfo(unsigned long arg)
+
+ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
+ (ioc == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
+ __FILE__, __LINE__, iocnum);
+ return -ENODEV;
+ }
+- dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
+- ioc->name));
+
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_targetinfo called.\n",
++ ioc->name));
+ /* There is nothing to do for FCP parts.
+ */
+ if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
+@@ -2685,7 +2830,7 @@ mptctl_hp_targetinfo(unsigned long arg)
+ pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
+ }
+ }
+- hd = shost_priv(ioc->sh);
++ hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
+ if (hd != NULL)
+ karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
+
+@@ -2703,7 +2848,7 @@ mptctl_hp_targetinfo(unsigned long arg)
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
+-static const struct file_operations mptctl_fops = {
++static struct file_operations mptctl_fops = {
+ .owner = THIS_MODULE,
+ .llseek = no_llseek,
+ .release = mptctl_release,
+@@ -2743,8 +2888,9 @@ compat_mptfwxfer_ioctl(struct file *filp
+ iocnumX = kfw32.iocnum & 0xFF;
+ if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
+ (iocp == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
+- __LINE__, iocnumX);
++ __LINE__, iocnumX);
+ return -ENODEV;
+ }
+
+@@ -2759,7 +2905,7 @@ compat_mptfwxfer_ioctl(struct file *filp
+
+ ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
+
+- mutex_unlock(&iocp->ioctl->ioctl_mutex);
++ mutex_unlock(&iocp->ioctl_cmds.mutex);
+
+ return ret;
+ }
+@@ -2783,8 +2929,9 @@ compat_mpt_command(struct file *filp, un
+ iocnumX = karg32.hdr.iocnum & 0xFF;
+ if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
+ (iocp == NULL)) {
++ if (mpt_debug_level & MPT_DEBUG_IOCTL)
+ printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
+- __LINE__, iocnumX);
++ __LINE__, iocnumX);
+ return -ENODEV;
+ }
+
+@@ -2813,7 +2960,7 @@ compat_mpt_command(struct file *filp, un
+ */
+ ret = mptctl_do_mpt_command (karg, &uarg->MF);
+
+- mutex_unlock(&iocp->ioctl->ioctl_mutex);
++ mutex_unlock(&iocp->ioctl_cmds.mutex);
+
+ return ret;
+ }
+@@ -2833,6 +2980,31 @@ static long compat_mpctl_ioctl(struct fi
+ case MPTHARDRESET:
+ case HP_GETHOSTINFO:
+ case HP_GETTARGETINFO:
++#if defined(CPQ_CIM)
++ case CC_CSMI_SAS_GET_DRIVER_INFO:
++ case CC_CSMI_SAS_GET_CNTLR_CONFIG:
++ case CC_CSMI_SAS_GET_CNTLR_STATUS:
++ case CC_CSMI_SAS_GET_SCSI_ADDRESS:
++ case CC_CSMI_SAS_GET_DEVICE_ADDRESS:
++ case CC_CSMI_SAS_GET_PHY_INFO:
++ case CC_CSMI_SAS_GET_SATA_SIGNATURE:
++ case CC_CSMI_SAS_GET_LINK_ERRORS:
++ case CC_CSMI_SAS_SMP_PASSTHRU:
++ case CC_CSMI_SAS_SSP_PASSTHRU:
++ case CC_CSMI_SAS_FIRMWARE_DOWNLOAD:
++ case CC_CSMI_SAS_GET_RAID_INFO:
++ case CC_CSMI_SAS_GET_RAID_CONFIG:
++ case CC_CSMI_SAS_GET_RAID_FEATURES:
++ case CC_CSMI_SAS_SET_RAID_CONTROL:
++ case CC_CSMI_SAS_GET_RAID_ELEMENT:
++ case CC_CSMI_SAS_SET_RAID_OPERATION:
++ case CC_CSMI_SAS_SET_PHY_INFO:
++ case CC_CSMI_SAS_STP_PASSTHRU:
++ case CC_CSMI_SAS_TASK_MANAGEMENT:
++ case CC_CSMI_SAS_PHY_CONTROL:
++ case CC_CSMI_SAS_GET_CONNECTOR_INFO:
++ case CC_CSMI_SAS_GET_LOCATION:
++#endif /* CPQ_CIM */
+ case MPTTEST:
+ ret = __mptctl_ioctl(f, cmd, arg);
+ break;
+@@ -2865,21 +3037,11 @@ static long compat_mpctl_ioctl(struct fi
+ static int
+ mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+ {
+- MPT_IOCTL *mem;
+ MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
+
+- /*
+- * Allocate and inite a MPT_IOCTL structure
+- */
+- mem = kzalloc(sizeof(MPT_IOCTL), GFP_KERNEL);
+- if (!mem) {
+- mptctl_remove(pdev);
+- return -ENOMEM;
+- }
++ mutex_init(&ioc->ioctl_cmds.mutex);
++ init_completion(&ioc->ioctl_cmds.done);
+
+- ioc->ioctl = mem;
+- ioc->ioctl->ioc = ioc;
+- mutex_init(&ioc->ioctl->ioctl_mutex);
+ return 0;
+ }
+
+@@ -2893,9 +3055,22 @@ mptctl_probe(struct pci_dev *pdev, const
+ static void
+ mptctl_remove(struct pci_dev *pdev)
+ {
++#if defined(DIAG_BUFFER_SUPPORT)
+ MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
++ int i;
+
+- kfree ( ioc->ioctl );
++ /*
++ * Cleanup diag buffer allocated memory
++ */
++ for (i = 0; i < MPI_DIAG_BUF_TYPE_COUNT; i++) {
++ if (ioc->DiagBuffer[i] == NULL)
++ continue;
++ pci_free_consistent(ioc->pcidev, ioc->DiagBuffer_sz[i],
++ ioc->DiagBuffer[i], ioc->DiagBuffer_dma[i]);
++ ioc->DiagBuffer[i] = NULL;
++ ioc->DiagBuffer_Status[i] = 0;
++ }
++#endif
+ }
+
+ static struct mpt_pci_driver mptctl_driver = {
+@@ -2935,6 +3110,7 @@ static int __init mptctl_init(void)
+ goto out_fail;
+ }
+
++ mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER);
+ mpt_reset_register(mptctl_id, mptctl_ioc_reset);
+ mpt_event_register(mptctl_id, mptctl_event_process);
+
+@@ -2956,15 +3132,23 @@ static void mptctl_exit(void)
+
+ /* De-register reset handler from base module */
+ mpt_reset_deregister(mptctl_id);
++ mpt_reset_deregister(mptctl_taskmgmt_id);
+
+ /* De-register callback handler from base module */
+ mpt_deregister(mptctl_id);
+
+ mpt_device_driver_deregister(MPTCTL_DRIVER);
+-
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
++#if defined(CPQ_CIM)
++#include "csmi/csmisas.c"
++#endif // CPQ_CIM
++
++#if defined(DIAG_BUFFER_SUPPORT)
++#include "rejected_ioctls/diag_buffer.c"
++#endif
++
+ module_init(mptctl_init);
+ module_exit(mptctl_exit);
+--- a/drivers/message/fusion/mptctl.h
++++ b/drivers/message/fusion/mptctl.h
+@@ -1,5 +1,5 @@
+ /*
+- * linux/drivers/message/fusion/mptioctl.h
++ * linux/drivers/message/fusion/mptctl.h
+ * Fusion MPT misc device (ioctl) driver.
+ * For use with PCI chip/adapter(s):
+ * LSIFC9xx/LSI409xx Fibre Channel
+@@ -460,8 +460,5 @@ typedef struct _hp_target_info {
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-
+ #endif
+
+--- a/drivers/message/fusion/mptdebug.h
++++ b/drivers/message/fusion/mptdebug.h
+@@ -17,6 +17,10 @@
+ *
+ * Example: (programming for MPT_DEBUG_EVENTS on host 5)
+ *
++ * global setting:
++ * echo 8 > /sys/module/mptbase/parameters/mpt_debug_level
++ *
++ * per host setting:
+ * echo 8 > /sys/class/scsi_host/host5/debug_level
+ *
+ * --------------------------------------------------------
+@@ -55,9 +59,11 @@
+ #define MPT_DEBUG_RESET 0x00008000
+ #define MPT_DEBUG_SCSI 0x00010000
+ #define MPT_DEBUG_IOCTL 0x00020000
++#define MPT_DEBUG_CSMISAS 0x00040000
+ #define MPT_DEBUG_FC 0x00080000
+ #define MPT_DEBUG_SAS 0x00100000
+ #define MPT_DEBUG_SAS_WIDE 0x00200000
++#define MPT_DEBUG_36GB_MEM 0x00400000
+
+ /*
+ * CONFIG_FUSION_LOGGING - enabled in Kconfig
+@@ -126,6 +132,9 @@
+ #define dctlprintk(IOC, CMD) \
+ MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_IOCTL)
+
++#define dcsmisasprintk(IOC, CMD) \
++ MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_CSMISAS)
++
+ #define dfcprintk(IOC, CMD) \
+ MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_FC)
+
+@@ -135,7 +144,8 @@
+ #define dsaswideprintk(IOC, CMD) \
+ MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_SAS_WIDE)
+
+-
++#define d36memprintk(IOC, CMD) \
++ MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_36GB_MEM)
+
+ /*
+ * Verbose logging
+--- a/drivers/message/fusion/mptfc.c
++++ b/drivers/message/fusion/mptfc.c
+@@ -43,6 +43,7 @@
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++
+ #include <linux/module.h>
+ #include <linux/kernel.h>
+ #include <linux/init.h>
+@@ -52,8 +53,10 @@
+ #include <linux/delay.h> /* for mdelay */
+ #include <linux/interrupt.h> /* needed for in_interrupt() proto */
+ #include <linux/reboot.h> /* notifier code */
++#include <linux/sched.h>
+ #include <linux/workqueue.h>
+ #include <linux/sort.h>
++#include <linux/pci.h>
+
+ #include <scsi/scsi.h>
+ #include <scsi/scsi_cmnd.h>
+@@ -84,6 +87,14 @@ MODULE_PARM_DESC(mptfc_dev_loss_tmo, " I
+ " return following a device loss event."
+ " Default=60.");
+
++static int mpt_sdev_queue_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
++static int mptfc_set_sdev_queue_depth(const char *val, struct kernel_param *kp);
++module_param_call(mpt_sdev_queue_depth, mptfc_set_sdev_queue_depth,
++ param_get_int, &mpt_sdev_queue_depth, 0600);
++MODULE_PARM_DESC(mpt_sdev_queue_depth,
++ " Max Device Queue Depth (default="
++ __MODULE_STRING(MPT_SCSI_CMD_PER_DEV_HIGH) ")");
++
+ /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
+ #define MPTFC_MAX_LUN (16895)
+ static int max_lun = MPTFC_MAX_LUN;
+@@ -183,6 +194,34 @@ static struct fc_function_template mptfc
+ .show_host_symbolic_name = 1,
+ };
+
++/**
++ * mptfc_set_sdev_queue_depth - global setting of the mpt_sdev_queue_depth
++ * found via /sys/module/mptfc/parameters/mpt_sdev_queue_depth
++ * @val:
++ * @kp:
++ *
++ * Returns
++ **/
++static int
++mptfc_set_sdev_queue_depth(const char *val, struct kernel_param *kp)
++{
++ int ret = param_set_int(val, kp);
++ MPT_ADAPTER *ioc;
++ struct scsi_device *sdev;
++
++ if (ret)
++ return ret;
++
++ list_for_each_entry(ioc, &ioc_list, list) {
++ if (ioc->bus_type != FC)
++ continue;
++ shost_for_each_device(sdev, ioc->sh)
++ mptscsih_change_queue_depth(sdev, mpt_sdev_queue_depth);
++ ioc->sdev_queue_depth = mpt_sdev_queue_depth;
++ }
++ return 0;
++}
++
+ static int
+ mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
+ int (*func)(struct scsi_cmnd *SCpnt),
+@@ -194,7 +233,7 @@ mptfc_block_error_handler(struct scsi_cm
+ struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
+ unsigned long flags;
+ int ready;
+- MPT_ADAPTER *ioc;
++ MPT_ADAPTER *ioc;
+
+ hd = shost_priv(SCpnt->device->host);
+ ioc = hd->ioc;
+@@ -231,28 +270,28 @@ static int
+ mptfc_abort(struct scsi_cmnd *SCpnt)
+ {
+ return
+- mptfc_block_error_handler(SCpnt, mptscsih_abort, __func__);
++ mptfc_block_error_handler(SCpnt, mptscsih_abort, __FUNCTION__);
+ }
+
+ static int
+ mptfc_dev_reset(struct scsi_cmnd *SCpnt)
+ {
+ return
+- mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __func__);
++ mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __FUNCTION__);
+ }
+
+ static int
+ mptfc_bus_reset(struct scsi_cmnd *SCpnt)
+ {
+ return
+- mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __func__);
++ mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __FUNCTION__);
+ }
+
+ static int
+ mptfc_host_reset(struct scsi_cmnd *SCpnt)
+ {
+ return
+- mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __func__);
++ mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __FUNCTION__);
+ }
+
+ static void
+@@ -476,6 +515,7 @@ mptfc_register_dev(MPT_ADAPTER *ioc, int
+ if (vtarget) {
+ vtarget->id = pg0->CurrentTargetID;
+ vtarget->channel = pg0->CurrentBus;
++ vtarget->deleted = 0;
+ }
+ }
+ *((struct mptfc_rport_info **)rport->dd_data) = ri;
+@@ -513,6 +553,7 @@ mptfc_target_destroy(struct scsi_target
+ struct fc_rport *rport;
+ struct mptfc_rport_info *ri;
+
++ printk("%s - starget=%p\n", __FUNCTION__, starget);
+ rport = starget_to_rport(starget);
+ if (rport) {
+ ri = *((struct mptfc_rport_info **)rport->dd_data);
+@@ -560,6 +601,7 @@ mptfc_target_alloc(struct scsi_target *s
+
+ return rc;
+ }
++
+ /*
+ * mptfc_dump_lun_info
+ * @ioc
+@@ -589,7 +631,6 @@ mptfc_dump_lun_info(MPT_ADAPTER *ioc, st
+ (unsigned long long)nn));
+ }
+
+-
+ /*
+ * OS entry point to allow host driver to alloc memory
+ * for each scsi device. Called once per device the bus scan.
+@@ -604,7 +645,7 @@ mptfc_slave_alloc(struct scsi_device *sd
+ VirtDevice *vdevice;
+ struct scsi_target *starget;
+ struct fc_rport *rport;
+- MPT_ADAPTER *ioc;
++ MPT_ADAPTER *ioc;
+
+ starget = scsi_target(sdev);
+ rport = starget_to_rport(starget);
+@@ -614,11 +655,10 @@ mptfc_slave_alloc(struct scsi_device *sd
+
+ hd = shost_priv(sdev->host);
+ ioc = hd->ioc;
+-
+ vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
+ if (!vdevice) {
+ printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
+- ioc->name, sizeof(VirtDevice));
++ ioc->name, sizeof(VirtDevice));
+ return -ENOMEM;
+ }
+
+@@ -635,10 +675,7 @@ mptfc_slave_alloc(struct scsi_device *sd
+ vdevice->lun = sdev->lun;
+
+ vtarget->num_luns++;
+-
+-
+ mptfc_dump_lun_info(ioc, rport, sdev, vtarget);
+-
+ return 0;
+ }
+
+@@ -944,11 +981,12 @@ start_over:
+ return rc;
+ }
+
+-static void
++static int
+ mptfc_SetFcPortPage1_defaults(MPT_ADAPTER *ioc)
+ {
+ int ii;
+ FCPortPage1_t *pp1;
++ int rc;
+
+ #define MPTFC_FW_DEVICE_TIMEOUT (1)
+ #define MPTFC_FW_IO_PEND_TIMEOUT (1)
+@@ -956,8 +994,8 @@ mptfc_SetFcPortPage1_defaults(MPT_ADAPTE
+ #define OFF_FLAGS (MPI_FCPORTPAGE1_FLAGS_VERBOSE_RESCAN_EVENTS)
+
+ for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
+- if (mptfc_GetFcPortPage1(ioc, ii) != 0)
+- continue;
++ if ((rc = mptfc_GetFcPortPage1(ioc, ii)) < 0)
++ return rc;
+ pp1 = ioc->fc_data.fc_port_page1[ii].data;
+ if ((pp1->InitiatorDeviceTimeout == MPTFC_FW_DEVICE_TIMEOUT)
+ && (pp1->InitiatorIoPendTimeout == MPTFC_FW_IO_PEND_TIMEOUT)
+@@ -968,8 +1006,10 @@ mptfc_SetFcPortPage1_defaults(MPT_ADAPTE
+ pp1->InitiatorIoPendTimeout = MPTFC_FW_IO_PEND_TIMEOUT;
+ pp1->Flags &= ~OFF_FLAGS;
+ pp1->Flags |= ON_FLAGS;
+- mptfc_WriteFcPortPage1(ioc, ii);
++ if ((rc = mptfc_WriteFcPortPage1(ioc, ii)) < 0)
++ return rc;
+ }
++ return 0;
+ }
+
+
+@@ -1082,10 +1122,13 @@ mptfc_link_status_change(struct work_str
+ static void
+ mptfc_setup_reset(struct work_struct *work)
+ {
+- MPT_ADAPTER *ioc =
++ MPT_ADAPTER *ioc =
+ 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) {
+@@ -1093,6 +1136,12 @@ mptfc_setup_reset(struct work_struct *wo
+ 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;
+@@ -1111,8 +1160,22 @@ mptfc_rescan_devices(struct work_struct
+ MPT_ADAPTER *ioc =
+ container_of(work, MPT_ADAPTER, fc_rescan_work);
+ int ii;
++ int rc;
+ u64 pn;
+ struct mptfc_rport_info *ri;
++ struct scsi_target *starget;
++ VirtTarget *vtarget;
++
++ /*
++ * if cannot set defaults, something's really wrong, bail out
++ */
++
++ if ((rc = mptfc_SetFcPortPage1_defaults(ioc)) < 0) {
++ dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
++ "mptfc_rescan.%d: unable to set PP1 defaults, rc %d.\n",
++ ioc->name, ioc->sh->host_no, rc));
++ return;
++ }
+
+ /* start by tagging all ports as missing */
+ list_for_each_entry(ri, &ioc->fc_rports, list) {
+@@ -1140,6 +1203,12 @@ mptfc_rescan_devices(struct work_struct
+ 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;
+@@ -1238,6 +1307,10 @@ mptfc_probe(struct pci_dev *pdev, const
+ sh->max_id = ioc->pfacts->MaxDevices;
+ sh->max_lun = max_lun;
+
++ sh->this_id = ioc->pfacts[0].PortSCSIID;
++
++ ioc->sdev_queue_depth = mpt_sdev_queue_depth;
++
+ /* Required entry.
+ */
+ sh->unique_id = ioc->id;
+@@ -1251,17 +1324,15 @@ mptfc_probe(struct pci_dev *pdev, const
+ * A slightly different algorithm is required for
+ * 64bit SGEs.
+ */
+- scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
++ scale = ioc->req_sz/ioc->SGE_size;
++ if (ioc->sg_addr_size == sizeof(u64)) {
+ numSGE = (scale - 1) *
+ (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
+- sizeof(u32));
++ (ioc->req_sz - 60) / ioc->SGE_size;
+ } else {
+ numSGE = 1 + (scale - 1) *
+ (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
+- sizeof(u32));
++ (ioc->req_sz - 64) / ioc->SGE_size;
+ }
+
+ if (numSGE < sh->sg_tablesize) {
+@@ -1290,30 +1361,6 @@ mptfc_probe(struct pci_dev *pdev, const
+ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
+ ioc->name, ioc->ScsiLookup));
+
+- /* Clear the TM flags
+- */
+- hd->tmPending = 0;
+- hd->tmState = TM_STATE_NONE;
+- hd->resetPending = 0;
+- hd->abortSCpnt = NULL;
+-
+- /* Clear the pointer used to store
+- * single-threaded commands, i.e., those
+- * issued during a bus scan, dv and
+- * configuration pages.
+- */
+- hd->cmdPtr = NULL;
+-
+- /* Initialize this SCSI Hosts' timers
+- * To use, set the timer expires field
+- * and add_timer
+- */
+- init_timer(&hd->timer);
+- hd->timer.data = (unsigned long) hd;
+- hd->timer.function = mptscsih_timer_expired;
+-
+- init_waitqueue_head(&hd->scandv_waitq);
+- hd->scandv_wait_done = 0;
+ hd->last_queue_full = 0;
+
+ sh->transportt = mptfc_transport_template;
+@@ -1326,8 +1373,8 @@ mptfc_probe(struct pci_dev *pdev, const
+
+ /* initialize workqueue */
+
+- snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name),
+- "mptfc_wq_%d", sh->host_no);
++ snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name), "mptfc_wq_%d",
++ sh->host_no);
+ ioc->fc_rescan_work_q =
+ create_singlethread_workqueue(ioc->fc_rescan_work_q_name);
+ if (!ioc->fc_rescan_work_q)
+@@ -1340,7 +1387,6 @@ mptfc_probe(struct pci_dev *pdev, const
+ for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
+ (void) mptfc_GetFcPortPage0(ioc, ii);
+ }
+- mptfc_SetFcPortPage1_defaults(ioc);
+
+ /*
+ * scan for rports -
+@@ -1378,9 +1424,6 @@ mptfc_event_process(MPT_ADAPTER *ioc, Ev
+ unsigned long flags;
+ int rc=1;
+
+- devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
+- ioc->name, event));
+-
+ if (ioc->sh == NULL ||
+ ((hd = shost_priv(ioc->sh)) == NULL))
+ return 1;
+@@ -1416,45 +1459,45 @@ mptfc_ioc_reset(MPT_ADAPTER *ioc, int re
+ unsigned long flags;
+
+ rc = mptscsih_ioc_reset(ioc,reset_phase);
+- if (rc == 0)
++ if ((ioc->bus_type != FC) || (!rc))
+ return rc;
+
+-
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- ": IOC %s_reset routed to FC host driver!\n",ioc->name,
+- reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
+- reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
+-
+- if (reset_phase == MPT_IOC_SETUP_RESET) {
++ switch(reset_phase) {
++ case MPT_IOC_SETUP_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
+ spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
+ if (ioc->fc_rescan_work_q) {
+ queue_work(ioc->fc_rescan_work_q,
+ &ioc->fc_setup_reset_work);
+ }
+ spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
+- }
+-
+- else if (reset_phase == MPT_IOC_PRE_RESET) {
+- }
+-
+- else { /* MPT_IOC_POST_RESET */
+- mptfc_SetFcPortPage1_defaults(ioc);
++ break;
++ case MPT_IOC_PRE_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
++ break;
++ case MPT_IOC_POST_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
+ spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
+ if (ioc->fc_rescan_work_q) {
+ queue_work(ioc->fc_rescan_work_q,
+ &ioc->fc_rescan_work);
+ }
+ spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
++ break;
++ default:
++ break;
+ }
+ return 1;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mptfc_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int __init
+ mptfc_init(void)
+ {
+@@ -1486,12 +1529,11 @@ mptfc_init(void)
+ return error;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mptfc_remove - Remove fc infrastructure for devices
+ * @pdev: Pointer to pci_dev structure
+ *
+- */
++ **/
+ static void __devexit
+ mptfc_remove(struct pci_dev *pdev)
+ {
+@@ -1501,6 +1543,8 @@ mptfc_remove(struct pci_dev *pdev)
+ unsigned long flags;
+ int ii;
+
++ printk("%s -pdev=%p\n", __FUNCTION__, pdev);
++
+ /* destroy workqueue */
+ if ((work_q=ioc->fc_rescan_work_q)) {
+ spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
+@@ -1543,7 +1587,6 @@ mptfc_exit(void)
+
+ mpt_reset_deregister(mptfcDoneCtx);
+ mpt_event_deregister(mptfcDoneCtx);
+-
+ mpt_deregister(mptfcInternalCtx);
+ mpt_deregister(mptfcTaskCtx);
+ mpt_deregister(mptfcDoneCtx);
+--- a/drivers/message/fusion/mptlan.c
++++ b/drivers/message/fusion/mptlan.c
+@@ -6,7 +6,6 @@
+ *
+ * Copyright (c) 2000-2008 LSI Corporation
+ * (mailto:DL-MPTFusionLinux@lsi.com)
+- *
+ */
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /*
+@@ -165,6 +164,11 @@ DEFINE_RWLOCK(bad_naa_lock);
+ #endif
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/*
++ * Fusion MPT LAN external data
++ */
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * lan_reply - Handle all data sent from the hardware.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -190,8 +194,7 @@ lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_H
+ u32 tmsg = CAST_PTR_TO_U32(reply);
+
+ dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08x\n",
+- IOC_AND_NETDEV_NAMES_s_s(dev),
+- tmsg));
++ IOC_AND_NETDEV_NAMES_s_s(dev), tmsg));
+
+ switch (GET_LAN_FORM(tmsg)) {
+
+@@ -440,6 +443,7 @@ mpt_lan_open(struct net_device *dev)
+ dlprintk((KERN_INFO MYNAM "/lo: Finished initializing RcvCtl\n"));
+
+ mpt_lan_post_receive_buckets(priv);
++
+ printk(KERN_INFO MYNAM ": %s/%s: interface up & active\n",
+ IOC_AND_NETDEV_NAMES_s_s(dev));
+
+@@ -610,7 +614,7 @@ mpt_lan_send_turbo(struct net_device *de
+
+ dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
+ IOC_AND_NETDEV_NAMES_s_s(dev),
+- __func__, sent));
++ __FUNCTION__, sent));
+
+ priv->SendCtl[ctx].skb = NULL;
+ pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
+@@ -676,7 +680,7 @@ mpt_lan_send_reply(struct net_device *de
+
+ dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
+ IOC_AND_NETDEV_NAMES_s_s(dev),
+- __func__, sent));
++ __FUNCTION__, sent));
+
+ priv->SendCtl[ctx].skb = NULL;
+ pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
+@@ -715,7 +719,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
+ u16 cur_naa = 0x1000;
+
+ dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %p\n",
+- __func__, skb));
++ __FUNCTION__, skb));
+
+ spin_lock_irqsave(&priv->txfidx_lock, flags);
+ if (priv->mpt_txfidx_tail < 0) {
+@@ -723,7 +727,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
+ spin_unlock_irqrestore(&priv->txfidx_lock, flags);
+
+ printk (KERN_ERR "%s: no tx context available: %u\n",
+- __func__, priv->mpt_txfidx_tail);
++ __FUNCTION__, priv->mpt_txfidx_tail);
+ return 1;
+ }
+
+@@ -733,7 +737,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
+ spin_unlock_irqrestore(&priv->txfidx_lock, flags);
+
+ printk (KERN_ERR "%s: Unable to alloc request frame\n",
+- __func__);
++ __FUNCTION__);
+ return 1;
+ }
+
+@@ -780,6 +784,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
+ // ctx, skb, skb->data));
+
+ mac = skb_mac_header(skb);
++
+ #ifdef QLOGIC_NAA_WORKAROUND
+ {
+ struct NAA_Hosed *nh;
+@@ -805,6 +810,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
+ }
+ #endif
+
++
+ pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa << 16) |
+ (mac[0] << 8) |
+ (mac[1] << 0));
+@@ -828,7 +834,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
+ MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
+ skb->len);
+ pSimple->Address.Low = cpu_to_le32((u32) dma);
+- if (sizeof(dma_addr_t) > sizeof(u32))
++ if (mpt_dev->sg_addr_size > sizeof(u32))
+ pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
+ else
+ pSimple->Address.High = 0;
+@@ -1117,7 +1123,6 @@ mpt_lan_receive_post_reply(struct net_de
+ PCI_DMA_FROMDEVICE);
+
+ skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
+-
+ pci_dma_sync_single_for_device(mpt_dev->pcidev,
+ priv->RcvCtl[ctx].dma,
+ priv->RcvCtl[ctx].len,
+@@ -1208,7 +1213,7 @@ mpt_lan_post_receive_buckets(struct mpt_
+
+ dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n",
+ IOC_AND_NETDEV_NAMES_s_s(dev),
+- __func__, buckets, curr));
++ __FUNCTION__, buckets, curr));
+
+ max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
+ (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
+@@ -1217,9 +1222,9 @@ mpt_lan_post_receive_buckets(struct mpt_
+ mf = mpt_get_msg_frame(LanCtx, mpt_dev);
+ if (mf == NULL) {
+ printk (KERN_ERR "%s: Unable to alloc request frame\n",
+- __func__);
++ __FUNCTION__);
+ dioprintk((KERN_ERR "%s: %u buckets remaining\n",
+- __func__, buckets));
++ __FUNCTION__, buckets));
+ goto out;
+ }
+ pRecvReq = (LANReceivePostRequest_t *) mf;
+@@ -1244,7 +1249,7 @@ mpt_lan_post_receive_buckets(struct mpt_
+ spin_lock_irqsave(&priv->rxfidx_lock, flags);
+ if (priv->mpt_rxfidx_tail < 0) {
+ printk (KERN_ERR "%s: Can't alloc context\n",
+- __func__);
++ __FUNCTION__);
+ spin_unlock_irqrestore(&priv->rxfidx_lock,
+ flags);
+ break;
+@@ -1267,7 +1272,7 @@ mpt_lan_post_receive_buckets(struct mpt_
+ if (skb == NULL) {
+ printk (KERN_WARNING
+ MYNAM "/%s: Can't alloc skb\n",
+- __func__);
++ __FUNCTION__);
+ priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
+ spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
+ break;
+@@ -1295,7 +1300,7 @@ mpt_lan_post_receive_buckets(struct mpt_
+ MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+ MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
+ pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
+- if (sizeof(dma_addr_t) > sizeof(u32))
++ if (mpt_dev->sg_addr_size > sizeof(u32))
+ pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
+ else
+ pSimple->Address.High = 0;
+@@ -1305,7 +1310,7 @@ mpt_lan_post_receive_buckets(struct mpt_
+
+ if (pSimple == NULL) {
+ /**/ printk (KERN_WARNING MYNAM "/%s: No buckets posted\n",
+-/**/ __func__);
++/**/ __FUNCTION__);
+ mpt_free_msg_frame(mpt_dev, mf);
+ goto out;
+ }
+@@ -1329,9 +1334,9 @@ mpt_lan_post_receive_buckets(struct mpt_
+
+ out:
+ dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n",
+- __func__, buckets, atomic_read(&priv->buckets_out)));
++ __FUNCTION__, buckets, atomic_read(&priv->buckets_out)));
+ dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n",
+- __func__, priv->total_posted, priv->total_received));
++ __FUNCTION__, priv->total_posted, priv->total_received));
+
+ clear_bit(0, &priv->post_buckets_active);
+ }
+@@ -1340,18 +1345,17 @@ static void
+ mpt_lan_post_receive_buckets_work(struct work_struct *work)
+ {
+ mpt_lan_post_receive_buckets(container_of(work, struct mpt_lan_priv,
+- post_buckets_task.work));
++ post_buckets_task.work));
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ static struct net_device *
+ mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
+ {
+- struct net_device *dev;
+- struct mpt_lan_priv *priv;
++ struct net_device *dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
++ struct mpt_lan_priv *priv = NULL;
+ u8 HWaddr[FC_ALEN], *a;
+
+- dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
+ if (!dev)
+ return NULL;
+
+@@ -1363,8 +1367,9 @@ mpt_register_lan_device (MPT_ADAPTER *mp
+ priv->mpt_dev = mpt_dev;
+ priv->pnum = pnum;
+
++ memset(&priv->post_buckets_task, 0, sizeof(priv->post_buckets_task));
+ INIT_DELAYED_WORK(&priv->post_buckets_task,
+- mpt_lan_post_receive_buckets_work);
++ mpt_lan_post_receive_buckets_work);
+ priv->post_buckets_active = 0;
+
+ dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n",
+@@ -1387,6 +1392,8 @@ mpt_register_lan_device (MPT_ADAPTER *mp
+ spin_lock_init(&priv->txfidx_lock);
+ spin_lock_init(&priv->rxfidx_lock);
+
++ memset(&priv->stats, 0, sizeof(priv->stats));
++
+ /* Grab pre-fetched LANPage1 stuff. :-) */
+ a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
+
+@@ -1421,6 +1428,7 @@ mpt_register_lan_device (MPT_ADAPTER *mp
+ dlprintk((KERN_INFO MYNAM ": Finished registering dev "
+ "and setting initial values\n"));
+
++
+ if (register_netdev(dev) != 0) {
+ free_netdev(dev);
+ dev = NULL;
+--- a/drivers/message/fusion/mptlan.h
++++ b/drivers/message/fusion/mptlan.h
+@@ -6,7 +6,6 @@
+ *
+ * Copyright (c) 2000-2008 LSI Corporation
+ * (mailto:DL-MPTFusionLinux@lsi.com)
+- *
+ */
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /*
+@@ -55,6 +54,7 @@
+ #include <linux/module.h>
+ #endif
+
++#include <linux/version.h>
+ #include <linux/netdevice.h>
+ #include <linux/errno.h>
+ // #include <linux/etherdevice.h>
+@@ -73,6 +73,7 @@
+
+ #include <asm/uaccess.h>
+ #include <asm/io.h>
++#include <linux/pci.h>
+
+ /* Override mptbase.h by pre-defining these! */
+ #define MODULEAUTHOR "LSI Corporation"
+--- a/drivers/message/fusion/mptsas.c
++++ b/drivers/message/fusion/mptsas.c
+@@ -47,9 +47,11 @@
+ #include <linux/kernel.h>
+ #include <linux/init.h>
+ #include <linux/errno.h>
+-#include <linux/jiffies.h>
++#include <linux/sched.h>
+ #include <linux/workqueue.h>
++#include <linux/interrupt.h>
+ #include <linux/delay.h> /* for mdelay */
++#include <linux/pci.h>
+
+ #include <scsi/scsi.h>
+ #include <scsi/scsi_cmnd.h>
+@@ -62,7 +64,6 @@
+ #include "mptscsih.h"
+ #include "mptsas.h"
+
+-
+ #define my_NAME "Fusion MPT SAS Host driver"
+ #define my_VERSION MPT_LINUX_VERSION_COMMON
+ #define MYNAM "mptsas"
+@@ -72,6 +73,8 @@
+ */
+ #define MPTSAS_RAID_CHANNEL 1
+
++#define SAS_CONFIG_PAGE_TIMEOUT 30
++
+ MODULE_AUTHOR(MODULEAUTHOR);
+ MODULE_DESCRIPTION(my_NAME);
+ MODULE_LICENSE("GPL");
+@@ -83,6 +86,25 @@ MODULE_PARM_DESC(mpt_pt_clear,
+ " Clear persistency table: enable=1 "
+ "(default=MPTSCSIH_PT_CLEAR=0)");
+
++static int mpt_cmd_retry_count = 144;
++module_param(mpt_cmd_retry_count, int, 0);
++MODULE_PARM_DESC(mpt_cmd_retry_count,
++ " Device discovery TUR command retry count: default=144");
++
++static int mpt_disable_hotplug_remove = 0;
++module_param(mpt_disable_hotplug_remove, int, 0);
++MODULE_PARM_DESC(mpt_disable_hotplug_remove,
++ " Disable hotpug remove events: default=0");
++
++static int mpt_sdev_queue_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
++static int mptsas_set_sdev_queue_depth(const char *val,
++ struct kernel_param *kp);
++module_param_call(mpt_sdev_queue_depth, mptsas_set_sdev_queue_depth,
++ param_get_int, &mpt_sdev_queue_depth, 0600);
++MODULE_PARM_DESC(mpt_sdev_queue_depth,
++ " Max Device Queue Depth (default="
++ __MODULE_STRING(MPT_SCSI_CMD_PER_DEV_HIGH) ")");
++
+ /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
+ #define MPTSAS_MAX_LUN (16895)
+ static int max_lun = MPTSAS_MAX_LUN;
+@@ -93,8 +115,53 @@ static u8 mptsasDoneCtx = MPT_MAX_PROTOC
+ static u8 mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
+ static u8 mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
+ static u8 mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS;
++static u8 mptsasDeviceResetCtx = MPT_MAX_PROTOCOL_DRIVERS;
++
++static inline void mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy);
++static struct mptsas_phyinfo * mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc,
++ u64 sas_address);
++static int mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
++ u32 form, u32 form_specific);
++static int mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
++ u32 form, u32 form_specific);
++
++static int mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info);
++static void mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info);
++static void mptsas_expander_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info);
++static int mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
++ u32 form, u32 form_specific);
++static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);
++static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);
++
++static void mptsas_firmware_event_work(struct work_struct *work);
++
++/**
++ * mptsas_set_sdev_queue_depth - global setting of the mpt_sdev_queue_depth
++ * found via /sys/module/mptsas/parameters/mpt_sdev_queue_depth
++ * @val:
++ * @kp:
++ *
++ * Returns
++ **/
++static int
++mptsas_set_sdev_queue_depth(const char *val, struct kernel_param *kp)
++{
++ int ret = param_set_int(val, kp);
++ MPT_ADAPTER *ioc;
++ struct scsi_device *sdev;
+
+-static void mptsas_hotplug_work(struct work_struct *work);
++ if (ret)
++ return ret;
++
++ list_for_each_entry(ioc, &ioc_list, list) {
++ if (ioc->bus_type != SAS)
++ continue;
++ shost_for_each_device(sdev, ioc->sh)
++ mptscsih_change_queue_depth(sdev, mpt_sdev_queue_depth);
++ ioc->sdev_queue_depth = mpt_sdev_queue_depth;
++ }
++ return 0;
++}
+
+ static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
+ MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
+@@ -218,37 +285,183 @@ static void mptsas_print_expander_pg1(MP
+ le16_to_cpu(pg1->AttachedDevHandle)));
+ }
+
+-static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
++/* inhibit sas firmware event handling */
++static void
++mptsas_fw_event_off(MPT_ADAPTER *ioc)
++{
++ unsigned long flags;
++
++ spin_lock_irqsave(&ioc->fw_event_lock, flags);
++ ioc->fw_events_off = 1;
++ spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
++
++}
++
++/* enable sas firmware event handling */
++static void
++mptsas_fw_event_on(MPT_ADAPTER *ioc)
++{
++ unsigned long flags;
++
++ spin_lock_irqsave(&ioc->fw_event_lock, flags);
++ ioc->fw_events_off = 0;
++ spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
++}
++
++/* queue a sas firmware event */
++static void
++mptsas_add_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
++ unsigned long delay)
++{
++ unsigned long flags;
++
++#if defined(CPQ_CIM)
++ ioc->csmi_change_count++;
++#endif
++
++ spin_lock_irqsave(&ioc->fw_event_lock, flags);
++ list_add_tail(&fw_event->list, &ioc->fw_event_list);
++ INIT_DELAYED_WORK(&fw_event->work, mptsas_firmware_event_work);
++ devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: add (fw_event=0x%p)\n",
++ ioc->name,__FUNCTION__, fw_event));
++ queue_delayed_work(ioc->fw_event_q, &fw_event->work,
++ msecs_to_jiffies(delay));
++ spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
++}
++
++/* requeue a sas firmware event */
++static void
++mptsas_requeue_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
++ unsigned long delay)
++{
++ unsigned long flags;
++ spin_lock_irqsave(&ioc->fw_event_lock, flags);
++ devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: reschedule task "
++ "(fw_event=0x%p)\n", ioc->name,__FUNCTION__, fw_event));
++ fw_event->retries++;
++ queue_delayed_work(ioc->fw_event_q, &fw_event->work,
++ msecs_to_jiffies(delay));
++ spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
++}
++
++/* free memory assoicated to a sas firmware event */
++static void
++mptsas_free_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event)
++{
++ unsigned long flags;
++
++ spin_lock_irqsave(&ioc->fw_event_lock, flags);
++ devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: kfree (fw_event=0x%p)\n",
++ ioc->name,__FUNCTION__, fw_event));
++ list_del(&fw_event->list);
++ kfree(fw_event);
++ spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
++}
++
++/* walk the firmware event queue, and either stop or wait for outstanding events to complete */
++static void
++mptsas_cleanup_fw_event_q(MPT_ADAPTER *ioc)
++{
++ struct fw_event_work *fw_event, *next;
++ struct mptsas_target_reset_event *target_reset_list, *n;
++ u8 flush_q;
++ MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
++
++ /* flush the target_reset_list */
++ if (!list_empty(&hd->target_reset_list)) {
++ list_for_each_entry_safe(target_reset_list, n,
++ &hd->target_reset_list, list) {
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: removing target reset for id=%d\n",
++ ioc->name, __FUNCTION__,
++ target_reset_list->sas_event_data.TargetID));
++ list_del(&target_reset_list->list);
++ kfree(target_reset_list);
++ }
++ }
++
++ if (list_empty(&ioc->fw_event_list) ||
++ !ioc->fw_event_q || in_interrupt())
++ return;
++
++ flush_q = 0;
++ list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
++ if (cancel_delayed_work(&fw_event->work))
++ mptsas_free_fw_event(ioc, fw_event);
++ else
++ flush_q = 1;
++ }
++ if (flush_q)
++ flush_workqueue(ioc->fw_event_q);
++}
++
++
++/**
++ * phy_to_ioc -
++ * @phy:
++ *
++ *
++ **/
++static inline MPT_ADAPTER *
++phy_to_ioc(struct sas_phy *phy)
+ {
+ struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
+ return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
+ }
+
+-static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
++/**
++ * rphy_to_ioc -
++ * @rphy:
++ *
++ *
++ **/
++static inline MPT_ADAPTER *
++rphy_to_ioc(struct sas_rphy *rphy)
+ {
+ struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
+ return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
+ }
+
++/**
++ * mptsas_find_portinfo_by_sas_address -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @handle:
++ *
++ * This function should be called with the sas_topology_mutex already held
++ *
++ **/
+ static struct mptsas_portinfo *
+-mptsas_get_hba_portinfo(MPT_ADAPTER *ioc)
++mptsas_find_portinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
+ {
+- struct list_head *head = &ioc->sas_topology;
+- struct mptsas_portinfo *pi = NULL;
+-
+- /* always the first entry on sas_topology list */
+-
+- if (!list_empty(head))
+- pi = list_entry(head->next, struct mptsas_portinfo, list);
++ struct mptsas_portinfo *port_info, *rc=NULL;
++ int i;
++
++ if (sas_address >= ioc->hba_port_sas_addr &&
++ sas_address < (ioc->hba_port_sas_addr +
++ ioc->hba_port_num_phy))
++ return ioc->hba_port_info;
+
+- return pi;
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_for_each_entry(port_info, &ioc->sas_topology, list)
++ for (i = 0; i < port_info->num_phys; i++)
++ if (port_info->phy_info[i].identify.sas_address ==
++ sas_address) {
++ rc = port_info;
++ goto out;
++ }
++ out:
++ mutex_unlock(&ioc->sas_topology_mutex);
++ return rc;
+ }
+
+-/*
+- * mptsas_find_portinfo_by_handle
++/**
++ * mptsas_find_portinfo_by_handle -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @handle:
+ *
+- * This function should be called with the sas_topology_mutex already held
+- */
++ * This function should be called with the sas_topology_mutex already held
++ *
++ **/
+ static struct mptsas_portinfo *
+ mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
+ {
+@@ -265,9 +478,12 @@ mptsas_find_portinfo_by_handle(MPT_ADAPT
+ return rc;
+ }
+
+-/*
+- * Returns true if there is a scsi end device
+- */
++/**
++ * mptsas_is_end_device -
++ * @attached:
++ *
++ * Returns true if there is a scsi end device
++ **/
+ static inline int
+ mptsas_is_end_device(struct mptsas_devinfo * attached)
+ {
+@@ -285,7 +501,14 @@ mptsas_is_end_device(struct mptsas_devin
+ return 0;
+ }
+
+-/* no mutex */
++/**
++ * mptsas_port_delete -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @port_details:
++ *
++ * (no mutex)
++ *
++ **/
+ static void
+ mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
+ {
+@@ -300,7 +523,7 @@ mptsas_port_delete(MPT_ADAPTER *ioc, str
+ phy_info = port_info->phy_info;
+
+ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d "
+- "bitmask=0x%016llX\n", ioc->name, __func__, port_details,
++ "bitmask=0x%016llX\n", ioc->name, __FUNCTION__, port_details,
+ port_details->num_phys, (unsigned long long)
+ port_details->phy_bitmask));
+
+@@ -308,11 +531,17 @@ mptsas_port_delete(MPT_ADAPTER *ioc, str
+ if(phy_info->port_details != port_details)
+ continue;
+ memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
++ mptsas_set_rphy(ioc, phy_info, NULL);
+ phy_info->port_details = NULL;
+ }
+ kfree(port_details);
+ }
+
++/**
++ * mptsas_get_rphy -
++ * @phy_info:
++ *
++ **/
+ static inline struct sas_rphy *
+ mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
+ {
+@@ -322,13 +551,20 @@ mptsas_get_rphy(struct mptsas_phyinfo *p
+ return NULL;
+ }
+
++/**
++ * mptsas_set_rphy -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @phy_info:
++ * @rphy:
++ *
++ **/
+ static inline void
+ mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
+ {
+ if (phy_info->port_details) {
+ phy_info->port_details->rphy = rphy;
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n",
+- ioc->name, rphy));
++ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "sas_rphy_add: rphy=%p\n", ioc->name, rphy));
+ }
+
+ if (rphy) {
+@@ -339,6 +575,11 @@ mptsas_set_rphy(MPT_ADAPTER *ioc, struct
+ }
+ }
+
++/**
++ * mptsas_get_port -
++ * @phy_info:
++ *
++ **/
+ static inline struct sas_port *
+ mptsas_get_port(struct mptsas_phyinfo *phy_info)
+ {
+@@ -348,6 +589,13 @@ mptsas_get_port(struct mptsas_phyinfo *p
+ return NULL;
+ }
+
++/**
++ * mptsas_set_port -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @phy_info:
++ * @port:
++ *
++ **/
+ static inline void
+ mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
+ {
+@@ -362,6 +610,11 @@ mptsas_set_port(MPT_ADAPTER *ioc, struct
+ }
+ }
+
++/**
++ * mptsas_get_starget -
++ * @phy_info:
++ *
++ **/
+ static inline struct scsi_target *
+ mptsas_get_starget(struct mptsas_phyinfo *phy_info)
+ {
+@@ -371,6 +624,12 @@ mptsas_get_starget(struct mptsas_phyinfo
+ return NULL;
+ }
+
++/**
++ * mptsas_set_starget -
++ * @phy_info:
++ * @starget:
++ *
++ **/
+ static inline void
+ mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
+ starget)
+@@ -379,714 +638,787 @@ starget)
+ phy_info->port_details->starget = starget;
+ }
+
+-
+-/*
+- * mptsas_setup_wide_ports
++/**
++ * mptsas_add_device_component -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel: fw mapped id's
++ * @id:
++ * @sas_address:
++ * @device_info:
+ *
+- * Updates for new and existing narrow/wide port configuration
+- * in the sas_topology
+- */
++ **/
+ static void
+-mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
++mptsas_add_device_component(MPT_ADAPTER *ioc, u8 channel, u8 id,
++ u64 sas_address, u32 device_info, u16 slot, u64 enclosure_logical_id)
+ {
+- struct mptsas_portinfo_details * port_details;
+- struct mptsas_phyinfo *phy_info, *phy_info_cmp;
+- u64 sas_address;
+- int i, j;
+-
+- mutex_lock(&ioc->sas_topology_mutex);
+-
+- phy_info = port_info->phy_info;
+- for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
+- if (phy_info->attached.handle)
+- continue;
+- port_details = phy_info->port_details;
+- if (!port_details)
+- continue;
+- if (port_details->num_phys < 2)
+- continue;
+- /*
+- * Removing a phy from a port, letting the last
+- * phy be removed by firmware events.
+- */
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "%s: [%p]: deleting phy = %d\n",
+- ioc->name, __func__, port_details, i));
+- port_details->num_phys--;
+- port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
+- memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
+- sas_port_delete_phy(port_details->port, phy_info->phy);
+- phy_info->port_details = NULL;
++ struct sas_device_info *sas_info, *next;
++ struct scsi_device *sdev;
++ struct scsi_target *starget;
++ struct sas_rphy *rphy;
++
++ /*
++ * Delete all matching devices out of the list
++ */
++ down(&ioc->sas_device_info_mutex);
++ list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
++ list) {
++ if (!sas_info->is_logical_volume &&
++ (sas_info->sas_address == sas_address ||
++ (sas_info->fw.channel == channel &&
++ sas_info->fw.id == id))) {
++ list_del(&sas_info->list);
++ kfree(sas_info);
++ }
+ }
+
++ if (!(sas_info = kzalloc(sizeof(struct sas_device_info), GFP_KERNEL)))
++ goto out;
++
+ /*
+- * Populate and refresh the tree
++ * Set Firmware mapping
+ */
+- phy_info = port_info->phy_info;
+- for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
+- sas_address = phy_info->attached.sas_address;
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
+- ioc->name, i, (unsigned long long)sas_address));
+- if (!sas_address)
+- continue;
+- port_details = phy_info->port_details;
+- /*
+- * Forming a port
+- */
+- if (!port_details) {
+- port_details = kzalloc(sizeof(*port_details),
+- GFP_KERNEL);
+- if (!port_details)
+- goto out;
+- port_details->num_phys = 1;
+- port_details->port_info = port_info;
+- if (phy_info->phy_id < 64 )
+- port_details->phy_bitmask |=
+- (1 << phy_info->phy_id);
+- phy_info->sas_port_add_phy=1;
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
+- "phy_id=%d sas_address=0x%018llX\n",
+- ioc->name, i, (unsigned long long)sas_address));
+- phy_info->port_details = port_details;
+- }
++ sas_info->fw.id = id;
++ sas_info->fw.channel = channel;
+
+- if (i == port_info->num_phys - 1)
+- continue;
+- phy_info_cmp = &port_info->phy_info[i + 1];
+- for (j = i + 1 ; j < port_info->num_phys ; j++,
+- phy_info_cmp++) {
+- if (!phy_info_cmp->attached.sas_address)
+- continue;
+- if (sas_address != phy_info_cmp->attached.sas_address)
+- continue;
+- if (phy_info_cmp->port_details == port_details )
+- continue;
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "\t\tphy_id=%d sas_address=0x%018llX\n",
+- ioc->name, j, (unsigned long long)
+- phy_info_cmp->attached.sas_address));
+- if (phy_info_cmp->port_details) {
+- port_details->rphy =
+- mptsas_get_rphy(phy_info_cmp);
+- port_details->port =
+- mptsas_get_port(phy_info_cmp);
+- port_details->starget =
+- mptsas_get_starget(phy_info_cmp);
+- port_details->num_phys =
+- phy_info_cmp->port_details->num_phys;
+- if (!phy_info_cmp->port_details->num_phys)
+- kfree(phy_info_cmp->port_details);
+- } else
+- phy_info_cmp->sas_port_add_phy=1;
+- /*
+- * Adding a phy to a port
+- */
+- phy_info_cmp->port_details = port_details;
+- if (phy_info_cmp->phy_id < 64 )
+- port_details->phy_bitmask |=
+- (1 << phy_info_cmp->phy_id);
+- port_details->num_phys++;
++ sas_info->sas_address = sas_address;
++ sas_info->device_info = device_info;
++ sas_info->slot = slot;
++ sas_info->enclosure_logical_id = enclosure_logical_id;
++ INIT_LIST_HEAD(&sas_info->list);
++ list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
++
++ /*
++ * Set OS mapping
++ */
++ shost_for_each_device(sdev, ioc->sh) {
++ starget = scsi_target(sdev);
++ rphy = dev_to_rphy(starget->dev.parent);
++ if (rphy->identify.sas_address == sas_address) {
++ sas_info->os.id = starget->id;
++ sas_info->os.channel = starget->channel;
+ }
+ }
+
+ out:
+-
+- for (i = 0; i < port_info->num_phys; i++) {
+- port_details = port_info->phy_info[i].port_details;
+- if (!port_details)
+- continue;
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "%s: [%p]: phy_id=%02d num_phys=%02d "
+- "bitmask=0x%016llX\n", ioc->name, __func__,
+- port_details, i, port_details->num_phys,
+- (unsigned long long)port_details->phy_bitmask));
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
+- ioc->name, port_details->port, port_details->rphy));
+- }
+- dsaswideprintk(ioc, printk("\n"));
+- mutex_unlock(&ioc->sas_topology_mutex);
++ up(&ioc->sas_device_info_mutex);
++ return;
+ }
+
+ /**
+- * csmisas_find_vtarget
+- *
+- * @ioc
+- * @volume_id
+- * @volume_bus
++ * mptsas_add_device_component_by_fw -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel: fw mapped id's
++ * @id:
+ *
+ **/
+-static VirtTarget *
+-mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
++static void
++mptsas_add_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
+ {
+- struct scsi_device *sdev;
+- VirtDevice *vdevice;
+- VirtTarget *vtarget = NULL;
++ struct mptsas_devinfo sas_device;
++ struct mptsas_enclosure enclosure_info;
++ int rc;
+
+- shost_for_each_device(sdev, ioc->sh) {
+- if ((vdevice = sdev->hostdata) == NULL)
+- continue;
+- if (vdevice->vtarget->id == id &&
+- vdevice->vtarget->channel == channel)
+- vtarget = vdevice->vtarget;
+- }
+- return vtarget;
++ rc = mptsas_sas_device_pg0(ioc, &sas_device,
++ (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ (channel << 8) + id);
++ if (rc)
++ return;
++
++ memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
++ mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
++ (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
++ MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
++ sas_device.handle_enclosure);
++
++ mptsas_add_device_component(ioc, sas_device.channel,
++ sas_device.id, sas_device.sas_address, sas_device.device_info,
++ sas_device.slot, enclosure_info.enclosure_logical_id);
+ }
+
+ /**
+- * mptsas_target_reset
+- *
+- * Issues TARGET_RESET to end device using handshaking method
+- *
+- * @ioc
+- * @channel
+- * @id
+- *
+- * Returns (1) success
+- * (0) failure
+- *
+- **/
+-static int
+-mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
+-{
+- MPT_FRAME_HDR *mf;
+- SCSITaskMgmt_t *pScsiTm;
+-
+- if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
+- dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n",
+- ioc->name,__func__, __LINE__));
+- return 0;
+- }
+-
+- /* Format the Request
+- */
+- pScsiTm = (SCSITaskMgmt_t *) mf;
+- memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
+- pScsiTm->TargetID = id;
+- pScsiTm->Bus = channel;
+- pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
+- pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
+- pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
+-
+- DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
+-
+- mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
+-
+- return 1;
+-}
+-
+-/**
+- * mptsas_target_reset_queue
+- *
+- * Receive request for TARGET_RESET after recieving an firmware
+- * event NOT_RESPONDING_EVENT, then put command in link list
+- * and queue if task_queue already in use.
+- *
+- * @ioc
+- * @sas_event_data
++ * mptsas_add_device_component_starget_ir - Handle Integrated RAID, adding
++ * each individual device to list
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel: fw mapped id's
++ * @id:
+ *
+ **/
+ static void
+-mptsas_target_reset_queue(MPT_ADAPTER *ioc,
+- EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
++mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc, struct scsi_target *starget)
+ {
+- MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
+- VirtTarget *vtarget = NULL;
+- struct mptsas_target_reset_event *target_reset_list;
+- u8 id, channel;
++ CONFIGPARMS cfg;
++ ConfigPageHeader_t hdr;
++ dma_addr_t dma_handle;
++ pRaidVolumePage0_t buffer = NULL;
++ int i;
++ RaidPhysDiskPage0_t phys_disk;
++ struct sas_device_info *sas_info, *next;
+
+- id = sas_event_data->TargetID;
+- channel = sas_event_data->Bus;
++ memset(&cfg, 0 , sizeof(CONFIGPARMS));
++ memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
++ hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
++ /* assumption that all volumes on channel = 0 */
++ cfg.pageAddr = starget->id;
++ cfg.cfghdr.hdr = &hdr;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+- if (!(vtarget = mptsas_find_vtarget(ioc, channel, id)))
+- return;
++ if (mpt_config(ioc, &cfg) != 0)
++ goto out;
+
+- vtarget->deleted = 1; /* block IO */
++ if (!hdr.PageLength)
++ goto out;
+
+- target_reset_list = kzalloc(sizeof(*target_reset_list),
+- GFP_ATOMIC);
+- if (!target_reset_list) {
+- dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
+- ioc->name,__func__, __LINE__));
+- return;
+- }
++ buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
++ &dma_handle);
+
+- memcpy(&target_reset_list->sas_event_data, sas_event_data,
+- sizeof(*sas_event_data));
+- list_add_tail(&target_reset_list->list, &hd->target_reset_list);
++ if (!buffer)
++ goto out;
+
+- if (hd->resetPending)
+- return;
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+
+- if (mptsas_target_reset(ioc, channel, id)) {
+- target_reset_list->target_reset_issued = 1;
+- hd->resetPending = 1;
+- }
+-}
++ if (mpt_config(ioc, &cfg) != 0)
++ goto out;
+
+-/**
+- * mptsas_dev_reset_complete
+- *
+- * Completion for TARGET_RESET after NOT_RESPONDING_EVENT,
+- * enable work queue to finish off removing device from upper layers.
+- * then send next TARGET_RESET in the queue.
+- *
+- * @ioc
+- *
+- **/
+-static void
+-mptsas_dev_reset_complete(MPT_ADAPTER *ioc)
+-{
+- MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
+- struct list_head *head = &hd->target_reset_list;
+- struct mptsas_target_reset_event *target_reset_list;
+- struct mptsas_hotplug_event *ev;
+- EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
+- u8 id, channel;
+- __le64 sas_address;
++ if (!buffer->NumPhysDisks)
++ goto out;
+
+- if (list_empty(head))
+- return;
++ /*
++ * Adding entry for hidden components
++ */
++ for (i = 0; i < buffer->NumPhysDisks; i++) {
+
+- target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, list);
++ if(mpt_raid_phys_disk_pg0(ioc,
++ buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
++ continue;
+
+- sas_event_data = &target_reset_list->sas_event_data;
+- id = sas_event_data->TargetID;
+- channel = sas_event_data->Bus;
+- hd->resetPending = 0;
++ mptsas_add_device_component_by_fw(ioc, phys_disk.PhysDiskBus,
++ phys_disk.PhysDiskID);
+
+- /*
+- * retry target reset
+- */
+- if (!target_reset_list->target_reset_issued) {
+- if (mptsas_target_reset(ioc, channel, id)) {
+- target_reset_list->target_reset_issued = 1;
+- hd->resetPending = 1;
++ down(&ioc->sas_device_info_mutex);
++ list_for_each_entry(sas_info, &ioc->sas_device_info_list,
++ list) {
++ if (!sas_info->is_logical_volume &&
++ (sas_info->fw.channel == phys_disk.PhysDiskBus &&
++ sas_info->fw.id == phys_disk.PhysDiskID)) {
++ sas_info->is_hidden_raid_component = 1;
++ sas_info->volume_id = starget->id;
++ }
+ }
+- return;
++ up(&ioc->sas_device_info_mutex);
+ }
+
+ /*
+- * enable work queue to remove device from upper layers
++ * Delete all matching devices out of the list
+ */
+- list_del(&target_reset_list->list);
++ down(&ioc->sas_device_info_mutex);
++ list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
++ list) {
++ if (sas_info->is_logical_volume && sas_info->fw.id ==
++ starget->id) {
++ list_del(&sas_info->list);
++ kfree(sas_info);
++ }
++ }
+
+- ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+- if (!ev) {
+- dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
+- ioc->name,__func__, __LINE__));
+- return;
++ sas_info = kzalloc(sizeof(struct sas_device_info), GFP_KERNEL);
++ if (sas_info) {
++ sas_info->fw.id = starget->id;
++ sas_info->os.id = starget->id;
++ sas_info->os.channel = starget->channel;
++ sas_info->is_logical_volume = 1;
++ INIT_LIST_HEAD(&sas_info->list);
++ list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
+ }
++ up(&ioc->sas_device_info_mutex);
+
+- INIT_WORK(&ev->work, mptsas_hotplug_work);
+- ev->ioc = ioc;
+- ev->handle = le16_to_cpu(sas_event_data->DevHandle);
+- ev->parent_handle =
+- le16_to_cpu(sas_event_data->ParentDevHandle);
+- ev->channel = channel;
+- ev->id =id;
+- ev->phy_id = sas_event_data->PhyNum;
+- memcpy(&sas_address, &sas_event_data->SASAddress,
+- sizeof(__le64));
+- ev->sas_address = le64_to_cpu(sas_address);
+- ev->device_info = le32_to_cpu(sas_event_data->DeviceInfo);
+- ev->event_type = MPTSAS_DEL_DEVICE;
+- schedule_work(&ev->work);
+- kfree(target_reset_list);
++ out:
++ if (buffer)
++ pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
++ dma_handle);
++}
+
+- /*
+- * issue target reset to next device in the queue
+- */
++/**
++ * mptsas_add_device_component_starget -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @starget:
++ *
++ **/
++static void
++mptsas_add_device_component_starget(MPT_ADAPTER *ioc, struct scsi_target *starget)
++{
++ VirtTarget *vtarget;
++ struct sas_rphy *rphy;
++ struct mptsas_phyinfo *phy_info = NULL;
++ struct mptsas_enclosure enclosure_info;
+
+- head = &hd->target_reset_list;
+- if (list_empty(head))
++ rphy = dev_to_rphy(starget->dev.parent);
++ vtarget = starget->hostdata;
++ phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
++ rphy->identify.sas_address);
++ if (!phy_info)
+ return;
+
+- target_reset_list = list_entry(head->next, struct mptsas_target_reset_event,
+- list);
+-
+- sas_event_data = &target_reset_list->sas_event_data;
+- id = sas_event_data->TargetID;
+- channel = sas_event_data->Bus;
+-
+- if (mptsas_target_reset(ioc, channel, id)) {
+- target_reset_list->target_reset_issued = 1;
+- hd->resetPending = 1;
+- }
++ memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
++ mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
++ (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
++ MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
++ phy_info->attached.handle_enclosure);
++
++ mptsas_add_device_component(ioc, phy_info->attached.channel,
++ phy_info->attached.id, phy_info->attached.sas_address,
++ phy_info->attached.device_info,
++ phy_info->attached.slot, enclosure_info.enclosure_logical_id);
+ }
+
+ /**
+- * mptsas_taskmgmt_complete
+- *
+- * @ioc
+- * @mf
+- * @mr
++ * mptsas_del_device_component_by_os - Once a device has been removed, we
++ * mark the entry in the list as being cached
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel: os mapped id's
++ * @id:
+ *
+ **/
+-static int
+-mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
++static void
++mptsas_del_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
+ {
+- mptsas_dev_reset_complete(ioc);
+- return mptscsih_taskmgmt_complete(ioc, mf, mr);
++ struct sas_device_info *sas_info, *next;
++
++ /*
++ * Set is_cached flag
++ */
++ list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
++ list) {
++ if (sas_info->os.channel == channel && sas_info->os.id == id)
++ sas_info->is_cached = 1;
++ }
+ }
+
+ /**
+- * mptscsih_ioc_reset
+- *
+- * @ioc
+- * @reset_phase
++ * mptsas_del_device_components - Cleaning the list
++ * @ioc: Pointer to MPT_ADAPTER structure
+ *
+ **/
+-static int
+-mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
++static void
++mptsas_del_device_components(MPT_ADAPTER *ioc)
+ {
+- MPT_SCSI_HOST *hd;
+- struct mptsas_target_reset_event *target_reset_list, *n;
+- int rc;
+-
+- rc = mptscsih_ioc_reset(ioc, reset_phase);
+-
+- if (ioc->bus_type != SAS)
+- goto out;
+-
+- if (reset_phase != MPT_IOC_POST_RESET)
+- goto out;
++ struct sas_device_info *sas_info, *next;
+
+- if (!ioc->sh || !ioc->sh->hostdata)
+- goto out;
+- hd = shost_priv(ioc->sh);
+- if (!hd->ioc)
+- goto out;
+-
+- if (list_empty(&hd->target_reset_list))
+- goto out;
+-
+- /* flush the target_reset_list */
+- list_for_each_entry_safe(target_reset_list, n,
+- &hd->target_reset_list, list) {
+- list_del(&target_reset_list->list);
+- kfree(target_reset_list);
++ down(&ioc->sas_device_info_mutex);
++ list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
++ list) {
++ list_del(&sas_info->list);
++ kfree(sas_info);
+ }
+-
+- out:
+- return rc;
++ up(&ioc->sas_device_info_mutex);
+ }
+
+-static int
+-mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
+- u32 form, u32 form_specific)
++/**
++ * mptsas_setup_wide_ports - Updates for new and existing narrow/wide port
++ * configuration
++ * in the sas_topology
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @port_info:
++ *
++ */
++static void
++mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
+ {
+- ConfigExtendedPageHeader_t hdr;
+- CONFIGPARMS cfg;
+- SasEnclosurePage0_t *buffer;
+- dma_addr_t dma_handle;
+- int error;
+- __le64 le_identifier;
+-
+- memset(&hdr, 0, sizeof(hdr));
+- hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
+- hdr.PageNumber = 0;
+- hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
+- hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
++ struct mptsas_portinfo_details * port_details;
++ struct mptsas_phyinfo *phy_info, *phy_info_cmp;
++ u64 sas_address;
++ int i, j;
+
+- cfg.cfghdr.ehdr = &hdr;
+- cfg.physAddr = -1;
+- cfg.pageAddr = form + form_specific;
+- cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+- cfg.dir = 0; /* read */
+- cfg.timeout = 10;
++ mutex_lock(&ioc->sas_topology_mutex);
+
+- error = mpt_config(ioc, &cfg);
+- if (error)
+- goto out;
+- if (!hdr.ExtPageLength) {
+- error = -ENXIO;
+- goto out;
+- }
++ phy_info = port_info->phy_info;
++ for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
++ if (phy_info->attached.handle)
++ continue;
++ port_details = phy_info->port_details;
++ if (!port_details)
++ continue;
++ if (port_details->num_phys < 2)
++ continue;
+
+- buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
+- &dma_handle);
+- if (!buffer) {
+- error = -ENOMEM;
+- goto out;
++ /*
++ * Removing a phy from a port, letting the last
++ * phy be removed by firmware events.
++ */
++ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: [%p]: deleting phy = %d\n",
++ ioc->name, __FUNCTION__, port_details, i));
++ port_details->num_phys--;
++ port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
++ memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
++ devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
++ MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
++ phy_info->phy_id, phy_info->phy));
++ sas_port_delete_phy(port_details->port, phy_info->phy);
++ phy_info->port_details = NULL;
+ }
+
+- cfg.physAddr = dma_handle;
+- cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+-
+- error = mpt_config(ioc, &cfg);
+- if (error)
+- goto out_free_consistent;
+-
+- /* save config data */
+- memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
+- enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
+- enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
+- enclosure->flags = le16_to_cpu(buffer->Flags);
+- enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
+- enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
+- enclosure->start_id = buffer->StartTargetID;
+- enclosure->start_channel = buffer->StartBus;
+- enclosure->sep_id = buffer->SEPTargetID;
+- enclosure->sep_channel = buffer->SEPBus;
++ /*
++ * Populate and refresh the tree
++ */
++ phy_info = port_info->phy_info;
++ for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
++ sas_address = phy_info->attached.sas_address;
++ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
++ ioc->name, i, (unsigned long long)sas_address));
++ if (!sas_address)
++ continue;
++ port_details = phy_info->port_details;
++ /*
++ * Forming a port
++ */
++ if (!port_details) {
++ port_details = kzalloc(sizeof(struct mptsas_portinfo_details),
++ GFP_KERNEL);
++ if (!port_details)
++ goto out;
++ port_details->num_phys = 1;
++ port_details->port_info = port_info;
++ if (phy_info->phy_id < 64 )
++ port_details->phy_bitmask |=
++ (1 << phy_info->phy_id);
++ phy_info->sas_port_add_phy=1;
++ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
++ "phy_id=%d sas_address=0x%018llX\n", ioc->name, i,
++ (unsigned long long) sas_address));
++ phy_info->port_details = port_details;
++ }
++
++ if (i == port_info->num_phys - 1)
++ continue;
++ phy_info_cmp = &port_info->phy_info[i + 1];
++ for (j = i + 1 ; j < port_info->num_phys ; j++,
++ phy_info_cmp++) {
++ if (!phy_info_cmp->attached.sas_address)
++ continue;
++ if (sas_address != phy_info_cmp->attached.sas_address)
++ continue;
++ if (phy_info_cmp->port_details == port_details )
++ continue;
++ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "\t\tphy_id=%d sas_address=0x%018llX\n",
++ ioc->name, j, (unsigned long long)
++ phy_info_cmp->attached.sas_address));
++ if (phy_info_cmp->port_details) {
++ port_details->rphy =
++ mptsas_get_rphy(phy_info_cmp);
++ port_details->port =
++ mptsas_get_port(phy_info_cmp);
++ port_details->starget =
++ mptsas_get_starget(phy_info_cmp);
++ port_details->num_phys =
++ phy_info_cmp->port_details->num_phys;
++ if (!phy_info_cmp->port_details->num_phys)
++ kfree(phy_info_cmp->port_details);
++ } else
++ phy_info_cmp->sas_port_add_phy=1;
++ /*
++ * Adding a phy to a port
++ */
++ phy_info_cmp->port_details = port_details;
++ if (phy_info_cmp->phy_id < 64 )
++ port_details->phy_bitmask |=
++ (1 << phy_info_cmp->phy_id);
++ port_details->num_phys++;
++ }
++ }
+
+- out_free_consistent:
+- pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
+- buffer, dma_handle);
+ out:
+- return error;
++
++ for (i = 0; i < port_info->num_phys; i++) {
++ port_details = port_info->phy_info[i].port_details;
++ if (!port_details)
++ continue;
++ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: [%p]: phy_id=%02d num_phys=%02d "
++ "bitmask=0x%016llX\n", ioc->name, __FUNCTION__,
++ port_details, i, port_details->num_phys,
++ (unsigned long long)port_details->phy_bitmask));
++ dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
++ ioc->name, port_details->port, port_details->rphy));
++ }
++ dsaswideprintk(ioc, printk("\n"));
++ mutex_unlock(&ioc->sas_topology_mutex);
+ }
+
+-static int
+-mptsas_slave_configure(struct scsi_device *sdev)
++/**
++ * mptsas_find_vtarget - obtain vtarget object for non-raid devices
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel:
++ * @id:
++ *
++ **/
++static VirtTarget *
++mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
++{
++ struct scsi_device *sdev;
++ VirtDevice *vdevice;
++ VirtTarget *vtarget = NULL;
++
++ shost_for_each_device(sdev, ioc->sh) {
++ if ((vdevice = sdev->hostdata) == NULL ||
++ (vdevice->vtarget == NULL))
++ continue;
++ if ((vdevice->vtarget->tflags &
++ MPT_TARGET_FLAGS_RAID_COMPONENT ||
++ vdevice->vtarget->raidVolume))
++ continue;
++ if (vdevice->vtarget->id == id &&
++ vdevice->vtarget->channel == channel)
++ vtarget = vdevice->vtarget;
++ }
++ return vtarget;
++}
++
++static void
++mptsas_queue_device_delete(MPT_ADAPTER *ioc,
++ MpiEventDataSasDeviceStatusChange_t *sas_event_data)
+ {
++ struct fw_event_work *fw_event;
++ int sz;
+
+- if (sdev->channel == MPTSAS_RAID_CHANNEL)
+- goto out;
++ sz = offsetof(struct fw_event_work, event_data) +
++ sizeof(MpiEventDataSasDeviceStatusChange_t);
++ fw_event = kzalloc(sz, GFP_ATOMIC);
++ if (!fw_event) {
++ printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
++ ioc->name, __FUNCTION__, __LINE__);
++ return;
++ }
++ memcpy(fw_event->event_data, sas_event_data,
++ sizeof(MpiEventDataSasDeviceStatusChange_t));
++ fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE;
++ fw_event->ioc = ioc;
++ mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
++}
+
+- sas_read_port_mode_page(sdev);
++static void
++mptsas_queue_rescan(MPT_ADAPTER *ioc)
++{
++ struct fw_event_work *fw_event;
++ int sz;
+
+- out:
+- return mptscsih_slave_configure(sdev);
++ sz = offsetof(struct fw_event_work, event_data);
++ fw_event = kzalloc(sz, GFP_ATOMIC);
++ if (!fw_event) {
++ printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
++ ioc->name, __FUNCTION__, __LINE__);
++ return;
++ }
++ fw_event->event = -1;
++ fw_event->ioc = ioc;
++ mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
+ }
+
++
++/**
++ * mptsas_target_reset - Issues TARGET_RESET to end device using
++ * handshaking method
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel:
++ * @id:
++ *
++ * Returns (1) success
++ * (0) failure
++ *
++ **/
+ static int
+-mptsas_target_alloc(struct scsi_target *starget)
++mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
+ {
+- struct Scsi_Host *host = dev_to_shost(&starget->dev);
+- MPT_SCSI_HOST *hd = shost_priv(host);
+- VirtTarget *vtarget;
+- u8 id, channel;
+- struct sas_rphy *rphy;
+- struct mptsas_portinfo *p;
+- int i;
+- MPT_ADAPTER *ioc = hd->ioc;
++ MPT_FRAME_HDR *mf;
++ SCSITaskMgmt_t *pScsiTm;
+
+- vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
+- if (!vtarget)
+- return -ENOMEM;
++ if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0)
++ return 0;
+
+- vtarget->starget = starget;
+- vtarget->ioc_id = ioc->id;
+- vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
+- id = starget->id;
+- channel = 0;
++ if ((mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc)) == NULL) {
++ dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n",
++ ioc->name,__FUNCTION__, __LINE__));
++ goto out_fail;
++ }
+
+- /*
+- * RAID volumes placed beyond the last expected port.
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
++ ioc->name, mf));
++
++ /* Format the Request
+ */
+- if (starget->channel == MPTSAS_RAID_CHANNEL) {
+- for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
+- if (id == ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID)
+- channel = ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus;
+- goto out;
+- }
++ pScsiTm = (SCSITaskMgmt_t *) mf;
++ memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
++ pScsiTm->TargetID = id;
++ pScsiTm->Bus = channel;
++ pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
++ pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
++ pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
+
+- rphy = dev_to_rphy(starget->dev.parent);
+- mutex_lock(&ioc->sas_topology_mutex);
+- list_for_each_entry(p, &ioc->sas_topology, list) {
+- for (i = 0; i < p->num_phys; i++) {
+- if (p->phy_info[i].attached.sas_address !=
+- rphy->identify.sas_address)
+- continue;
+- id = p->phy_info[i].attached.id;
+- channel = p->phy_info[i].attached.channel;
+- mptsas_set_starget(&p->phy_info[i], starget);
++ DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
+
+- /*
+- * Exposing hidden raid components
+- */
+- if (mptscsih_is_phys_disk(ioc, channel, id)) {
+- id = mptscsih_raid_id_to_num(ioc,
+- channel, id);
+- vtarget->tflags |=
+- MPT_TARGET_FLAGS_RAID_COMPONENT;
+- p->phy_info[i].attached.phys_disk_num = id;
+- }
+- mutex_unlock(&ioc->sas_topology_mutex);
+- goto out;
+- }
+- }
+- mutex_unlock(&ioc->sas_topology_mutex);
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n",
++ ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id));
+
+- kfree(vtarget);
+- return -ENXIO;
++ mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
+
+- out:
+- vtarget->id = id;
+- vtarget->channel = channel;
+- starget->hostdata = vtarget;
++ return 1;
++
++ out_fail:
++
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
+ return 0;
+ }
+-
++/**
++ * mptsas_target_reset_queue -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @sas_event_data:
++ *
++ * Receive request for TARGET_RESET after
++ * recieving an firmware event NOT_RESPONDING_EVENT, then put command in
++ * link list and queue if task_queue already in use.
++ **/
+ static void
+-mptsas_target_destroy(struct scsi_target *starget)
++mptsas_target_reset_queue(MPT_ADAPTER *ioc,
++ EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
+ {
+- struct Scsi_Host *host = dev_to_shost(&starget->dev);
+- MPT_SCSI_HOST *hd = shost_priv(host);
+- struct sas_rphy *rphy;
+- struct mptsas_portinfo *p;
+- int i;
+- MPT_ADAPTER *ioc = hd->ioc;
++ MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
++ VirtTarget *vtarget = NULL;
++ struct mptsas_target_reset_event *target_reset_list;
++ u8 id, channel;
+
+- if (!starget->hostdata)
+- return;
++ id = sas_event_data->TargetID;
++ channel = sas_event_data->Bus;
+
+- if (starget->channel == MPTSAS_RAID_CHANNEL)
+- goto out;
++ if ((vtarget = mptsas_find_vtarget(ioc, channel, id))) {
++ if (!ioc->disable_hotplug_remove)
++ vtarget->deleted = 1; /* block IO */
++ }
+
+- rphy = dev_to_rphy(starget->dev.parent);
+- list_for_each_entry(p, &ioc->sas_topology, list) {
+- for (i = 0; i < p->num_phys; i++) {
+- if (p->phy_info[i].attached.sas_address !=
+- rphy->identify.sas_address)
+- continue;
+- mptsas_set_starget(&p->phy_info[i], NULL);
+- goto out;
+- }
++ target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
++ GFP_ATOMIC);
++ if (!target_reset_list) {
++ dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
++ ioc->name,__FUNCTION__, __LINE__));
++ return;
+ }
+
+- out:
+- kfree(starget->hostdata);
+- starget->hostdata = NULL;
+-}
++ memcpy(&target_reset_list->sas_event_data, sas_event_data,
++ sizeof(*sas_event_data));
++ list_add_tail(&target_reset_list->list, &hd->target_reset_list);
++
++ target_reset_list->time_count = jiffies;
+
++ if (mptsas_target_reset(ioc, channel, id))
++ target_reset_list->target_reset_issued = 1;
++}
+
++/**
++ * mptsas_taskmgmt_complete - Completion for TARGET_RESET after
++ * NOT_RESPONDING_EVENT, enable work queue to finish off removing device
++ * from upper layers. then send next TARGET_RESET in the queue.
++ * @ioc: Pointer to MPT_ADAPTER structure
++ *
++ **/
+ static int
+-mptsas_slave_alloc(struct scsi_device *sdev)
++mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
+ {
+- struct Scsi_Host *host = sdev->host;
+- MPT_SCSI_HOST *hd = shost_priv(host);
+- struct sas_rphy *rphy;
+- struct mptsas_portinfo *p;
+- VirtDevice *vdevice;
+- struct scsi_target *starget;
+- int i;
+- MPT_ADAPTER *ioc = hd->ioc;
++ MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
++ struct list_head *head = &hd->target_reset_list;
++ struct mptsas_target_reset_event *target_reset_list;
++ u8 id, channel;
++ SCSITaskMgmtReply_t *pScsiTmReply;
+
+- vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
+- if (!vdevice) {
+- printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
+- ioc->name, sizeof(VirtDevice));
+- return -ENOMEM;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: "
++ "(mf = %p, mr = %p)\n", ioc->name, mf, mr));
++
++ pScsiTmReply = (SCSITaskMgmtReply_t *)mr;
++ if (pScsiTmReply) {
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n"
++ "\ttask_type = 0x%02X, iocstatus = 0x%04X "
++ "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, "
++ "term_cmnds = %d\n", ioc->name,
++ pScsiTmReply->Bus, pScsiTmReply->TargetID,
++ pScsiTmReply->TaskType,
++ le16_to_cpu(pScsiTmReply->IOCStatus),
++ le32_to_cpu(pScsiTmReply->IOCLogInfo),
++ pScsiTmReply->ResponseCode,
++ le32_to_cpu(pScsiTmReply->TerminationCount)));
++
++ if (pScsiTmReply->ResponseCode)
++ mptscsih_taskmgmt_response_code(ioc,
++ pScsiTmReply->ResponseCode);
++ }
++
++ if (pScsiTmReply && (pScsiTmReply->TaskType ==
++ MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType ==
++ MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET)) {
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
++ memcpy(ioc->taskmgmt_cmds.reply, mr,
++ min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
++ if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
++ complete(&ioc->taskmgmt_cmds.done);
++ return 1;
++ }
++ return 0;
+ }
+- starget = scsi_target(sdev);
+- vdevice->vtarget = starget->hostdata;
+
+- if (sdev->channel == MPTSAS_RAID_CHANNEL)
+- goto out;
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
+
+- rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
+- mutex_lock(&ioc->sas_topology_mutex);
+- list_for_each_entry(p, &ioc->sas_topology, list) {
+- for (i = 0; i < p->num_phys; i++) {
+- if (p->phy_info[i].attached.sas_address !=
+- rphy->identify.sas_address)
+- continue;
+- vdevice->lun = sdev->lun;
+- /*
+- * Exposing hidden raid components
+- */
+- if (mptscsih_is_phys_disk(ioc,
+- p->phy_info[i].attached.channel,
+- p->phy_info[i].attached.id))
+- sdev->no_uld_attach = 1;
+- mutex_unlock(&ioc->sas_topology_mutex);
+- goto out;
+- }
++ if (list_empty(head))
++ return 1;
++
++ target_reset_list = list_entry(head->next,
++ struct mptsas_target_reset_event, list);
++
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt: completed (%d seconds)\n",
++ ioc->name, jiffies_to_msecs(jiffies -
++ target_reset_list->time_count)/1000));
++
++ id = pScsiTmReply->TargetID;
++ channel = pScsiTmReply->Bus;
++ target_reset_list->time_count = jiffies;
++
++ /*
++ * retry target reset
++ */
++ if (!target_reset_list->target_reset_issued) {
++ if (mptsas_target_reset(ioc, channel, id))
++ target_reset_list->target_reset_issued = 1;
++ return 1;
+ }
+- mutex_unlock(&ioc->sas_topology_mutex);
+
+- kfree(vdevice);
+- return -ENXIO;
++ /*
++ * enable work queue to remove device from upper layers
++ */
++ list_del(&target_reset_list->list);
++ if ((mptsas_find_vtarget(ioc, channel, id)) && !ioc->fw_events_off)
++ mptsas_queue_device_delete(ioc, &target_reset_list->sas_event_data);
+
+- out:
+- vdevice->vtarget->num_luns++;
+- sdev->hostdata = vdevice;
+- return 0;
++
++ /*
++ * issue target reset to next device in the queue
++ */
++
++ head = &hd->target_reset_list;
++ if (list_empty(head))
++ return 1;
++
++ target_reset_list = list_entry(head->next, struct mptsas_target_reset_event,
++ list);
++
++ id = target_reset_list->sas_event_data.TargetID;
++ channel = target_reset_list->sas_event_data.Bus;
++ target_reset_list->time_count = jiffies;
++
++ if (mptsas_target_reset(ioc, channel, id))
++ target_reset_list->target_reset_issued = 1;
++
++ return 1;
+ }
+
++/**
++ * mptsas_ioc_reset -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @reset_phase:
++ *
++ **/
+ static int
+-mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
++mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
+ {
+- VirtDevice *vdevice = SCpnt->device->hostdata;
+-
+- if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
+- SCpnt->result = DID_NO_CONNECT << 16;
+- done(SCpnt);
+- return 0;
+- }
++ MPT_SCSI_HOST *hd;
++ int rc;
+
+-// scsi_print_command(SCpnt);
++ rc = mptscsih_ioc_reset(ioc, reset_phase);
++ if ((ioc->bus_type != SAS) || (!rc))
++ return rc;
+
+- return mptscsih_qcmd(SCpnt,done);
+-}
++ hd = shost_priv(ioc->sh);
++ if (!hd->ioc)
++ goto out;
+
++ switch(reset_phase) {
++ case MPT_IOC_SETUP_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
++ mptsas_fw_event_off(ioc);
++ break;
++ case MPT_IOC_PRE_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
++ break;
++ case MPT_IOC_POST_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
++ if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET;
++ complete(&ioc->sas_mgmt.done);
++ }
++ mptsas_cleanup_fw_event_q(ioc);
++ mptsas_queue_rescan(ioc);
++ mptsas_fw_event_on(ioc);
++ break;
++ default:
++ break;
++ }
+
+-static struct scsi_host_template mptsas_driver_template = {
+- .module = THIS_MODULE,
+- .proc_name = "mptsas",
+- .proc_info = mptscsih_proc_info,
+- .name = "MPT SPI Host",
+- .info = mptscsih_info,
+- .queuecommand = mptsas_qcmd,
+- .target_alloc = mptsas_target_alloc,
+- .slave_alloc = mptsas_slave_alloc,
+- .slave_configure = mptsas_slave_configure,
+- .target_destroy = mptsas_target_destroy,
+- .slave_destroy = mptscsih_slave_destroy,
+- .change_queue_depth = mptscsih_change_queue_depth,
+- .eh_abort_handler = mptscsih_abort,
+- .eh_device_reset_handler = mptscsih_dev_reset,
+- .eh_bus_reset_handler = mptscsih_bus_reset,
+- .eh_host_reset_handler = mptscsih_host_reset,
+- .bios_param = mptscsih_bios_param,
+- .can_queue = MPT_FC_CAN_QUEUE,
+- .this_id = -1,
+- .sg_tablesize = MPT_SCSI_SG_DEPTH,
+- .max_sectors = 8192,
+- .cmd_per_lun = 7,
+- .use_clustering = ENABLE_CLUSTERING,
+- .shost_attrs = mptscsih_host_attrs,
+-};
++ out:
++ return rc;
++}
+
+-static int mptsas_get_linkerrors(struct sas_phy *phy)
++/**
++ * mptsas_sas_enclosure_pg0 -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @enclosure:
++ * @form:
++ * @form_specific:
++ *
++ **/
++static int
++mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
++ u32 form, u32 form_specific)
+ {
+- MPT_ADAPTER *ioc = phy_to_ioc(phy);
+ ConfigExtendedPageHeader_t hdr;
+ CONFIGPARMS cfg;
+- SasPhyPage1_t *buffer;
++ SasEnclosurePage0_t *buffer;
+ dma_addr_t dma_handle;
+ int error;
++ __le64 le_identifier;
+
+- /* FIXME: only have link errors on local phys */
+- if (!scsi_is_sas_phy_local(phy))
+- return -EINVAL;
+-
+- hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
+- hdr.ExtPageLength = 0;
+- hdr.PageNumber = 1 /* page number 1*/;
+- hdr.Reserved1 = 0;
+- hdr.Reserved2 = 0;
++ memset(&hdr, 0, sizeof(hdr));
++ hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
++ hdr.PageNumber = 0;
+ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
+- hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
+
+ cfg.cfghdr.ehdr = &hdr;
+ cfg.physAddr = -1;
+- cfg.pageAddr = phy->identify.phy_identifier;
++ cfg.pageAddr = form + form_specific;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+- cfg.dir = 0; /* read */
+- cfg.timeout = 10;
++ cfg.dir = 0; /* read */
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+ error = mpt_config(ioc, &cfg);
+ if (error)
+- return error;
+- if (!hdr.ExtPageLength)
+- return -ENXIO;
++ goto out;
++ if (!hdr.ExtPageLength) {
++ error = -ENXIO;
++ goto out;
++ }
+
+ buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
+- &dma_handle);
+- if (!buffer)
+- return -ENOMEM;
++ &dma_handle);
++ if (!buffer) {
++ error = -ENOMEM;
++ goto out;
++ }
+
+ cfg.physAddr = dma_handle;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+@@ -1095,289 +1427,852 @@ static int mptsas_get_linkerrors(struct
+ if (error)
+ goto out_free_consistent;
+
+- mptsas_print_phy_pg1(ioc, buffer);
+-
+- phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
+- phy->running_disparity_error_count =
+- le32_to_cpu(buffer->RunningDisparityErrorCount);
+- phy->loss_of_dword_sync_count =
+- le32_to_cpu(buffer->LossDwordSynchCount);
+- phy->phy_reset_problem_count =
+- le32_to_cpu(buffer->PhyResetProblemCount);
++ /* save config data */
++ memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
++ enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
++ enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
++ enclosure->flags = le16_to_cpu(buffer->Flags);
++ enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
++ enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
++ enclosure->start_id = buffer->StartTargetID;
++ enclosure->start_channel = buffer->StartBus;
++ enclosure->sep_id = buffer->SEPTargetID;
++ enclosure->sep_channel = buffer->SEPBus;
+
+ out_free_consistent:
+ pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
+ buffer, dma_handle);
++ out:
+ return error;
+ }
+
+-static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
+- MPT_FRAME_HDR *reply)
++/**
++ * mptsas_get_lun_number - returns the first entry in report_luns table
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel:
++ * @id:
++ * @lun:
++ *
++ */
++static int
++mptsas_get_lun_number(MPT_ADAPTER *ioc, u8 channel, u8 id, int *lun)
+ {
+- ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
+- if (reply != NULL) {
+- ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
+- memcpy(ioc->sas_mgmt.reply, reply,
+- min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
+- }
+- complete(&ioc->sas_mgmt.done);
+- return 1;
+-}
++ INTERNAL_CMD *iocmd;
++ struct scsi_lun *lun_data;
++ dma_addr_t lun_data_dma;
++ u32 lun_data_len;
++ u8 *data;
++ MPT_SCSI_HOST *hd;
++ int rc;
++ u32 length, num_luns;
+
+-static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
+-{
+- MPT_ADAPTER *ioc = phy_to_ioc(phy);
+- SasIoUnitControlRequest_t *req;
+- SasIoUnitControlReply_t *reply;
+- MPT_FRAME_HDR *mf;
+- MPIHeader_t *hdr;
+- unsigned long timeleft;
+- int error = -ERESTARTSYS;
++ iocmd = NULL;
++ hd = shost_priv(ioc->sh);
++ lun_data_len = (255 * sizeof(struct scsi_lun));
++ lun_data = pci_alloc_consistent(ioc->pcidev, lun_data_len,
++ &lun_data_dma);
++ if (!lun_data) {
++ printk(MYIOC_s_ERR_FMT "%s: pci_alloc_consistent(%d) FAILED!\n",
++ ioc->name, __FUNCTION__, lun_data_len);
++ rc = -ENOMEM;
++ goto out;
++ }
+
+- /* FIXME: fusion doesn't allow non-local phy reset */
+- if (!scsi_is_sas_phy_local(phy))
+- return -EINVAL;
++ iocmd = kzalloc(sizeof(INTERNAL_CMD), GFP_KERNEL);
++ if (!iocmd) {
++ printk(MYIOC_s_ERR_FMT "%s: kzalloc(%zd) FAILED!\n",
++ ioc->name, __FUNCTION__, sizeof(INTERNAL_CMD));
++ rc = -ENOMEM;
++ goto out;
++ }
+
+- /* not implemented for expanders */
+- if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
+- return -ENXIO;
++ /*
++ * Report Luns
++ */
++ iocmd->cmd = REPORT_LUNS;
++ iocmd->data_dma = lun_data_dma;
++ iocmd->data = (u8 *)lun_data;
++ iocmd->size = lun_data_len;
++ iocmd->channel = channel;
++ iocmd->id = id;
+
+- if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
++ if ((rc = mptscsih_do_cmd(hd, iocmd)) < 0) {
++ printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
++ "report_luns failed due to rc=0x%x\n", ioc->name,
++ __FUNCTION__, channel, id, rc);
+ goto out;
++ }
+
+- mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
+- if (!mf) {
+- error = -ENOMEM;
+- goto out_unlock;
++ if (rc != MPT_SCANDV_GOOD) {
++ printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
++ "report_luns failed due to rc=0x%x\n", ioc->name,
++ __FUNCTION__, channel, id, rc);
++ rc = -rc;
++ goto out;
+ }
+
+- hdr = (MPIHeader_t *) mf;
+- req = (SasIoUnitControlRequest_t *)mf;
+- memset(req, 0, sizeof(SasIoUnitControlRequest_t));
+- req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
+- req->MsgContext = hdr->MsgContext;
+- req->Operation = hard_reset ?
+- MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
+- req->PhyNum = phy->identify.phy_identifier;
++ data = (u8 *)lun_data;
++ length = ((data[0] << 24) | (data[1] << 16) |
++ (data[2] << 8) | (data[3] << 0));
+
+- mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
++ num_luns = (length / sizeof(struct scsi_lun));
++ if (!num_luns)
++ goto out;
++ /* return 1st lun in the list */
++ *lun = scsilun_to_int(&lun_data[1]);
+
+- timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
+- 10 * HZ);
+- if (!timeleft) {
+- /* On timeout reset the board */
+- mpt_free_msg_frame(ioc, mf);
+- mpt_HardResetHandler(ioc, CAN_SLEEP);
+- error = -ETIMEDOUT;
+- goto out_unlock;
++#if 0
++ /* some debugging, left commented out */
++ {
++ struct scsi_lun *lunp;
++ for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++)
++ printk("%x\n", scsilun_to_int(lunp));
+ }
++#endif
+
+- /* a reply frame is expected */
+- if ((ioc->sas_mgmt.status &
+- MPT_IOCTL_STATUS_RF_VALID) == 0) {
+- error = -ENXIO;
+- goto out_unlock;
+- }
++ out:
++ if (lun_data)
++ pci_free_consistent(ioc->pcidev, lun_data_len, lun_data,
++ lun_data_dma);
++ kfree(iocmd);
++ return rc;
++}
+
+- /* process the completed Reply Message Frame */
+- reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
+- if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
+- printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
+- ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
+- error = -ENXIO;
+- goto out_unlock;
++/**
++ * enum device_state -
++ * @DEVICE_RETRY: need to retry the TUR
++ * @DEVICE_ERROR: TUR return error, don't add device
++ * @DEVICE_READY: device can be added
++ *
++ */
++enum device_state{
++ DEVICE_RETRY,
++ DEVICE_ERROR,
++ DEVICE_READY,
++};
++
++/**
++ * mptsas_test_unit_ready -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel:
++ * @id:
++ * @count: retry count
++ *
++ */
++enum device_state
++mptsas_test_unit_ready(MPT_ADAPTER *ioc, u8 channel, u8 id, u16 count)
++{
++ INTERNAL_CMD *iocmd;
++ MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
++ enum device_state state;
++ int rc;
++ u8 skey, asc, ascq;
++ u8 retry_ua;
++
++ if (count >= mpt_cmd_retry_count)
++ return DEVICE_ERROR;
++
++ retry_ua = 0;
++ iocmd = kzalloc(sizeof(INTERNAL_CMD), GFP_KERNEL);
++ if (!iocmd) {
++ printk(MYIOC_s_ERR_FMT "%s: kzalloc(%zd) FAILED!\n",
++ __FUNCTION__, ioc->name, sizeof(INTERNAL_CMD));
++ return DEVICE_ERROR;
++ }
++
++ state = DEVICE_ERROR;
++ iocmd->cmd = TEST_UNIT_READY;
++ iocmd->data_dma = -1;
++ iocmd->data = NULL;
++
++ if (mptscsih_is_phys_disk(ioc, channel, id)) {
++ iocmd->flags |= MPT_ICFLAG_PHYS_DISK;
++ iocmd->physDiskNum = mptscsih_raid_id_to_num(ioc, channel, id);
++ iocmd->id = id;
++ }
++ iocmd->channel = channel;
++ iocmd->id = id;
++
++ retry:
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_channel=%d "
++ "fw_id=%d retry=%d\n", ioc->name, __FUNCTION__, channel, id, count));
++ rc = mptscsih_do_cmd(hd, iocmd);
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rc=0x%02x\n",
++ ioc->name, __FUNCTION__, rc));
++ if (rc < 0) {
++ printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
++ "tur failed due to timeout\n", ioc->name,
++ __FUNCTION__, channel, id);
++ goto tur_done;
++ }
++
++ switch(rc) {
++ case MPT_SCANDV_GOOD:
++ state = DEVICE_READY;
++ goto tur_done;
++ case MPT_SCANDV_BUSY:
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: "
++ "fw_channel=%d fw_id=%d : device busy\n",
++ ioc->name, __FUNCTION__, channel, id));
++ state = DEVICE_RETRY;
++ break;
++ case MPT_SCANDV_DID_RESET:
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: "
++ "fw_channel=%d fw_id=%d : did reset\n",
++ ioc->name, __FUNCTION__, channel, id));
++ state = DEVICE_RETRY;
++ break;
++ case MPT_SCANDV_SENSE:
++ skey = ioc->internal_cmds.sense[2] & 0x0F;
++ asc = ioc->internal_cmds.sense[12];
++ ascq = ioc->internal_cmds.sense[13];
++
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: "
++ "fw_channel=%d fw_id=%d : [sense_key,asc,"
++ "ascq]: [0x%02x,0x%02x,0x%02x]\n", ioc->name,
++ __FUNCTION__, channel, id, skey, asc, ascq));
++
++ if (skey == UNIT_ATTENTION) {
++ if (!retry_ua) {
++ retry_ua++;
++ goto retry;
++ }
++ } else if (skey == NOT_READY) {
++ /*
++ * medium isn't present
++ */
++ if (asc == 0x3a) {
++ state = DEVICE_READY;
++ goto tur_done;
++ }
++ /*
++ * LU becoming ready, or
++ * LU hasn't self-configured yet
++ */
++ if ((asc == 0x04 && ascq == 0x01) ||
++ (asc == 0x04 && ascq == 0x11) ||
++ asc == 0x3e) {
++ state = DEVICE_RETRY;
++ break;
++ }
++ } else if (skey == ILLEGAL_REQUEST) {
++ /* try sending a tur to a non-zero lun number */
++ if (!iocmd->lun && !mptsas_get_lun_number(ioc,
++ channel, id, &iocmd->lun) && iocmd->lun)
++ goto retry;
++ }
++ printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d : "
++ "tur failed due to [sense_key,asc,ascq]: "
++ "[0x%02x,0x%02x,0x%02x]\n", ioc->name,
++ __FUNCTION__, channel, id, skey, asc, ascq);
++ goto tur_done;
++ case MPT_SCANDV_SELECTION_TIMEOUT:
++ printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
++ "tur failed due to no device\n", ioc->name,
++ __FUNCTION__, channel,
++ id);
++ goto tur_done;
++ case MPT_SCANDV_SOME_ERROR:
++ printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
++ "tur failed due to some error\n", ioc->name,
++ __FUNCTION__,
++ channel, id);
++ goto tur_done;
++ default:
++ printk(MYIOC_s_ERR_FMT
++ "%s: fw_channel=%d fw_id=%d: tur failed due to "
++ "unknown rc=0x%02x\n", ioc->name, __FUNCTION__,
++ channel, id, rc );
++ goto tur_done;
++ }
++ tur_done:
++ kfree(iocmd);
++ return state;
++}
++
++/**
++ * mptsas_issue_tlr - Enabling Transport Layer Retries
++ * @hd:
++ * @sdev:
++ *
++ **/
++static void
++mptsas_issue_tlr(MPT_SCSI_HOST *hd, struct scsi_device *sdev)
++{
++ INTERNAL_CMD *iocmd;
++ VirtDevice *vdevice = sdev->hostdata;
++ u8 retries;
++ u8 rc;
++ MPT_ADAPTER *ioc = hd->ioc;
++
++ if ( sdev->inquiry[8] == 'H' &&
++ sdev->inquiry[9] == 'P' &&
++ sdev->inquiry[10] == ' ' &&
++ sdev->inquiry[11] == ' ' &&
++ sdev->inquiry[12] == ' ' &&
++ sdev->inquiry[13] == ' ' &&
++ sdev->inquiry[14] == ' ' &&
++ sdev->inquiry[15] == ' ' ) {
++
++ iocmd = kzalloc(sizeof(INTERNAL_CMD), GFP_KERNEL);
++ if (!iocmd) {
++ printk(MYIOC_s_ERR_FMT "%s: kzalloc(%zd) FAILED!\n",
++ __FUNCTION__, ioc->name, sizeof(INTERNAL_CMD));
++ return;
++ }
++ iocmd->id = vdevice->vtarget->id;
++ iocmd->channel = vdevice->vtarget->channel;
++ iocmd->lun = vdevice->lun;
++ iocmd->physDiskNum = -1;
++ iocmd->cmd = TRANSPORT_LAYER_RETRIES;
++ iocmd->data_dma = -1;
++ for (retries = 0, rc = -1; retries < 3; retries++) {
++ rc = mptscsih_do_cmd(hd, iocmd);
++ if (!rc)
++ break;
++ }
++ if (rc != 0)
++ printk(MYIOC_s_DEBUG_FMT "unable to enable TLR on"
++ " fw_channel %d, fw_id %d, lun=%d\n",
++ ioc->name, vdevice->vtarget->channel,
++ vdevice->vtarget->id, sdev->lun);
++ kfree(iocmd);
+ }
++}
+
+- error = 0;
++/**
++ * mptsas_slave_configure -
++ * @sdev:
++ *
++ **/
++static int
++mptsas_slave_configure(struct scsi_device *sdev)
++{
++ struct Scsi_Host *host = sdev->host;
++ MPT_SCSI_HOST *hd = shost_priv(host);
++ MPT_ADAPTER *ioc = hd->ioc;
++ VirtDevice *vdevice = sdev->hostdata;
++
++
++ if (vdevice->vtarget->deleted) {
++ sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n");
++ vdevice->vtarget->deleted = 0;
++ }
+
+- out_unlock:
+- mutex_unlock(&ioc->sas_mgmt.mutex);
++ /*
++ * RAID volumes placed beyond the last expected port.
++ * Ignore sending sas mode pages in that case..
++ */
++ if (sdev->channel == MPTSAS_RAID_CHANNEL) {
++ mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev));
++ goto out;
++ }
++
++ sas_read_port_mode_page(sdev);
++
++ mptsas_add_device_component_starget(ioc, scsi_target(sdev));
++
++ if (sdev->type == TYPE_TAPE &&
++ (ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_TLR ))
++ mptsas_issue_tlr(hd, sdev);
+ out:
+- return error;
++
++ return mptscsih_slave_configure(sdev);
+ }
+
++/**
++ * mptsas_target_alloc -
++ * @starget:
++ *
++ **/
+ static int
+-mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
++mptsas_target_alloc(struct scsi_target *starget)
+ {
+- MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
+- int i, error;
+- struct mptsas_portinfo *p;
+- struct mptsas_enclosure enclosure_info;
+- u64 enclosure_handle;
++ struct Scsi_Host *host = dev_to_shost(&starget->dev);
++ MPT_SCSI_HOST *hd = shost_priv(host);
++ VirtTarget *vtarget;
++ u8 id, channel;
++ struct sas_rphy *rphy;
++ struct mptsas_portinfo *p;
++ int i;
++ MPT_ADAPTER *ioc = hd->ioc;
++
++ vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
++ if (!vtarget)
++ return -ENOMEM;
++
++ vtarget->starget = starget;
++ vtarget->ioc_id = ioc->id;
++ vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
++ id = starget->id;
++ channel = 0;
++
++ /*
++ * RAID volumes placed beyond the last expected port.
++ */
++ if (starget->channel == MPTSAS_RAID_CHANNEL) {
++ if (!ioc->raid_data.pIocPg2) {
++ kfree(vtarget);
++ return -ENXIO;
++ }
++ for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
++ if (id == ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID)
++ channel = ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus;
++ vtarget->raidVolume = 1;
++ goto out;
++ }
+
++ rphy = dev_to_rphy(starget->dev.parent);
+ mutex_lock(&ioc->sas_topology_mutex);
+ list_for_each_entry(p, &ioc->sas_topology, list) {
+ for (i = 0; i < p->num_phys; i++) {
+- if (p->phy_info[i].attached.sas_address ==
+- rphy->identify.sas_address) {
+- enclosure_handle = p->phy_info[i].
+- attached.handle_enclosure;
+- goto found_info;
++ if (p->phy_info[i].attached.sas_address !=
++ rphy->identify.sas_address)
++ continue;
++ id = p->phy_info[i].attached.id;
++ channel = p->phy_info[i].attached.channel;
++ mptsas_set_starget(&p->phy_info[i], starget);
++
++ starget_printk(KERN_INFO, starget, MYIOC_s_FMT
++ "add device: fw_channel %d, fw_id %d, phy %d, sas_addr 0x%llx\n",
++ ioc->name, p->phy_info[i].attached.channel,
++ p->phy_info[i].attached.id, p->phy_info[i].attached.phy_id,
++ (unsigned long long)p->phy_info[i].attached.sas_address);
++
++ /*
++ * Exposing hidden raid components
++ */
++ if (mptscsih_is_phys_disk(ioc, channel, id)) {
++ id = mptscsih_raid_id_to_num(ioc,
++ channel, id);
++ vtarget->tflags |=
++ MPT_TARGET_FLAGS_RAID_COMPONENT;
++ p->phy_info[i].attached.phys_disk_num = id;
+ }
++ mutex_unlock(&ioc->sas_topology_mutex);
++ goto out;
+ }
+ }
+ mutex_unlock(&ioc->sas_topology_mutex);
++
++ kfree(vtarget);
+ return -ENXIO;
+
+- found_info:
+- mutex_unlock(&ioc->sas_topology_mutex);
+- memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
+- error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
+- (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
+- MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
+- if (!error)
+- *identifier = enclosure_info.enclosure_logical_id;
+- return error;
++ out:
++ vtarget->id = id;
++ vtarget->channel = channel;
++ starget->hostdata = vtarget;
++ return 0;
+ }
+
+-static int
+-mptsas_get_bay_identifier(struct sas_rphy *rphy)
++/**
++ * mptsas_target_destroy -
++ * @starget:
++ *
++ **/
++static void
++mptsas_target_destroy(struct scsi_target *starget)
+ {
+- MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
+- struct mptsas_portinfo *p;
+- int i, rc;
++ struct Scsi_Host *host = dev_to_shost(&starget->dev);
++ MPT_SCSI_HOST *hd = shost_priv(host);
++ struct sas_rphy *rphy;
++ struct mptsas_portinfo *p;
++ int i;
++ MPT_ADAPTER *ioc = hd->ioc;
+
+- mutex_lock(&ioc->sas_topology_mutex);
++ if (!starget->hostdata)
++ return;
++
++ mptsas_del_device_component_by_os(ioc, starget->channel,
++ starget->id);
++
++ if (starget->channel == MPTSAS_RAID_CHANNEL)
++ goto out;
++
++ rphy = dev_to_rphy(starget->dev.parent);
+ list_for_each_entry(p, &ioc->sas_topology, list) {
+ for (i = 0; i < p->num_phys; i++) {
+- if (p->phy_info[i].attached.sas_address ==
+- rphy->identify.sas_address) {
+- rc = p->phy_info[i].attached.slot;
+- goto out;
+- }
++ if (p->phy_info[i].attached.sas_address !=
++ rphy->identify.sas_address)
++ continue;
++
++ starget_printk(KERN_INFO, starget, MYIOC_s_FMT
++ "delete device: fw_channel %d, fw_id %d, phy %d, "
++ "sas_addr 0x%llx\n", ioc->name,
++ p->phy_info[i].attached.channel,
++ p->phy_info[i].attached.id,
++ p->phy_info[i].attached.phy_id, (unsigned long long)
++ p->phy_info[i].attached.sas_address);
++
++ mptsas_port_delete(ioc, p->phy_info[i].port_details);
+ }
+ }
+- rc = -ENXIO;
++
+ out:
+- mutex_unlock(&ioc->sas_topology_mutex);
+- return rc;
++ kfree(starget->hostdata);
++ starget->hostdata = NULL;
+ }
+
+-static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
+- struct request *req)
++/**
++ * mptsas_slave_alloc -
++ * @sdev:
++ *
++ **/
++static int
++mptsas_slave_alloc(struct scsi_device *sdev)
+ {
+- MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
+- MPT_FRAME_HDR *mf;
+- SmpPassthroughRequest_t *smpreq;
+- struct request *rsp = req->next_rq;
+- int ret;
+- int flagsLength;
+- unsigned long timeleft;
+- char *psge;
+- dma_addr_t dma_addr_in = 0;
+- dma_addr_t dma_addr_out = 0;
+- u64 sas_address = 0;
+-
+- if (!rsp) {
+- printk(MYIOC_s_ERR_FMT "%s: the smp response space is missing\n",
+- ioc->name, __func__);
+- return -EINVAL;
+- }
++ struct Scsi_Host *host = sdev->host;
++ MPT_SCSI_HOST *hd = shost_priv(host);
++ struct sas_rphy *rphy;
++ struct mptsas_portinfo *p;
++ VirtDevice *vdevice;
++ struct scsi_target *starget;
++ int i;
++ MPT_ADAPTER *ioc = hd->ioc;
+
+- /* do we need to support multiple segments? */
+- if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
+- printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n",
+- ioc->name, __func__, req->bio->bi_vcnt, req->data_len,
+- rsp->bio->bi_vcnt, rsp->data_len);
+- return -EINVAL;
++ vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
++ if (!vdevice) {
++ printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
++ ioc->name, sizeof(VirtDevice));
++ return -ENOMEM;
+ }
++ starget = scsi_target(sdev);
++ vdevice->vtarget = starget->hostdata;
+
+- ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
+- if (ret)
++ /*
++ * RAID volumes placed beyond the last expected port.
++ */
++ if (sdev->channel == MPTSAS_RAID_CHANNEL)
+ goto out;
+
+- mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
+- if (!mf) {
+- ret = -ENOMEM;
+- goto out_unlock;
++ rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_for_each_entry(p, &ioc->sas_topology, list) {
++ for (i = 0; i < p->num_phys; i++) {
++ if (p->phy_info[i].attached.sas_address !=
++ rphy->identify.sas_address)
++ continue;
++ vdevice->lun = sdev->lun;
++ /*
++ * Exposing hidden raid components
++ */
++ if (mptscsih_is_phys_disk(ioc,
++ p->phy_info[i].attached.channel,
++ p->phy_info[i].attached.id))
++ sdev->no_uld_attach = 1;
++ mutex_unlock(&ioc->sas_topology_mutex);
++ goto out;
++ }
+ }
++ mutex_unlock(&ioc->sas_topology_mutex);
+
+- smpreq = (SmpPassthroughRequest_t *)mf;
+- memset(smpreq, 0, sizeof(*smpreq));
++ kfree(vdevice);
++ return -ENXIO;
+
+- smpreq->RequestDataLength = cpu_to_le16(req->data_len - 4);
+- smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
++ out:
++ vdevice->vtarget->num_luns++;
++ sdev->hostdata = vdevice;
++ return 0;
++}
+
+- if (rphy)
+- sas_address = rphy->identify.sas_address;
+- else {
+- struct mptsas_portinfo *port_info;
++/**
++ * mptsas_qcmd -
++ * @SCpnt:
++ * @done:
++ *
++ **/
++static int
++mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
++{
++ MPT_SCSI_HOST *hd;
++ MPT_ADAPTER *ioc;
++ VirtDevice *vdevice = SCpnt->device->hostdata;
+
+- mutex_lock(&ioc->sas_topology_mutex);
+- port_info = mptsas_get_hba_portinfo(ioc);
+- if (port_info && port_info->phy_info)
+- sas_address =
+- port_info->phy_info[0].phy->identify.sas_address;
+- mutex_unlock(&ioc->sas_topology_mutex);
++ if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
++ SCpnt->result = DID_NO_CONNECT << 16;
++ done(SCpnt);
++ return 0;
+ }
+
+- *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
++ hd = shost_priv(SCpnt->device->host);
++ ioc = hd->ioc;
+
+- psge = (char *)
+- (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
++ if (ioc->sas_discovery_quiesce_io)
++ return SCSI_MLQUEUE_HOST_BUSY;
+
+- /* request */
+- flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+- MPI_SGE_FLAGS_END_OF_BUFFER |
+- MPI_SGE_FLAGS_DIRECTION |
+- mpt_addr_size()) << MPI_SGE_FLAGS_SHIFT;
+- flagsLength |= (req->data_len - 4);
+-
+- dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
+- req->data_len, PCI_DMA_BIDIRECTIONAL);
+- if (!dma_addr_out)
+- goto put_mf;
+- mpt_add_sge(psge, flagsLength, dma_addr_out);
+- psge += (sizeof(u32) + sizeof(dma_addr_t));
+-
+- /* response */
+- flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
+- flagsLength |= rsp->data_len + 4;
+- dma_addr_in = pci_map_single(ioc->pcidev, bio_data(rsp->bio),
+- rsp->data_len, PCI_DMA_BIDIRECTIONAL);
+- if (!dma_addr_in)
+- goto unmap;
+- mpt_add_sge(psge, flagsLength, dma_addr_in);
++// scsi_print_command(SCpnt);
++ return mptscsih_qcmd(SCpnt,done);
++}
+
+- mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
+
+- timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
+- if (!timeleft) {
+- printk(MYIOC_s_ERR_FMT "%s: smp timeout!\n", ioc->name, __func__);
+- /* On timeout reset the board */
+- mpt_HardResetHandler(ioc, CAN_SLEEP);
+- ret = -ETIMEDOUT;
+- goto unmap;
+- }
+- mf = NULL;
+-
+- if (ioc->sas_mgmt.status & MPT_IOCTL_STATUS_RF_VALID) {
+- SmpPassthroughReply_t *smprep;
+-
+- smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
+- memcpy(req->sense, smprep, sizeof(*smprep));
+- req->sense_len = sizeof(*smprep);
+- req->data_len = 0;
+- rsp->data_len -= smprep->ResponseDataLength;
+- } else {
+- printk(MYIOC_s_ERR_FMT "%s: smp passthru reply failed to be returned\n",
+- ioc->name, __func__);
+- ret = -ENXIO;
+- }
+-unmap:
+- if (dma_addr_out)
+- pci_unmap_single(ioc->pcidev, dma_addr_out, req->data_len,
+- PCI_DMA_BIDIRECTIONAL);
+- if (dma_addr_in)
+- pci_unmap_single(ioc->pcidev, dma_addr_in, rsp->data_len,
+- PCI_DMA_BIDIRECTIONAL);
+-put_mf:
+- if (mf)
++static struct scsi_host_template mptsas_driver_template = {
++ .module = THIS_MODULE,
++ .proc_name = "mptsas",
++ .proc_info = mptscsih_proc_info,
++ .name = "MPT SPI Host",
++ .info = mptscsih_info,
++ .queuecommand = mptsas_qcmd,
++ .target_alloc = mptsas_target_alloc,
++ .slave_alloc = mptsas_slave_alloc,
++ .slave_configure = mptsas_slave_configure,
++ .target_destroy = mptsas_target_destroy,
++ .slave_destroy = mptscsih_slave_destroy,
++ .change_queue_depth = mptscsih_change_queue_depth,
++ .eh_abort_handler = mptscsih_abort,
++ .eh_device_reset_handler = mptscsih_dev_reset,
++ .eh_bus_reset_handler = mptscsih_bus_reset,
++ .eh_host_reset_handler = mptscsih_host_reset,
++ .bios_param = mptscsih_bios_param,
++ .can_queue = MPT_FC_CAN_QUEUE,
++ .this_id = -1,
++ .sg_tablesize = MPT_SCSI_SG_DEPTH,
++ .max_sectors = 8192,
++ .cmd_per_lun = 7,
++ .use_clustering = ENABLE_CLUSTERING,
++ .shost_attrs = mptscsih_host_attrs,
++};
++
++/**
++ * mptsas_get_linkerrors -
++ * @phy:
++ *
++ **/
++static int mptsas_get_linkerrors(struct sas_phy *phy)
++{
++ MPT_ADAPTER *ioc = phy_to_ioc(phy);
++ ConfigExtendedPageHeader_t hdr;
++ CONFIGPARMS cfg;
++ SasPhyPage1_t *buffer;
++ dma_addr_t dma_handle;
++ int error;
++
++ /* FIXME: only have link errors on local phys */
++ if (!scsi_is_sas_phy_local(phy))
++ return -EINVAL;
++
++ hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
++ hdr.ExtPageLength = 0;
++ hdr.PageNumber = 1 /* page number 1*/;
++ hdr.Reserved1 = 0;
++ hdr.Reserved2 = 0;
++ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
++ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
++
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = phy->identify.phy_identifier;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
++
++ error = mpt_config(ioc, &cfg);
++ if (error)
++ return error;
++ if (!hdr.ExtPageLength)
++ return -ENXIO;
++
++ buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
++ &dma_handle);
++ if (!buffer)
++ return -ENOMEM;
++
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ error = mpt_config(ioc, &cfg);
++ if (error)
++ goto out_free_consistent;
++
++ mptsas_print_phy_pg1(ioc, buffer);
++
++ phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
++ phy->running_disparity_error_count =
++ le32_to_cpu(buffer->RunningDisparityErrorCount);
++ phy->loss_of_dword_sync_count =
++ le32_to_cpu(buffer->LossDwordSynchCount);
++ phy->phy_reset_problem_count =
++ le32_to_cpu(buffer->PhyResetProblemCount);
++
++ out_free_consistent:
++ pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
++ buffer, dma_handle);
++ return error;
++}
++
++/**
++ * mptsas_mgmt_done -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @req:
++ * @reply:
++ *
++ **/
++static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
++ MPT_FRAME_HDR *reply)
++{
++ ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
++ if (reply != NULL) {
++ ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID;
++ memcpy(ioc->sas_mgmt.reply, reply,
++ min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
++ }
++
++ if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING;
++ complete(&ioc->sas_mgmt.done);
++ return 1;
++ }
++ return 0;
++}
++
++/**
++ * mptsas_phy_reset -
++ * @phy:
++ * @hard_reset:
++ *
++ **/
++static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
++{
++ MPT_ADAPTER *ioc = phy_to_ioc(phy);
++ SasIoUnitControlRequest_t *req;
++ SasIoUnitControlReply_t *reply;
++ MPT_FRAME_HDR *mf;
++ MPIHeader_t *hdr;
++ unsigned long timeleft;
++ int error = -ERESTARTSYS;
++
++ /* FIXME: fusion doesn't allow non-local phy reset */
++ if (!scsi_is_sas_phy_local(phy))
++ return -EINVAL;
++
++ /* not implemented for expanders */
++ if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
++ return -ENXIO;
++
++ if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
++ goto out;
++
++ mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
++ if (!mf) {
++ error = -ENOMEM;
++ goto out_unlock;
++ }
++
++ hdr = (MPIHeader_t *) mf;
++ req = (SasIoUnitControlRequest_t *)mf;
++ memset(req, 0, sizeof(SasIoUnitControlRequest_t));
++ req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
++ req->MsgContext = hdr->MsgContext;
++ req->Operation = hard_reset ?
++ MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
++ req->PhyNum = phy->identify.phy_identifier;
++
++ INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
++ mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
++ timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10*HZ);
++ if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ error = -ETIME;
+ mpt_free_msg_frame(ioc, mf);
+-out_unlock:
++ if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
++ goto out;
++ if (!timeleft) {
++ if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
++ mpt_HardResetHandler(ioc, CAN_SLEEP);
++ }
++ goto out_unlock;
++ }
++
++ /* a reply frame is expected */
++ if ((ioc->sas_mgmt.status &
++ MPT_MGMT_STATUS_RF_VALID) == 0) {
++ error = -ENXIO;
++ goto out_unlock;
++ }
++
++ /* process the completed Reply Message Frame */
++ reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
++ if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
++ printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
++ ioc->name, __FUNCTION__, reply->IOCStatus, reply->IOCLogInfo);
++ error = -ENXIO;
++ goto out_unlock;
++ }
++
++ error = 0;
++
++ out_unlock:
++ CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
+ mutex_unlock(&ioc->sas_mgmt.mutex);
+-out:
+- return ret;
++ out:
++ return error;
++}
++
++/**
++ * mptsas_get_enclosure_identifier -
++ * @rphy:
++ * @identifier:
++ *
++ **/
++static int
++mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
++{
++ MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
++ int i, error;
++ struct mptsas_portinfo *p;
++ struct mptsas_enclosure enclosure_info;
++ u64 enclosure_handle;
++
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_for_each_entry(p, &ioc->sas_topology, list) {
++ for (i = 0; i < p->num_phys; i++) {
++ if (p->phy_info[i].attached.sas_address ==
++ rphy->identify.sas_address) {
++ enclosure_handle = p->phy_info[i].
++ attached.handle_enclosure;
++ goto found_info;
++ }
++ }
++ }
++ mutex_unlock(&ioc->sas_topology_mutex);
++ return -ENXIO;
++
++ found_info:
++ mutex_unlock(&ioc->sas_topology_mutex);
++ memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
++ error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
++ (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
++ MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
++ enclosure_handle);
++ if (!error)
++ *identifier = enclosure_info.enclosure_logical_id;
++ return error;
++}
++
++/**
++ * mptsas_get_bay_identifier -
++ * @rphy:
++ *
++ **/
++static int
++mptsas_get_bay_identifier(struct sas_rphy *rphy)
++{
++ MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
++ struct mptsas_portinfo *p;
++ int i, rc;
++
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_for_each_entry(p, &ioc->sas_topology, list) {
++ for (i = 0; i < p->num_phys; i++) {
++ if (p->phy_info[i].attached.sas_address ==
++ rphy->identify.sas_address) {
++ rc = p->phy_info[i].attached.slot;
++ goto out;
++ }
++ }
++ }
++ rc = -ENXIO;
++ out:
++ mutex_unlock(&ioc->sas_topology_mutex);
++ return rc;
+ }
+
+ static struct sas_function_template mptsas_transport_functions = {
+@@ -1385,11 +2280,16 @@ static struct sas_function_template mpts
+ .get_enclosure_identifier = mptsas_get_enclosure_identifier,
+ .get_bay_identifier = mptsas_get_bay_identifier,
+ .phy_reset = mptsas_phy_reset,
+- .smp_handler = mptsas_smp_handler,
+ };
+
+ static struct scsi_transport_template *mptsas_transport_template;
+
++/**
++ * mptsas_sas_io_unit_pg0 -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @port_info:
++ *
++ **/
+ static int
+ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
+ {
+@@ -1412,7 +2312,7 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
+ cfg.pageAddr = 0;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+ cfg.dir = 0; /* read */
+- cfg.timeout = 10;
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+ error = mpt_config(ioc, &cfg);
+ if (error)
+@@ -1438,7 +2338,7 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
+
+ port_info->num_phys = buffer->NumPhys;
+ port_info->phy_info = kcalloc(port_info->num_phys,
+- sizeof(*port_info->phy_info),GFP_KERNEL);
++ sizeof(struct mptsas_phyinfo),GFP_KERNEL);
+ if (!port_info->phy_info) {
+ error = -ENOMEM;
+ goto out_free_consistent;
+@@ -1459,6 +2359,8 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
+ port_info->phy_info[i].portinfo = port_info;
+ port_info->phy_info[i].handle =
+ le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
++ port_info->phy_info[i].port_flags =
++ buffer->PhyData[i].PortFlags;
+ }
+
+ out_free_consistent:
+@@ -1468,6 +2370,11 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
+ return error;
+ }
+
++/**
++ * mptsas_sas_io_unit_pg1 -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ *
++ **/
+ static int
+ mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
+ {
+@@ -1483,11 +2390,11 @@ mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
+
+ cfg.cfghdr.ehdr = &hdr;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+- cfg.timeout = 10;
+ cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
+ cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
+ cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
+ cfg.cfghdr.ehdr->PageNumber = 1;
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+ error = mpt_config(ioc, &cfg);
+ if (error)
+@@ -1525,6 +2432,14 @@ mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
+ return error;
+ }
+
++/**
++ * mptsas_sas_phy_pg0 -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @phy_info:
++ * @form:
++ * @form_specific:
++ *
++ **/
+ static int
+ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
+ u32 form, u32 form_specific)
+@@ -1545,12 +2460,12 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, str
+
+ cfg.cfghdr.ehdr = &hdr;
+ cfg.dir = 0; /* read */
+- cfg.timeout = 10;
+
+ /* Get Phy Pg 0 for each Phy. */
+ cfg.physAddr = -1;
+ cfg.pageAddr = form + form_specific;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+ error = mpt_config(ioc, &cfg);
+ if (error)
+@@ -1581,6 +2496,8 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, str
+ phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
+ phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
+ phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
++ phy_info->change_count = buffer->ChangeCount;
++ phy_info->phy_info = le32_to_cpu(buffer->PhyInfo);
+
+ out_free_consistent:
+ pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
+@@ -1589,6 +2506,14 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, str
+ return error;
+ }
+
++/**
++ * mptsas_sas_device_pg0 -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @device_info:
++ * @form:
++ * @form_specific:
++ *
++ **/
+ static int
+ mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
+ u32 form, u32 form_specific)
+@@ -1600,10 +2525,6 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
+ __le64 sas_address;
+ int error=0;
+
+- if (ioc->sas_discovery_runtime &&
+- mptsas_is_end_device(device_info))
+- goto out;
+-
+ hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
+ hdr.ExtPageLength = 0;
+ hdr.PageNumber = 0;
+@@ -1617,9 +2538,8 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
+ cfg.physAddr = -1;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+ cfg.dir = 0; /* read */
+- cfg.timeout = 10;
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+- memset(device_info, 0, sizeof(struct mptsas_devinfo));
+ error = mpt_config(ioc, &cfg);
+ if (error)
+ goto out;
+@@ -1639,11 +2559,18 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
+ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+
+ error = mpt_config(ioc, &cfg);
++
++ if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
++ error = -ENODEV;
++ goto out_free_consistent;
++ }
++
+ if (error)
+ goto out_free_consistent;
+
+ mptsas_print_device_pg0(ioc, buffer);
+
++ memset(device_info, 0, sizeof(struct mptsas_devinfo));
+ device_info->handle = le16_to_cpu(buffer->DevHandle);
+ device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
+ device_info->handle_enclosure =
+@@ -1666,6 +2593,14 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
+ return error;
+ }
+
++/**
++ * mptsas_sas_expander_pg0 -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @port_info:
++ * @form:
++ * @form_specific:
++ *
++ **/
+ static int
+ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
+ u32 form, u32 form_specific)
+@@ -1675,7 +2610,9 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
+ SasExpanderPage0_t *buffer;
+ dma_addr_t dma_handle;
+ int i, error;
++ __le64 sas_address;
+
++ memset(port_info, 0, sizeof(struct mptsas_portinfo));
+ hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
+ hdr.ExtPageLength = 0;
+ hdr.PageNumber = 0;
+@@ -1689,9 +2626,8 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
+ cfg.pageAddr = form + form_specific;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+ cfg.dir = 0; /* read */
+- cfg.timeout = 10;
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+- memset(port_info, 0, sizeof(struct mptsas_portinfo));
+ error = mpt_config(ioc, &cfg);
+ if (error)
+ goto out;
+@@ -1712,27 +2648,32 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
+ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+
+ error = mpt_config(ioc, &cfg);
+- if (error)
+- goto out_free_consistent;
+-
+- if (!buffer->NumPhys) {
++ if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
+ error = -ENODEV;
+ goto out_free_consistent;
+ }
+
++ if (error)
++ goto out_free_consistent;
++
+ /* save config data */
+- port_info->num_phys = buffer->NumPhys;
++ port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
+ port_info->phy_info = kcalloc(port_info->num_phys,
+- sizeof(*port_info->phy_info),GFP_KERNEL);
++ sizeof(struct mptsas_phyinfo),GFP_KERNEL);
+ if (!port_info->phy_info) {
+ error = -ENOMEM;
+ goto out_free_consistent;
+ }
+
++ memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
+ for (i = 0; i < port_info->num_phys; i++) {
+ port_info->phy_info[i].portinfo = port_info;
+ port_info->phy_info[i].handle =
+ le16_to_cpu(buffer->DevHandle);
++ port_info->phy_info[i].identify.sas_address =
++ le64_to_cpu(sas_address);
++ port_info->phy_info[i].identify.handle_parent =
++ le16_to_cpu(buffer->ParentDevHandle);
+ }
+
+ out_free_consistent:
+@@ -1742,6 +2683,14 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
+ return error;
+ }
+
++/**
++ * mptsas_sas_expander_pg1 -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @phy_info:
++ * @form:
++ * @form_specific:
++ *
++ **/
+ static int
+ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
+ u32 form, u32 form_specific)
+@@ -1752,11 +2701,7 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc
+ dma_addr_t dma_handle;
+ int error=0;
+
+- if (ioc->sas_discovery_runtime &&
+- mptsas_is_end_device(&phy_info->attached))
+- goto out;
+-
+- hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
++ hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION;
+ hdr.ExtPageLength = 0;
+ hdr.PageNumber = 1;
+ hdr.Reserved1 = 0;
+@@ -1764,1352 +2709,2349 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc
+ hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
+ hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
+
+- cfg.cfghdr.ehdr = &hdr;
+- cfg.physAddr = -1;
+- cfg.pageAddr = form + form_specific;
++ cfg.cfghdr.ehdr = &hdr;
++ cfg.physAddr = -1;
++ cfg.pageAddr = form + form_specific;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ cfg.dir = 0; /* read */
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
++
++ error = mpt_config(ioc, &cfg);
++ if (error)
++ goto out;
++
++ if (!hdr.ExtPageLength) {
++ error = -ENXIO;
++ goto out;
++ }
++
++ buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
++ &dma_handle);
++ if (!buffer) {
++ error = -ENOMEM;
++ goto out;
++ }
++
++ cfg.physAddr = dma_handle;
++ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++
++ error = mpt_config(ioc, &cfg);
++ if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
++ error = -ENODEV;
++ goto out;
++ }
++
++ if (error)
++ goto out_free_consistent;
++
++
++ mptsas_print_expander_pg1(ioc, buffer);
++
++ /* save config data */
++ phy_info->phy_id = buffer->PhyIdentifier;
++ phy_info->port_id = buffer->PhysicalPort;
++ phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
++ phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
++ phy_info->hw_link_rate = buffer->HwLinkRate;
++ phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
++ phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
++ phy_info->change_count = buffer->ChangeCount;
++ phy_info->phy_info = le32_to_cpu(buffer->PhyInfo);
++
++ out_free_consistent:
++ pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
++ buffer, dma_handle);
++ out:
++ return error;
++}
++
++/**
++ * mptsas_parse_device_info -
++ * @identify:
++ * @device_info:
++ *
++ **/
++static void
++mptsas_parse_device_info(struct sas_identify *identify,
++ struct mptsas_devinfo *device_info)
++{
++ u16 protocols;
++
++ identify->sas_address = device_info->sas_address;
++ identify->phy_identifier = device_info->phy_id;
++
++ /*
++ * Fill in Phy Initiator Port Protocol.
++ * Bits 6:3, more than one bit can be set, fall through cases.
++ */
++ protocols = device_info->device_info & 0x78;
++ identify->initiator_port_protocols = 0;
++ if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
++ identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
++ if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
++ identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
++ if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
++ identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
++ if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
++ identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
++
++ /*
++ * Fill in Phy Target Port Protocol.
++ * Bits 10:7, more than one bit can be set, fall through cases.
++ */
++ protocols = device_info->device_info & 0x780;
++ identify->target_port_protocols = 0;
++ if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
++ identify->target_port_protocols |= SAS_PROTOCOL_SSP;
++ if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
++ identify->target_port_protocols |= SAS_PROTOCOL_STP;
++ if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
++ identify->target_port_protocols |= SAS_PROTOCOL_SMP;
++ if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
++ identify->target_port_protocols |= SAS_PROTOCOL_SATA;
++
++ /*
++ * Fill in Attached device type.
++ */
++ switch (device_info->device_info &
++ MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
++ case MPI_SAS_DEVICE_INFO_NO_DEVICE:
++ identify->device_type = SAS_PHY_UNUSED;
++ break;
++ case MPI_SAS_DEVICE_INFO_END_DEVICE:
++ identify->device_type = SAS_END_DEVICE;
++ break;
++ case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
++ identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
++ break;
++ case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
++ identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
++ break;
++ }
++}
++
++/**
++ * mptsas_probe_one_phy -
++ * @dev:
++ * @phy_info:
++ * @local:
++ *
++ **/
++static int mptsas_probe_one_phy(struct device *dev,
++ struct mptsas_phyinfo *phy_info, int index, int local)
++{
++ MPT_ADAPTER *ioc;
++ struct sas_phy *phy;
++ struct sas_port *port;
++ int error = 0;
++
++ if (!dev) {
++ error = -ENODEV;
++ goto out;
++ }
++
++ if (!phy_info->phy) {
++ phy = sas_phy_alloc(dev, index);
++ if (!phy) {
++ error = -ENOMEM;
++ goto out;
++ }
++ } else
++ phy = phy_info->phy;
++
++ mptsas_parse_device_info(&phy->identify, &phy_info->identify);
++
++ /*
++ * Set Negotiated link rate.
++ */
++ switch (phy_info->negotiated_link_rate) {
++ case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
++ phy->negotiated_linkrate = SAS_PHY_DISABLED;
++ break;
++ case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
++ phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
++ break;
++ case MPI_SAS_IOUNIT0_RATE_1_5:
++ phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
++ break;
++ case MPI_SAS_IOUNIT0_RATE_3_0:
++ phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
++ break;
++ case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
++ case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
++ default:
++ phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
++ break;
++ }
++
++ /*
++ * Set Max hardware link rate.
++ */
++ switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
++ case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
++ phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
++ break;
++ case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
++ phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
++ break;
++ default:
++ break;
++ }
++
++ /*
++ * Set Max programmed link rate.
++ */
++ switch (phy_info->programmed_link_rate &
++ MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
++ case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
++ phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
++ break;
++ case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
++ phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
++ break;
++ default:
++ break;
++ }
++
++ /*
++ * Set Min hardware link rate.
++ */
++ switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
++ case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
++ phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
++ break;
++ case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
++ phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
++ break;
++ default:
++ break;
++ }
++
++ /*
++ * Set Min programmed link rate.
++ */
++ switch (phy_info->programmed_link_rate &
++ MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
++ case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
++ phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
++ break;
++ case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
++ phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
++ break;
++ default:
++ break;
++ }
++
++ if (!phy_info->phy) {
++
++ error = sas_phy_add(phy);
++ if (error) {
++ sas_phy_free(phy);
++ goto out;
++ }
++ phy_info->phy = phy;
++ }
++
++ if (!phy_info->attached.handle ||
++ !phy_info->port_details)
++ goto out;
++
++ port = mptsas_get_port(phy_info);
++ ioc = phy_to_ioc(phy_info->phy);
++
++ if (phy_info->sas_port_add_phy) {
++ if (!port) {
++ port = sas_port_alloc_num(dev);
++ if (!port) {
++ error = -ENOMEM;
++ goto out;
++ }
++ error = sas_port_add(port);
++ if (error) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: exit at line=%d\n", ioc->name,
++ __FUNCTION__, __LINE__));
++ goto out;
++ }
++ mptsas_set_port(ioc, phy_info, port);
++ devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
++ MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
++ ioc->name, port->port_identifier,
++ (unsigned long long)phy_info->attached.sas_address));
++ }
++ sas_port_add_phy(port, phy_info->phy);
++ phy_info->sas_port_add_phy = 0;
++ devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
++ MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
++ phy_info->phy_id, phy_info->phy));
++ }
++
++ if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
++
++ struct sas_rphy *rphy;
++ struct device *parent;
++ struct sas_identify identify;
++
++ parent = dev->parent->parent;
++
++ if (mptsas_is_end_device(&phy_info->attached) &&
++ phy_info->attached.handle_parent) {
++ goto out;
++ }
++
++ mptsas_parse_device_info(&identify, &phy_info->attached);
++ if (scsi_is_host_device(parent)) {
++ struct mptsas_portinfo *port_info;
++ int i;
++
++ port_info = ioc->hba_port_info;
++ for (i = 0; i < port_info->num_phys; i++)
++ if (port_info->phy_info[i].identify.sas_address ==
++ identify.sas_address) {
++ sas_port_mark_backlink(port);
++ goto out;
++ }
++
++ } else if (scsi_is_sas_rphy(parent)) {
++ struct sas_rphy *parent_rphy = dev_to_rphy(parent);
++ if (identify.sas_address ==
++ parent_rphy->identify.sas_address) {
++ sas_port_mark_backlink(port);
++ goto out;
++ }
++ }
++
++ switch (identify.device_type) {
++ case SAS_END_DEVICE:
++ rphy = sas_end_device_alloc(port);
++ break;
++ case SAS_EDGE_EXPANDER_DEVICE:
++ case SAS_FANOUT_EXPANDER_DEVICE:
++ rphy = sas_expander_alloc(port, identify.device_type);
++ break;
++ default:
++ rphy = NULL;
++ break;
++ }
++ if (!rphy) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: exit at line=%d\n", ioc->name,
++ __FUNCTION__, __LINE__));
++ goto out;
++ }
++
++ rphy->identify = identify;
++ error = sas_rphy_add(rphy);
++ if (error) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: exit at line=%d\n", ioc->name,
++ __FUNCTION__, __LINE__));
++ sas_rphy_free(rphy);
++ goto out;
++ }
++ mptsas_set_rphy(ioc, phy_info, rphy);
++ }
++
++ out:
++ return error;
++}
++
++/**
++ * mptsas_probe_hba_phys -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @handle:
++ *
++ **/
++static int
++mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
++{
++ struct mptsas_portinfo *port_info, *hba;
++ int error = -ENOMEM, i;
++
++ hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
++ if (! hba)
++ goto out;
++
++ error = mptsas_sas_io_unit_pg0(ioc, hba);
++ if (error)
++ goto out_free_port_info;
++
++ mptsas_sas_io_unit_pg1(ioc);
++ mutex_lock(&ioc->sas_topology_mutex);
++ port_info = ioc->hba_port_info;
++ if (!port_info) {
++ ioc->hba_port_info = port_info = hba;
++ ioc->hba_port_num_phy = port_info->num_phys;
++ list_add_tail(&port_info->list, &ioc->sas_topology);
++ } else {
++ for (i = 0; i < hba->num_phys; i++) {
++ port_info->phy_info[i].negotiated_link_rate =
++ hba->phy_info[i].negotiated_link_rate;
++ port_info->phy_info[i].handle =
++ hba->phy_info[i].handle;
++ port_info->phy_info[i].port_id =
++ hba->phy_info[i].port_id;
++ port_info->phy_info[i].port_flags =
++ hba->phy_info[i].port_flags;
++ }
++ kfree(hba->phy_info);
++ kfree(hba);
++ hba = NULL;
++ }
++ mutex_unlock(&ioc->sas_topology_mutex);
++#if defined(CPQ_CIM)
++ ioc->num_ports = port_info->num_phys;
++#endif
++ for (i = 0; i < port_info->num_phys; i++) {
++ mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
++ (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
++ MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
++ port_info->phy_info[i].identify.handle =
++ port_info->phy_info[i].handle;
++ mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
++ (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ port_info->phy_info[i].identify.handle);
++ if (!ioc->hba_port_sas_addr)
++ ioc->hba_port_sas_addr =
++ port_info->phy_info[i].identify.sas_address;
++ port_info->phy_info[i].identify.phy_id =
++ port_info->phy_info[i].phy_id = i;
++ if (port_info->phy_info[i].attached.handle)
++ mptsas_sas_device_pg0(ioc,
++ &port_info->phy_info[i].attached,
++ (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ port_info->phy_info[i].attached.handle);
++ }
++
++ mptsas_setup_wide_ports(ioc, port_info);
++
++ for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
++ mptsas_probe_one_phy(&ioc->sh->shost_gendev,
++ &port_info->phy_info[i], ioc->sas_index, 1);
++
++ return 0;
++
++ out_free_port_info:
++ kfree(hba);
++ out:
++ return error;
++}
++
++/**
++ * mptsas_find_phyinfo_by_sas_address -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @sas_address:
++ *
++ **/
++static struct mptsas_phyinfo *
++mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
++{
++ struct mptsas_portinfo *port_info;
++ struct mptsas_phyinfo *phy_info = NULL;
++ int i;
++
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_for_each_entry(port_info, &ioc->sas_topology, list) {
++ for (i = 0; i < port_info->num_phys; i++) {
++ if (!mptsas_is_end_device(
++ &port_info->phy_info[i].attached))
++ continue;
++ if (port_info->phy_info[i].attached.sas_address
++ != sas_address)
++ continue;
++ phy_info = &port_info->phy_info[i];
++ break;
++ }
++ }
++ mutex_unlock(&ioc->sas_topology_mutex);
++ return phy_info;
++}
++
++/**
++ * mptsas_find_phyinfo_by_phys_disk_num -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @phys_disk_num:
++ * @channel:
++ * @id:
++ *
++ **/
++static struct mptsas_phyinfo *
++mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
++ u8 channel, u8 id)
++{
++ struct mptsas_phyinfo *phy_info;
++ struct mptsas_portinfo *port_info;
++ RaidPhysDiskPage1_t *phys_disk = NULL;
++ int num_paths;
++ u64 sas_address = 0;
++ int i;
++
++ phy_info = NULL;
++ if (!ioc->raid_data.pIocPg3)
++ return NULL;
++ /* dual port support */
++ num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
++ if (!num_paths)
++ goto out;
++ phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
++ (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
++ if (!phys_disk)
++ goto out;
++ mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
++ for (i = 0; i < num_paths; i++) {
++ if ((phys_disk->Path[i].Flags & 1) != 0)
++ /* entry no longer valid */
++ continue;
++ if ((id == phys_disk->Path[i].PhysDiskID) &&
++ (channel == phys_disk->Path[i].PhysDiskBus)) {
++ memcpy(&sas_address, &phys_disk->Path[i].WWID,
++ sizeof(u64));
++ phy_info = mptsas_find_phyinfo_by_sas_address(ioc, sas_address);
++ goto out;
++ }
++ }
++
++ out:
++ kfree(phys_disk);
++ if (phy_info)
++ return phy_info;
++
++ /*
++ * Extra code to handle RAID0 case, where the sas_address is not updated
++ * in phys_disk_page_1 when hotswapped
++ */
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_for_each_entry(port_info, &ioc->sas_topology, list) {
++ for (i = 0; i < port_info->num_phys && !phy_info; i++) {
++ if (!mptsas_is_end_device(
++ &port_info->phy_info[i].attached))
++ continue;
++ if (port_info->phy_info[i].attached.phys_disk_num == ~0)
++ continue;
++ if (port_info->phy_info[i].attached.phys_disk_num == phys_disk_num &&
++ port_info->phy_info[i].attached.id == id &&
++ port_info->phy_info[i].attached.channel == channel)
++ phy_info = &port_info->phy_info[i];
++ }
++ }
++ mutex_unlock(&ioc->sas_topology_mutex);
++ return phy_info;
++}
++
++/**
++ * mptsas_reprobe_lun -
++ * @sdev:
++ * @data:
++ *
++ **/
++static void
++mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
++{
++ int rc;
++
++ sdev->no_uld_attach = data ? 1 : 0;
++ rc = scsi_device_reprobe(sdev);
++}
++
++/**
++ * mptsas_reprobe_target -
++ * @starget:
++ * @uld_attach:
++ *
++ **/
++static void
++mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
++{
++ starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
++ mptsas_reprobe_lun);
++}
++
++/**
++ * mptsas_adding_inactive_raid_components -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @channel:
++ * @id:
++ *
++ *
++ * TODO: check for hotspares
++ **/
++static void
++mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
++{
++ CONFIGPARMS cfg;
++ ConfigPageHeader_t hdr;
++ dma_addr_t dma_handle;
++ pRaidVolumePage0_t buffer = NULL;
++ RaidPhysDiskPage0_t phys_disk;
++ int i;
++ struct mptsas_phyinfo *phy_info;
++ struct mptsas_devinfo sas_device;
++
++ memset(&cfg, 0 , sizeof(CONFIGPARMS));
++ memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
++ hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
++ cfg.pageAddr = (channel << 8) + id;
++ cfg.cfghdr.hdr = &hdr;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
+- cfg.dir = 0; /* read */
+- cfg.timeout = 10;
++ cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
+
+- error = mpt_config(ioc, &cfg);
+- if (error)
++ if (mpt_config(ioc, &cfg) != 0)
+ goto out;
+
+- if (!hdr.ExtPageLength) {
+- error = -ENXIO;
++ if (!hdr.PageLength)
+ goto out;
+- }
+
+- buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
+- &dma_handle);
+- if (!buffer) {
+- error = -ENOMEM;
++ buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
++ &dma_handle);
++
++ if (!buffer)
+ goto out;
+- }
+
+ cfg.physAddr = dma_handle;
+ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+
+- error = mpt_config(ioc, &cfg);
+- if (error)
+- goto out_free_consistent;
+-
+-
+- mptsas_print_expander_pg1(ioc, buffer);
+-
+- /* save config data */
+- phy_info->phy_id = buffer->PhyIdentifier;
+- phy_info->port_id = buffer->PhysicalPort;
+- phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
+- phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
+- phy_info->hw_link_rate = buffer->HwLinkRate;
+- phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
+- phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
++ if (mpt_config(ioc, &cfg) != 0)
++ goto out;
+
+- out_free_consistent:
+- pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
+- buffer, dma_handle);
+- out:
+- return error;
+-}
++ if (!(buffer->VolumeStatus.Flags &
++ MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
++ goto out;
+
+-static void
+-mptsas_parse_device_info(struct sas_identify *identify,
+- struct mptsas_devinfo *device_info)
+-{
+- u16 protocols;
++ if (!buffer->NumPhysDisks)
++ goto out;
+
+- identify->sas_address = device_info->sas_address;
+- identify->phy_identifier = device_info->phy_id;
++ for (i = 0; i < buffer->NumPhysDisks; i++) {
+
+- /*
+- * Fill in Phy Initiator Port Protocol.
+- * Bits 6:3, more than one bit can be set, fall through cases.
+- */
+- protocols = device_info->device_info & 0x78;
+- identify->initiator_port_protocols = 0;
+- if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
+- identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
+- if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
+- identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
+- if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
+- identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
+- if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
+- identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
++ if (mpt_raid_phys_disk_pg0(ioc,
++ buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
++ continue;
+
+- /*
+- * Fill in Phy Target Port Protocol.
+- * Bits 10:7, more than one bit can be set, fall through cases.
+- */
+- protocols = device_info->device_info & 0x780;
+- identify->target_port_protocols = 0;
+- if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
+- identify->target_port_protocols |= SAS_PROTOCOL_SSP;
+- if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
+- identify->target_port_protocols |= SAS_PROTOCOL_STP;
+- if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
+- identify->target_port_protocols |= SAS_PROTOCOL_SMP;
+- if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
+- identify->target_port_protocols |= SAS_PROTOCOL_SATA;
++ if (mptsas_sas_device_pg0(ioc, &sas_device,
++ (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ (phys_disk.PhysDiskBus << 8) +
++ phys_disk.PhysDiskID))
++ continue;
+
+- /*
+- * Fill in Attached device type.
+- */
+- switch (device_info->device_info &
+- MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
+- case MPI_SAS_DEVICE_INFO_NO_DEVICE:
+- identify->device_type = SAS_PHY_UNUSED;
+- break;
+- case MPI_SAS_DEVICE_INFO_END_DEVICE:
+- identify->device_type = SAS_END_DEVICE;
+- break;
+- case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
+- identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
+- break;
+- case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
+- identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
+- break;
++ phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
++ sas_device.sas_address);
++ mptsas_add_end_device(ioc, phy_info);
+ }
++
++ out:
++ if (buffer)
++ pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
++ dma_handle);
+ }
+
+-static int mptsas_probe_one_phy(struct device *dev,
+- struct mptsas_phyinfo *phy_info, int index, int local)
++/**
++ * mptsas_add_end_device - report a new end device to sas transport layer
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @phy_info: decribes attached device
++ *
++ * return (0) success (1) failure
++ *
++ **/
++static int
++mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
+ {
+- MPT_ADAPTER *ioc;
+- struct sas_phy *phy;
++ struct sas_rphy *rphy;
+ struct sas_port *port;
+- int error = 0;
++ struct sas_identify identify;
++ char *ds = NULL;
++ u8 fw_id;
+
+- if (!dev) {
+- error = -ENODEV;
+- goto out;
++ if (!phy_info){
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: exit at line=%d\n", ioc->name,
++ __FUNCTION__, __LINE__));
++ return 1;
+ }
+
+- if (!phy_info->phy) {
+- phy = sas_phy_alloc(dev, index);
+- if (!phy) {
+- error = -ENOMEM;
+- goto out;
+- }
+- } else
+- phy = phy_info->phy;
+-
+- mptsas_parse_device_info(&phy->identify, &phy_info->identify);
+-
+- /*
+- * Set Negotiated link rate.
+- */
+- switch (phy_info->negotiated_link_rate) {
+- case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
+- phy->negotiated_linkrate = SAS_PHY_DISABLED;
+- break;
+- case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
+- phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
+- break;
+- case MPI_SAS_IOUNIT0_RATE_1_5:
+- phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
+- break;
+- case MPI_SAS_IOUNIT0_RATE_3_0:
+- phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
+- break;
+- case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
+- case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
+- default:
+- phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
+- break;
+- }
++ fw_id = phy_info->attached.id;
+
+- /*
+- * Set Max hardware link rate.
+- */
+- switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
+- case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
+- phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
+- break;
+- case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
+- phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
+- break;
+- default:
+- break;
++ if (mptsas_get_rphy(phy_info)) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, fw_id, __LINE__));
++ return 2;
+ }
+
+- /*
+- * Set Max programmed link rate.
+- */
+- switch (phy_info->programmed_link_rate &
+- MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
+- case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
+- phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
+- break;
+- case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
+- phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
+- break;
+- default:
+- break;
++ port = mptsas_get_port(phy_info);
++ if (!port) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, fw_id, __LINE__));
++ return 3;
++ }
++
++ if (phy_info->attached.device_info &
++ MPI_SAS_DEVICE_INFO_SSP_TARGET)
++ ds = "ssp";
++ if (phy_info->attached.device_info &
++ MPI_SAS_DEVICE_INFO_STP_TARGET)
++ ds = "stp";
++ if (phy_info->attached.device_info &
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE)
++ ds = "sata";
++
++ printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d,"
++ " phy %d, sas_addr 0x%llx\n", ioc->name, ds,
++ phy_info->attached.channel, phy_info->attached.id,
++ phy_info->attached.phy_id, (unsigned long long)
++ phy_info->attached.sas_address);
++
++ mptsas_parse_device_info(&identify, &phy_info->attached);
++ rphy = sas_end_device_alloc(port);
++ if (!rphy) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, fw_id, __LINE__));
++ return 5; /* non-fatal: an rphy can be added later */
++ }
++
++ rphy->identify = identify;
++ if (sas_rphy_add(rphy)) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, fw_id, __LINE__));
++ sas_rphy_free(rphy);
++ return 6;
+ }
++ mptsas_set_rphy(ioc, phy_info, rphy);
++ return 0;
++}
+
+- /*
+- * Set Min hardware link rate.
+- */
+- switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
+- case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
+- phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
+- break;
+- case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
+- phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
+- break;
+- default:
+- break;
+- }
++/**
++ * mptsas_del_end_device - report a deleted end device to sas transport
++ * layer
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @phy_info: decribes attached device
++ *
++ **/
++static void
++mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
++{
++ struct sas_rphy *rphy;
++ struct sas_port *port;
++ struct mptsas_portinfo *port_info;
++ struct mptsas_phyinfo *phy_info_parent;
++ int i;
++ struct scsi_target * starget;
++ char *ds = NULL;
++ u8 fw_id;
++ u64 sas_address;
+
+- /*
+- * Set Min programmed link rate.
+- */
+- switch (phy_info->programmed_link_rate &
+- MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
+- case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
+- phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
+- break;
+- case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
+- phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
+- break;
+- default:
+- break;
+- }
++ if (!phy_info)
++ return;
+
+- if (!phy_info->phy) {
++ fw_id = phy_info->attached.id;
++ sas_address = phy_info->attached.sas_address;
+
+- error = sas_phy_add(phy);
+- if (error) {
+- sas_phy_free(phy);
+- goto out;
+- }
+- phy_info->phy = phy;
++ if (!phy_info->port_details) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, fw_id, __LINE__));
++ return;
+ }
+-
+- if (!phy_info->attached.handle ||
+- !phy_info->port_details)
+- goto out;
++ rphy = mptsas_get_rphy(phy_info);
++ if (!rphy) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, fw_id, __LINE__));
++ return;
++ }
++ if (phy_info->attached.device_info &
++ MPI_SAS_DEVICE_INFO_SSP_TARGET)
++ ds = "ssp";
++ if (phy_info->attached.device_info &
++ MPI_SAS_DEVICE_INFO_STP_TARGET)
++ ds = "stp";
++ if (phy_info->attached.device_info &
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE)
++ ds = "sata";
++
++ starget = mptsas_get_starget(phy_info);
++
++ printk(MYIOC_s_INFO_FMT "removing %s device: fw_channel %d,"
++ " fw_id %d, phy %d, sas_addr 0x%llx\n", ioc->name, ds,
++ phy_info->attached.channel, phy_info->attached.id,
++ phy_info->attached.phy_id, (unsigned long long)
++ sas_address);
+
+ port = mptsas_get_port(phy_info);
+- ioc = phy_to_ioc(phy_info->phy);
++ if (!port) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, fw_id, __LINE__));
++ return;
++ }
++ port_info = phy_info->portinfo;
++ phy_info_parent = port_info->phy_info;
++ for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) {
++ if(!phy_info_parent->phy)
++ continue;
++ if (phy_info_parent->attached.sas_address !=
++ sas_address)
++ continue;
++ dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev,
++ MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n",
++ ioc->name, phy_info_parent->phy_id,
++ phy_info_parent->phy);
++ sas_port_delete_phy(port, phy_info_parent->phy);
++ }
++
++ dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
++ "delete port %d, sas_addr (0x%llx)\n", ioc->name,
++ port->port_identifier, (unsigned long long)sas_address);
++ sas_port_delete(port);
++// mptsas_port_delete(ioc, phy_info->port_details);
++}
+
+- if (phy_info->sas_port_add_phy) {
++struct mptsas_phyinfo *
++mptsas_refreshing_device_handles(MPT_ADAPTER *ioc, struct mptsas_devinfo *sas_device)
++{
++ struct mptsas_phyinfo *phy_info;
++ struct mptsas_portinfo *port_info;
++ int i;
+
+- if (!port) {
+- port = sas_port_alloc_num(dev);
+- if (!port) {
+- error = -ENOMEM;
+- goto out;
+- }
+- error = sas_port_add(port);
+- if (error) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- goto out;
+- }
+- mptsas_set_port(ioc, phy_info, port);
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "sas_port_alloc: port=%p dev=%p port_id=%d\n",
+- ioc->name, port, dev, port->port_identifier));
+- }
+- dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_port_add_phy: phy_id=%d\n",
+- ioc->name, phy_info->phy_id));
+- sas_port_add_phy(port, phy_info->phy);
+- phy_info->sas_port_add_phy = 0;
++ phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
++ sas_device->sas_address);
++ if (!phy_info)
++ goto out;
++ port_info = phy_info->portinfo;
++ if (!port_info)
++ goto out;
++ mutex_lock(&ioc->sas_topology_mutex);
++ for (i = 0; i < port_info->num_phys; i++) {
++ if(port_info->phy_info[i].attached.sas_address !=
++ sas_device->sas_address)
++ continue;
++ port_info->phy_info[i].attached.channel = sas_device->channel;
++ port_info->phy_info[i].attached.id = sas_device->id;
++ port_info->phy_info[i].attached.sas_address =
++ sas_device->sas_address;
++ port_info->phy_info[i].attached.handle = sas_device->handle;
++ port_info->phy_info[i].attached.handle_parent =
++ sas_device->handle_parent;
++ port_info->phy_info[i].attached.handle_enclosure =
++ sas_device->handle_enclosure;
+ }
++ mutex_unlock(&ioc->sas_topology_mutex);
++ out:
++ return phy_info;
++}
+
+- if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
+-
+- struct sas_rphy *rphy;
+- struct device *parent;
+- struct sas_identify identify;
+
+- parent = dev->parent->parent;
+- /*
+- * Let the hotplug_work thread handle processing
+- * the adding/removing of devices that occur
+- * after start of day.
+- */
+- if (ioc->sas_discovery_runtime &&
+- mptsas_is_end_device(&phy_info->attached))
+- goto out;
++/**
++ * mptsas_hotplug_work - Work queue thread to handle SAS hotplug events
++ *
++ *
++ **/
++static void
++mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
++ struct mptsas_hotplug_event *hot_plug_info)
++{
++ struct mptsas_phyinfo *phy_info;
++ struct scsi_target * starget;
++ struct mptsas_devinfo sas_device;
++ VirtTarget *vtarget;
++ enum device_state state;
++ int i;
+
+- mptsas_parse_device_info(&identify, &phy_info->attached);
+- if (scsi_is_host_device(parent)) {
+- struct mptsas_portinfo *port_info;
+- int i;
++ switch (hot_plug_info->event_type) {
+
+- mutex_lock(&ioc->sas_topology_mutex);
+- port_info = mptsas_get_hba_portinfo(ioc);
+- mutex_unlock(&ioc->sas_topology_mutex);
++ case MPTSAS_ADD_PHYSDISK:
+
+- for (i = 0; i < port_info->num_phys; i++)
+- if (port_info->phy_info[i].identify.sas_address ==
+- identify.sas_address) {
+- sas_port_mark_backlink(port);
+- goto out;
+- }
++ if (!ioc->raid_data.pIocPg2)
++ break;
+
+- } else if (scsi_is_sas_rphy(parent)) {
+- struct sas_rphy *parent_rphy = dev_to_rphy(parent);
+- if (identify.sas_address ==
+- parent_rphy->identify.sas_address) {
+- sas_port_mark_backlink(port);
+- goto out;
++ for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
++ if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
++ hot_plug_info->id) {
++ printk(MYIOC_s_WARN_FMT "firmware bug: unable "
++ "to add hidden disk - target_id matchs "
++ "volume_id\n", ioc->name);
++ mptsas_free_fw_event(ioc, fw_event);
++ return;
+ }
+ }
+
+- switch (identify.device_type) {
+- case SAS_END_DEVICE:
+- rphy = sas_end_device_alloc(port);
+- break;
+- case SAS_EDGE_EXPANDER_DEVICE:
+- case SAS_FANOUT_EXPANDER_DEVICE:
+- rphy = sas_expander_alloc(port, identify.device_type);
++ case MPTSAS_ADD_DEVICE:
++ memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
++ mptsas_sas_device_pg0(ioc, &sas_device,
++ (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ (hot_plug_info->channel << 8) +
++ hot_plug_info->id);
++
++ if (!sas_device.handle)
++ return;
++
++ phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
++ if (!phy_info)
+ break;
+- default:
+- rphy = NULL;
++
++ if (mptsas_get_rphy(phy_info))
+ break;
+- }
+- if (!rphy) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- goto out;
+- }
+
+- rphy->identify = identify;
+- error = sas_rphy_add(rphy);
+- if (error) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- sas_rphy_free(rphy);
+- goto out;
++ state = mptsas_test_unit_ready(ioc, phy_info->attached.channel,
++ phy_info->attached.id, fw_event->retries);
++
++ if (state == DEVICE_RETRY && !ioc->fw_events_off) {
++ mptsas_requeue_fw_event(ioc, fw_event, 1000);
++ return;
+ }
+- mptsas_set_rphy(ioc, phy_info, rphy);
+- }
+
+- out:
+- return error;
+-}
++ if (state == DEVICE_READY)
++ mptsas_add_end_device(ioc, phy_info);
++ break;
+
+-static int
+-mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
+-{
+- struct mptsas_portinfo *port_info, *hba;
+- int error = -ENOMEM, i;
++ case MPTSAS_DEL_DEVICE:
+
+- hba = kzalloc(sizeof(*port_info), GFP_KERNEL);
+- if (! hba)
+- goto out;
++ if (!ioc->disable_hotplug_remove) {
++ phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
++ hot_plug_info->sas_address);
++ mptsas_del_end_device(ioc, phy_info);
++ }
++ break;
+
+- error = mptsas_sas_io_unit_pg0(ioc, hba);
+- if (error)
+- goto out_free_port_info;
++ case MPTSAS_DEL_PHYSDISK:
+
+- mptsas_sas_io_unit_pg1(ioc);
+- mutex_lock(&ioc->sas_topology_mutex);
+- port_info = mptsas_get_hba_portinfo(ioc);
+- if (!port_info) {
+- port_info = hba;
+- list_add_tail(&port_info->list, &ioc->sas_topology);
+- } else {
+- for (i = 0; i < hba->num_phys; i++) {
+- port_info->phy_info[i].negotiated_link_rate =
+- hba->phy_info[i].negotiated_link_rate;
+- port_info->phy_info[i].handle =
+- hba->phy_info[i].handle;
+- port_info->phy_info[i].port_id =
+- hba->phy_info[i].port_id;
+- }
+- kfree(hba->phy_info);
+- kfree(hba);
+- hba = NULL;
+- }
+- mutex_unlock(&ioc->sas_topology_mutex);
+- for (i = 0; i < port_info->num_phys; i++) {
+- mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
+- (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
+- MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
++ mpt_findImVolumes(ioc);
+
+- mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
+- (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
+- MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
+- port_info->phy_info[i].handle);
+- port_info->phy_info[i].identify.phy_id =
+- port_info->phy_info[i].phy_id = i;
+- if (port_info->phy_info[i].attached.handle)
+- mptsas_sas_device_pg0(ioc,
+- &port_info->phy_info[i].attached,
+- (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
+- MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
+- port_info->phy_info[i].attached.handle);
+- }
++ phy_info = mptsas_find_phyinfo_by_phys_disk_num(
++ ioc, hot_plug_info->phys_disk_num, hot_plug_info->channel,
++ hot_plug_info->id);
++ mptsas_del_end_device(ioc, phy_info);
++ break;
+
+- mptsas_setup_wide_ports(ioc, port_info);
++ case MPTSAS_ADD_PHYSDISK_REPROBE:
+
+- for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
+- mptsas_probe_one_phy(&ioc->sh->shost_gendev,
+- &port_info->phy_info[i], ioc->sas_index, 1);
++ if (mptsas_sas_device_pg0(ioc, &sas_device,
++ (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ (hot_plug_info->channel << 8) + hot_plug_info->id)) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
++ }
+
+- return 0;
++ phy_info = mptsas_find_phyinfo_by_sas_address(
++ ioc, sas_device.sas_address);
+
+- out_free_port_info:
+- kfree(hba);
+- out:
+- return error;
+-}
++ if (!phy_info){
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
++ }
+
+-static int
+-mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle)
+-{
+- struct mptsas_portinfo *port_info, *p, *ex;
+- struct device *parent;
+- struct sas_rphy *rphy;
+- int error = -ENOMEM, i, j;
++ starget = mptsas_get_starget(phy_info);
++ if (!starget) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
++ }
+
+- ex = kzalloc(sizeof(*port_info), GFP_KERNEL);
+- if (!ex)
+- goto out;
++ vtarget = starget->hostdata;
++ if (!vtarget) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
++ }
+
+- error = mptsas_sas_expander_pg0(ioc, ex,
+- (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
+- MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
+- if (error)
+- goto out_free_port_info;
++ mpt_findImVolumes(ioc);
+
+- *handle = ex->phy_info[0].handle;
++ starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
++ "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
++ ioc->name, hot_plug_info->channel, hot_plug_info->id,
++ hot_plug_info->phys_disk_num, (unsigned long long)
++ sas_device.sas_address);
++
++ vtarget->id = hot_plug_info->phys_disk_num;
++ vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
++ phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
++ mptsas_reprobe_target(starget, 1);
++ break;
+
+- mutex_lock(&ioc->sas_topology_mutex);
+- port_info = mptsas_find_portinfo_by_handle(ioc, *handle);
+- if (!port_info) {
+- port_info = ex;
+- list_add_tail(&port_info->list, &ioc->sas_topology);
+- } else {
+- for (i = 0; i < ex->num_phys; i++) {
+- port_info->phy_info[i].handle =
+- ex->phy_info[i].handle;
+- port_info->phy_info[i].port_id =
+- ex->phy_info[i].port_id;
++ case MPTSAS_DEL_PHYSDISK_REPROBE:
++
++ if (mptsas_sas_device_pg0(ioc, &sas_device,
++ (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ (hot_plug_info->channel << 8) + hot_plug_info->id)) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n",
++ ioc->name, __FUNCTION__,
++ hot_plug_info->id, __LINE__));
++ break;
+ }
+- kfree(ex->phy_info);
+- kfree(ex);
+- ex = NULL;
+- }
+- mutex_unlock(&ioc->sas_topology_mutex);
+
+- for (i = 0; i < port_info->num_phys; i++) {
+- mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
+- (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
+- MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
++ phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
++ sas_device.sas_address);
++ if (!phy_info) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
++ }
+
+- if (port_info->phy_info[i].identify.handle) {
+- mptsas_sas_device_pg0(ioc,
+- &port_info->phy_info[i].identify,
+- (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
+- MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
+- port_info->phy_info[i].identify.handle);
+- port_info->phy_info[i].identify.phy_id =
+- port_info->phy_info[i].phy_id;
++ starget = mptsas_get_starget(phy_info);
++ if (!starget) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
+ }
+
+- if (port_info->phy_info[i].attached.handle) {
+- mptsas_sas_device_pg0(ioc,
+- &port_info->phy_info[i].attached,
+- (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
+- MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
+- port_info->phy_info[i].attached.handle);
+- port_info->phy_info[i].attached.phy_id =
+- port_info->phy_info[i].phy_id;
++ vtarget = starget->hostdata;
++ if (!vtarget) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
+ }
+- }
+
+- parent = &ioc->sh->shost_gendev;
+- for (i = 0; i < port_info->num_phys; i++) {
+- mutex_lock(&ioc->sas_topology_mutex);
+- list_for_each_entry(p, &ioc->sas_topology, list) {
+- for (j = 0; j < p->num_phys; j++) {
+- if (port_info->phy_info[i].identify.handle !=
+- p->phy_info[j].attached.handle)
+- continue;
+- rphy = mptsas_get_rphy(&p->phy_info[j]);
+- parent = &rphy->dev;
+- }
++ if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: fw_id=%d exit at line=%d\n", ioc->name,
++ __FUNCTION__, hot_plug_info->id, __LINE__));
++ break;
+ }
+- mutex_unlock(&ioc->sas_topology_mutex);
+- }
+
+- mptsas_setup_wide_ports(ioc, port_info);
++ mpt_findImVolumes(ioc);
++
++ starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
++ " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
++ ioc->name, hot_plug_info->channel, hot_plug_info->id,
++ hot_plug_info->phys_disk_num, (unsigned long long)
++ sas_device.sas_address);
++
++ vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
++ vtarget->id = hot_plug_info->id;
++ phy_info->attached.phys_disk_num = ~0;
++ mptsas_reprobe_target(starget, 0);
++ mptsas_add_device_component_by_fw(ioc,
++ hot_plug_info->channel, hot_plug_info->id);
++ break;
++
++ case MPTSAS_ADD_RAID:
++
++ mpt_findImVolumes(ioc);
++ printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
++ "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
++ hot_plug_info->id);
++ scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
++ hot_plug_info->id, 0);
++ break;
++
++ case MPTSAS_DEL_RAID:
++
++ mpt_findImVolumes(ioc);
++ printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
++ "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
++ hot_plug_info->id);
++ scsi_remove_device(hot_plug_info->sdev);
++ scsi_device_put(hot_plug_info->sdev);
++ break;
+
+- for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
+- mptsas_probe_one_phy(parent, &port_info->phy_info[i],
+- ioc->sas_index, 0);
++ case MPTSAS_ADD_INACTIVE_VOLUME:
+
+- return 0;
++ mpt_findImVolumes(ioc);
++ mptsas_adding_inactive_raid_components(ioc,
++ hot_plug_info->channel, hot_plug_info->id);
++ break;
+
+- out_free_port_info:
+- if (ex) {
+- kfree(ex->phy_info);
+- kfree(ex);
++ default:
++ break;
+ }
+- out:
+- return error;
++
++ mptsas_free_fw_event(ioc, fw_event);
+ }
+
+-/*
+- * mptsas_delete_expander_phys
++/**
++ * mptsas_send_sas_event
+ *
+ *
+- * This will traverse topology, and remove expanders
+- * that are no longer present
+- */
++ * @ioc
++ * @sas_event_data
++ *
++ **/
+ static void
+-mptsas_delete_expander_phys(MPT_ADAPTER *ioc)
++mptsas_send_sas_event(struct fw_event_work *fw_event)
+ {
+- struct mptsas_portinfo buffer;
+- struct mptsas_portinfo *port_info, *n, *parent;
+- struct mptsas_phyinfo *phy_info;
+- struct sas_port * port;
+- int i;
+- u64 expander_sas_address;
++ MPT_ADAPTER *ioc;
++ struct mptsas_hotplug_event hot_plug_info;
++ EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
++ u32 device_info;
++ u64 sas_address;
+
+- mutex_lock(&ioc->sas_topology_mutex);
+- list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) {
++ ioc = fw_event->ioc;
++ sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
++ fw_event->event_data;
++ device_info = le32_to_cpu(sas_event_data->DeviceInfo);
+
+- if (port_info->phy_info &&
+- (!(port_info->phy_info[0].identify.device_info &
+- MPI_SAS_DEVICE_INFO_SMP_TARGET)))
+- continue;
++ if ((device_info &
++ (MPI_SAS_DEVICE_INFO_SSP_TARGET |
++ MPI_SAS_DEVICE_INFO_STP_TARGET |
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0) {
++ mptsas_free_fw_event(ioc, fw_event);
++ return;
++ }
+
+- if (mptsas_sas_expander_pg0(ioc, &buffer,
+- (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
+- MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
+- port_info->phy_info[0].handle)) {
++ if (sas_event_data->ReasonCode ==
++ MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
++ mptbase_sas_persist_operation(ioc,
++ MPI_SAS_OP_CLEAR_NOT_PRESENT);
++ mptsas_free_fw_event(ioc, fw_event);
++ return;
++ }
+
+- /*
+- * Obtain the port_info instance to the parent port
+- */
+- parent = mptsas_find_portinfo_by_handle(ioc,
+- port_info->phy_info[0].identify.handle_parent);
++ switch (sas_event_data->ReasonCode) {
++ case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
++ case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
++ memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
++ hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
++ hot_plug_info.channel = sas_event_data->Bus;
++ hot_plug_info.id = sas_event_data->TargetID;
++ hot_plug_info.phy_id = sas_event_data->PhyNum;
++ memcpy(&sas_address, &sas_event_data->SASAddress,
++ sizeof(u64));
++ hot_plug_info.sas_address = le64_to_cpu(sas_address);
++ hot_plug_info.device_info = device_info;
++ if (sas_event_data->ReasonCode &
++ MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
++ hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
++ else
++ hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
++ mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
++ break;
++
++ case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
++ mptbase_sas_persist_operation(ioc,
++ MPI_SAS_OP_CLEAR_NOT_PRESENT);
++ mptsas_free_fw_event(ioc, fw_event);
++ break;
+
+- if (!parent)
+- goto next_port;
++ case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
++ /* TODO */
++ case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
++ /* TODO */
++ default:
++ mptsas_free_fw_event(ioc, fw_event);
++ break;
++ }
++}
+
+- expander_sas_address =
+- port_info->phy_info[0].identify.sas_address;
+
+- /*
+- * Delete rphys in the parent that point
+- * to this expander. The transport layer will
+- * cleanup all the children.
+- */
+- phy_info = parent->phy_info;
+- for (i = 0; i < parent->num_phys; i++, phy_info++) {
+- port = mptsas_get_port(phy_info);
+- if (!port)
+- continue;
+- if (phy_info->attached.sas_address !=
+- expander_sas_address)
+- continue;
+- dsaswideprintk(ioc,
+- dev_printk(KERN_DEBUG, &port->dev,
+- MYIOC_s_FMT "delete port (%d)\n", ioc->name,
+- port->port_identifier));
+- sas_port_delete(port);
+- mptsas_port_delete(ioc, phy_info->port_details);
+- }
+- next_port:
+-
+- phy_info = port_info->phy_info;
+- for (i = 0; i < port_info->num_phys; i++, phy_info++)
+- mptsas_port_delete(ioc, phy_info->port_details);
+-
+- list_del(&port_info->list);
+- kfree(port_info->phy_info);
+- kfree(port_info);
++/**
++ * mptsas_send_raid_event
++ *
++ *
++ * @ioc
++ * @raid_event_data
++ *
++ **/
++static void
++mptsas_send_raid_event(struct fw_event_work *fw_event)
++{
++ MPT_ADAPTER *ioc;
++ EVENT_DATA_RAID *raid_event_data;
++ struct mptsas_hotplug_event hot_plug_info;
++ int status;
++ int state;
++ struct scsi_device *sdev = NULL;
++ VirtDevice *vdevice = NULL;
++ RaidPhysDiskPage0_t phys_disk;
++
++ ioc = fw_event->ioc;
++ raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
++ status = le32_to_cpu(raid_event_data->SettingsStatus);
++ state = (status >> 8) & 0xff;
++
++ memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
++ hot_plug_info.id = raid_event_data->VolumeID;
++ hot_plug_info.channel = raid_event_data->VolumeBus;
++ hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
++
++ if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
++ raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
++ raid_event_data->ReasonCode ==
++ MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
++ sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
++ hot_plug_info.id, 0);
++ hot_plug_info.sdev = sdev;
++ if (sdev)
++ vdevice = sdev->hostdata;
++ }
++
++ devtprintk(ioc, printk(MYIOC_s_INFO_FMT "Entering %s: "
++ "ReasonCode=%02x\n", ioc->name, __FUNCTION__,
++ raid_event_data->ReasonCode));
++
++ switch (raid_event_data->ReasonCode) {
++ case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
++ hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
++ break;
++ case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
++ hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
++ break;
++ case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
++ switch (state) {
++ case MPI_PD_STATE_ONLINE:
++ case MPI_PD_STATE_NOT_COMPATIBLE:
++ mpt_raid_phys_disk_pg0(ioc,
++ raid_event_data->PhysDiskNum, &phys_disk);
++ hot_plug_info.id = phys_disk.PhysDiskID;
++ hot_plug_info.channel = phys_disk.PhysDiskBus;
++ hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
++ break;
++ case MPI_PD_STATE_FAILED:
++ case MPI_PD_STATE_MISSING:
++ case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
++ case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
++ case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
++ hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
++ break;
++ default:
++ break;
+ }
+- /*
+- * Free this memory allocated from inside
+- * mptsas_sas_expander_pg0
+- */
+- kfree(buffer.phy_info);
++ break;
++ case MPI_EVENT_RAID_RC_VOLUME_DELETED:
++ if (!sdev)
++ break;
++ vdevice->vtarget->deleted = 1; /* block IO */
++ hot_plug_info.event_type = MPTSAS_DEL_RAID;
++ break;
++ case MPI_EVENT_RAID_RC_VOLUME_CREATED:
++ if (sdev) {
++ scsi_device_put(sdev);
++ break;
++ }
++ hot_plug_info.event_type = MPTSAS_ADD_RAID;
++ break;
++ case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
++ if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
++ if (!sdev)
++ break;
++ vdevice->vtarget->deleted = 1; /* block IO */
++ hot_plug_info.event_type = MPTSAS_DEL_RAID;
++ break;
++ }
++ switch (state) {
++ case MPI_RAIDVOL0_STATUS_STATE_FAILED:
++ case MPI_RAIDVOL0_STATUS_STATE_MISSING:
++ if (!sdev)
++ break;
++ vdevice->vtarget->deleted = 1; /* block IO */
++ hot_plug_info.event_type = MPTSAS_DEL_RAID;
++ break;
++ case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
++ case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
++ if (sdev) {
++ scsi_device_put(sdev);
++ break;
++ }
++ hot_plug_info.event_type = MPTSAS_ADD_RAID;
++ break;
++ default:
++ break;
++ }
++ break;
++ default:
++ break;
+ }
+- mutex_unlock(&ioc->sas_topology_mutex);
++
++ if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
++ mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
++ else
++ mptsas_free_fw_event(ioc, fw_event);
+ }
+
+-/*
+- * Start of day discovery
+- */
+-static void
+-mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
++/**
++ * mptsas_issue_tm - send mptsas internal tm request
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @type
++ * @channel
++ * @id
++ * @lun
++ * @task_context
++ * @timeout
++ *
++ * return:
++ *
++ **/
++static int
++mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun, int task_context, ulong timeout,
++ u8 *issue_reset)
+ {
+- u32 handle = 0xFFFF;
+- int i;
++ MPT_FRAME_HDR *mf;
++ SCSITaskMgmt_t *pScsiTm;
++ int retval;
++ unsigned long timeleft;
+
+- mutex_lock(&ioc->sas_discovery_mutex);
+- mptsas_probe_hba_phys(ioc);
+- while (!mptsas_probe_expander_phys(ioc, &handle))
+- ;
+- /*
+- Reporting RAID volumes.
+- */
+- if (!ioc->ir_firmware)
++ *issue_reset = 0;
++ if ((mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc)) == NULL) {
++ retval = -1; /* return failure */
++ dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
++ "msg frames!!\n", ioc->name));
+ goto out;
+- if (!ioc->raid_data.pIocPg2)
++ }
++
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
++ "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
++ "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
++ type, timeout, channel, id, (unsigned long long)lun,
++ task_context));
++
++ pScsiTm = (SCSITaskMgmt_t *) mf;
++ memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
++ pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
++ pScsiTm->TaskType = type;
++ pScsiTm->MsgFlags = 0;
++ pScsiTm->TargetID = id;
++ pScsiTm->Bus = channel;
++ pScsiTm->ChainOffset = 0;
++ pScsiTm->Reserved = 0;
++ pScsiTm->Reserved1 = 0;
++ pScsiTm->TaskMsgContext = task_context;
++ int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
++
++ INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
++ retval = 0;
++ mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
++
++ /* Now wait for the command to complete */
++ timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
++ timeout*HZ);
++ if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ retval = -1; /* return failure */
++ dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
++ mpt_free_msg_frame(ioc, mf);
++ if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
++ goto out;
++ *issue_reset = 1;
+ goto out;
+- if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
++ }
++
++ if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
++ retval = -1; /* return failure */
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt request: failed with no reply\n", ioc->name));
+ goto out;
+- for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
+- scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
+- ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
+ }
++
+ out:
+- mutex_unlock(&ioc->sas_discovery_mutex);
++ CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ return retval;
+ }
+
+-/*
+- * Work queue thread to handle Runtime discovery
+- * Mere purpose is the hot add/delete of expanders
+- *(Mutex UNLOCKED)
+- */
++/**
++ * mptsas_broadcast_primative_work - Work queue thread to handle
++ * broadcast primitive events
++ * @work: work queue payload containing info describing the event
++ *
++ **/
+ static void
+-__mptsas_discovery_work(MPT_ADAPTER *ioc)
++mptsas_broadcast_primative_work(struct fw_event_work *fw_event)
+ {
+- u32 handle = 0xFFFF;
++ MPT_ADAPTER *ioc = fw_event->ioc;
++ MPT_FRAME_HDR *mf;
++ VirtDevice *vdevice;
++ int ii;
++ struct scsi_cmnd *sc;
++ SCSITaskMgmtReply_t * pScsiTmReply;
++ u8 issue_reset;
++ int task_context;
++ u8 channel, id;
++ int lun;
++ u32 termination_count;
++ u32 query_count;
++
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s - enter\n", ioc->name, __FUNCTION__));
++
++ mutex_lock(&ioc->taskmgmt_cmds.mutex);
++ if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ mptsas_requeue_fw_event(ioc, fw_event, 1000);
++ return;
++ }
+
+- ioc->sas_discovery_runtime=1;
+- mptsas_delete_expander_phys(ioc);
+- mptsas_probe_hba_phys(ioc);
+- while (!mptsas_probe_expander_phys(ioc, &handle))
+- ;
+- ioc->sas_discovery_runtime=0;
++ issue_reset = 0;
++ termination_count = 0;
++ query_count = 0;
++ mpt_findImVolumes(ioc);
++ pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
++
++ for (ii = 0; ii < ioc->req_depth; ii++) {
++ sc = mptscsih_get_scsi_lookup(ioc, ii);
++ if (!sc)
++ continue;
++ mf = MPT_INDEX_2_MFPTR(ioc, ii);
++ if (!mf)
++ continue;
++ task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
++ vdevice = sc->device->hostdata;
++ if (!vdevice || !vdevice->vtarget)
++ continue;
++ if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
++ continue; /* skip hidden raid components */
++ if (vdevice->vtarget->raidVolume)
++ continue; /* skip hidden raid components */
++ channel = vdevice->vtarget->channel;
++ id = vdevice->vtarget->id;
++ lun = vdevice->lun;
++ if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
++ channel, id, (u64)lun, task_context, 30, &issue_reset))
++ goto out;
++ query_count++;
++ termination_count +=
++ le32_to_cpu(pScsiTmReply->TerminationCount);
++ if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
++ (pScsiTmReply->ResponseCode ==
++ MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
++ pScsiTmReply->ResponseCode ==
++ MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
++ continue;
++ if (mptsas_issue_tm(ioc,
++ MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
++ channel, id, (u64)lun, 0, 30, &issue_reset))
++ goto out;
++ termination_count +=
++ le32_to_cpu(pScsiTmReply->TerminationCount);
++ }
++
++ out:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s - exit, query_count = %d termination_count = %d\n",
++ ioc->name, __FUNCTION__, query_count, termination_count));
++
++ ioc->broadcast_aen_busy = 0;
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++
++ if (issue_reset) {
++ printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
++ ioc->name, __FUNCTION__);
++ if (mpt_SoftResetHandler(ioc, CAN_SLEEP))
++ mpt_HardResetHandler(ioc, CAN_SLEEP);
++ }
++ mptsas_free_fw_event(ioc, fw_event);
+ }
+
+-/*
+- * Work queue thread to handle Runtime discovery
+- * Mere purpose is the hot add/delete of expanders
+- *(Mutex LOCKED)
+- */
++/**
++ * mptsas_send_ir2_event - handle exposing hidden disk when an inactive raid volume is added
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @ir2_data:
++ *
++ **/
+ static void
+-mptsas_discovery_work(struct work_struct *work)
++mptsas_send_ir2_event(struct fw_event_work *fw_event)
+ {
+- struct mptsas_discovery_event *ev =
+- container_of(work, struct mptsas_discovery_event, work);
+- MPT_ADAPTER *ioc = ev->ioc;
+-
+- mutex_lock(&ioc->sas_discovery_mutex);
+- __mptsas_discovery_work(ioc);
+- mutex_unlock(&ioc->sas_discovery_mutex);
+- kfree(ev);
++ MPT_ADAPTER *ioc;
++ struct mptsas_hotplug_event hot_plug_info;
++ MPI_EVENT_DATA_IR2 * ir2_data;
++ u8 reasonCode;
++ RaidPhysDiskPage0_t phys_disk;
++
++ ioc = fw_event->ioc;
++ ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
++ reasonCode = ir2_data->ReasonCode;
++
++ devtprintk(ioc, printk(MYIOC_s_INFO_FMT "Entering %s: "
++ "ReasonCode=%02x\n", ioc->name,__FUNCTION__, reasonCode));
++
++ memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
++ hot_plug_info.id = ir2_data->TargetID;
++ hot_plug_info.channel = ir2_data->Bus;
++ switch (reasonCode) {
++ case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
++ hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
++ break;
++ case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
++ hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
++ hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
++ break;
++ case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
++ hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
++ mpt_raid_phys_disk_pg0(ioc,
++ ir2_data->PhysDiskNum, &phys_disk);
++ hot_plug_info.id = phys_disk.PhysDiskID;
++ hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
++ break;
++ default:
++ mptsas_free_fw_event(ioc, fw_event);
++ return;
++ }
++ mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
+ }
+
+-static struct mptsas_phyinfo *
+-mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
++static void
++mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
+ {
+- struct mptsas_portinfo *port_info;
+- struct mptsas_phyinfo *phy_info = NULL;
+- int i;
++ struct mptsas_portinfo *parent;
++ struct device *parent_dev;
++ struct sas_rphy *rphy;
++ int i;
++ u64 sas_address; /* expander sas address */
++ u32 handle;
+
+- mutex_lock(&ioc->sas_topology_mutex);
+- list_for_each_entry(port_info, &ioc->sas_topology, list) {
+- for (i = 0; i < port_info->num_phys; i++) {
+- if (!mptsas_is_end_device(
+- &port_info->phy_info[i].attached))
+- continue;
+- if (port_info->phy_info[i].attached.sas_address
+- != sas_address)
+- continue;
+- phy_info = &port_info->phy_info[i];
+- break;
+- }
+- }
+- mutex_unlock(&ioc->sas_topology_mutex);
+- return phy_info;
+-}
++ handle = port_info->phy_info[0].handle;
++ sas_address = port_info->phy_info[0].identify.sas_address;
++ for (i = 0; i < port_info->num_phys; i++) {
++ mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
++ (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
++ MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
+
+-static struct mptsas_phyinfo *
+-mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u8 channel, u8 id)
+-{
+- struct mptsas_portinfo *port_info;
+- struct mptsas_phyinfo *phy_info = NULL;
+- int i;
++ mptsas_sas_device_pg0(ioc,
++ &port_info->phy_info[i].identify,
++ (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ port_info->phy_info[i].identify.handle);
++ port_info->phy_info[i].identify.phy_id =
++ port_info->phy_info[i].phy_id;
+
+- mutex_lock(&ioc->sas_topology_mutex);
+- list_for_each_entry(port_info, &ioc->sas_topology, list) {
+- for (i = 0; i < port_info->num_phys; i++) {
+- if (!mptsas_is_end_device(
+- &port_info->phy_info[i].attached))
+- continue;
+- if (port_info->phy_info[i].attached.id != id)
+- continue;
+- if (port_info->phy_info[i].attached.channel != channel)
+- continue;
+- phy_info = &port_info->phy_info[i];
+- break;
++ if (port_info->phy_info[i].attached.handle) {
++ mptsas_sas_device_pg0(ioc,
++ &port_info->phy_info[i].attached,
++ (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ port_info->phy_info[i].attached.handle);
++ port_info->phy_info[i].attached.phy_id =
++ port_info->phy_info[i].phy_id;
+ }
+ }
+- mutex_unlock(&ioc->sas_topology_mutex);
+- return phy_info;
+-}
+-
+-static struct mptsas_phyinfo *
+-mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
+-{
+- struct mptsas_portinfo *port_info;
+- struct mptsas_phyinfo *phy_info = NULL;
+- int i;
+
+ mutex_lock(&ioc->sas_topology_mutex);
+- list_for_each_entry(port_info, &ioc->sas_topology, list) {
+- for (i = 0; i < port_info->num_phys; i++) {
+- if (!mptsas_is_end_device(
+- &port_info->phy_info[i].attached))
+- continue;
+- if (port_info->phy_info[i].attached.phys_disk_num == ~0)
+- continue;
+- if (port_info->phy_info[i].attached.phys_disk_num != id)
+- continue;
+- if (port_info->phy_info[i].attached.channel != channel)
+- continue;
+- phy_info = &port_info->phy_info[i];
+- break;
++ parent = mptsas_find_portinfo_by_handle(ioc,
++ port_info->phy_info[0].identify.handle_parent);
++ if (!parent) {
++ mutex_unlock(&ioc->sas_topology_mutex);
++ return;
++ }
++ for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
++ i++) {
++ if (parent->phy_info[i].attached.sas_address == sas_address) {
++ rphy = mptsas_get_rphy(&parent->phy_info[i]);
++ parent_dev = &rphy->dev;
+ }
+ }
+ mutex_unlock(&ioc->sas_topology_mutex);
+- return phy_info;
++
++ mptsas_setup_wide_ports(ioc, port_info);
++ for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
++ mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
++ ioc->sas_index, 0);
+ }
+
+-/*
+- * Work queue thread to clear the persitency table
+- */
+ static void
+-mptsas_persist_clear_table(struct work_struct *work)
++mptsas_expander_event_add(MPT_ADAPTER *ioc,
++ MpiEventDataSasExpanderStatusChange_t* expander_data)
+ {
+- MPT_ADAPTER *ioc = container_of(work, MPT_ADAPTER, sas_persist_task);
++ struct mptsas_portinfo *port_info;
++ int i;
++ __le64 sas_address;
+
+- mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
+-}
++ port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
++ if (!port_info)
++ BUG();
++ port_info->num_phys = (expander_data->NumPhys) ?
++ expander_data->NumPhys : 1;
++ port_info->phy_info = kcalloc(port_info->num_phys,
++ sizeof(struct mptsas_phyinfo),GFP_KERNEL);
++ if (!port_info->phy_info)
++ BUG();
++ memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
++ for (i = 0; i < port_info->num_phys; i++) {
++ port_info->phy_info[i].portinfo = port_info;
++ port_info->phy_info[i].handle =
++ le16_to_cpu(expander_data->DevHandle);
++ port_info->phy_info[i].identify.sas_address =
++ le64_to_cpu(sas_address);
++ port_info->phy_info[i].identify.handle_parent =
++ le16_to_cpu(expander_data->ParentDevHandle);
++ }
+
+-static void
+-mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
+-{
+- int rc;
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_add_tail(&port_info->list, &ioc->sas_topology);
++ mutex_unlock(&ioc->sas_topology_mutex);
+
+- sdev->no_uld_attach = data ? 1 : 0;
+- rc = scsi_device_reprobe(sdev);
+-}
++ printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
++ "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
++ (unsigned long long)sas_address);
+
+-static void
+-mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
+-{
+- starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
+- mptsas_reprobe_lun);
++ mptsas_expander_refresh(ioc, port_info);
+ }
+
++/**
++ * mptsas_delete_expander_siblings - remove siblings attached to expander
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @parent: the parent port_info object
++ * @expander: the expander port_info object
++ **/
+ static void
+-mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
++mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
++ *parent, struct mptsas_portinfo *expander)
+ {
+- CONFIGPARMS cfg;
+- ConfigPageHeader_t hdr;
+- dma_addr_t dma_handle;
+- pRaidVolumePage0_t buffer = NULL;
+- RaidPhysDiskPage0_t phys_disk;
+- int i;
+- struct mptsas_hotplug_event *ev;
++ struct mptsas_phyinfo *phy_info;
++ struct mptsas_portinfo *port_info;
++ struct sas_rphy *rphy;
++ int i;
+
+- memset(&cfg, 0 , sizeof(CONFIGPARMS));
+- memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
+- hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
+- cfg.pageAddr = (channel << 8) + id;
+- cfg.cfghdr.hdr = &hdr;
+- cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
++ phy_info = expander->phy_info;
++ for (i = 0; i < expander->num_phys; i++, phy_info++) {
++ if (!(rphy = mptsas_get_rphy(phy_info)))
++ continue;
++ if (rphy->identify.device_type == SAS_END_DEVICE)
++ mptsas_del_end_device(ioc, phy_info);
++ }
+
+- if (mpt_config(ioc, &cfg) != 0)
+- goto out;
++ phy_info = expander->phy_info;
++ for (i = 0; i < expander->num_phys; i++, phy_info++) {
++ if (!(rphy = mptsas_get_rphy(phy_info)))
++ continue;
++ if (rphy->identify.device_type ==
++ MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
++ rphy->identify.device_type ==
++ MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
++ port_info = mptsas_find_portinfo_by_sas_address(ioc,
++ rphy->identify.sas_address);
++ if (!port_info)
++ continue;
++ if (port_info == parent) /* backlink rphy */
++ continue;
++ mptsas_expander_delete(ioc, port_info);
++ }
++ }
++}
+
+- if (!hdr.PageLength)
+- goto out;
+
+- buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
+- &dma_handle);
++/**
++ * mptsas_expander_delete - remove this expander
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @port_info: expander port_info struct
++ *
++ **/
+
+- if (!buffer)
+- goto out;
++static void
++mptsas_expander_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
++{
+
+- cfg.physAddr = dma_handle;
+- cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
++ struct mptsas_portinfo *parent;
++ int i;
++ u64 expander_sas_address;
++ struct mptsas_phyinfo *phy_info;
++ struct mptsas_portinfo buffer;
++ struct mptsas_portinfo_details * port_details;
++ struct sas_port * port;
+
+- if (mpt_config(ioc, &cfg) != 0)
+- goto out;
++ if (!port_info)
++ return;
+
+- if (!(buffer->VolumeStatus.Flags &
+- MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
+- goto out;
++ /* see if expander is still there before deleting */
++ mptsas_sas_expander_pg0(ioc, &buffer,
++ (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
++ MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
++ port_info->phy_info[0].identify.handle);
+
+- if (!buffer->NumPhysDisks)
+- goto out;
++ if (buffer.num_phys) {
++ kfree(buffer.phy_info);
++ return;
++ }
+
+- for (i = 0; i < buffer->NumPhysDisks; i++) {
+
+- if (mpt_raid_phys_disk_pg0(ioc,
+- buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
+- continue;
++ /*
++ * Obtain the port_info instance to the parent port
++ */
++ port_details = NULL;
++ expander_sas_address =
++ port_info->phy_info[0].identify.sas_address;
++ parent = mptsas_find_portinfo_by_handle(ioc,
++ port_info->phy_info[0].identify.handle_parent);
++ mptsas_delete_expander_siblings(ioc, parent, port_info);
++ if (!parent)
++ goto out;
+
+- ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+- if (!ev) {
+- printk(MYIOC_s_WARN_FMT "mptsas: lost hotplug event\n", ioc->name);
+- goto out;
++ /*
++ * Delete rphys in the parent that point
++ * to this expander.
++ */
++ phy_info = parent->phy_info;
++ port = NULL;
++ for (i = 0; i < parent->num_phys; i++, phy_info++) {
++ if(!phy_info->phy)
++ continue;
++ if (phy_info->attached.sas_address !=
++ expander_sas_address)
++ continue;
++ if (!port) {
++ port = mptsas_get_port(phy_info);
++ port_details = phy_info->port_details;
+ }
+-
+- INIT_WORK(&ev->work, mptsas_hotplug_work);
+- ev->ioc = ioc;
+- ev->id = phys_disk.PhysDiskID;
+- ev->channel = phys_disk.PhysDiskBus;
+- ev->phys_disk_num_valid = 1;
+- ev->phys_disk_num = phys_disk.PhysDiskNum;
+- ev->event_type = MPTSAS_ADD_DEVICE;
+- schedule_work(&ev->work);
++ dev_printk(KERN_DEBUG, &phy_info->phy->dev,
++ MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
++ phy_info->phy_id, phy_info->phy);
++ sas_port_delete_phy(port, phy_info->phy);
++ }
++ if (port) {
++ dev_printk(KERN_DEBUG, &port->dev,
++ MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
++ ioc->name, port->port_identifier,
++ (unsigned long long)expander_sas_address);
++ sas_port_delete(port);
++ mptsas_port_delete(ioc, port_details);
+ }
+-
+ out:
+- if (buffer)
+- pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
+- dma_handle);
++
++ printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
++ "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
++ (unsigned long long)expander_sas_address);
++
++ /*
++ * free link
++ */
++ list_del(&port_info->list);
++ kfree(port_info->phy_info);
++ kfree(port_info);
+ }
+-/*
+- * Work queue thread to handle SAS hotplug events
++
++
++/**
++ * mptsas_send_expander_event - expanders events
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @expander_data: event data
++ *
++ *
++ * This function handles adding, removing, and refreshing
++ * device handles within the expander objects.
+ */
+ static void
+-mptsas_hotplug_work(struct work_struct *work)
++mptsas_send_expander_event(struct fw_event_work *fw_event)
+ {
+- struct mptsas_hotplug_event *ev =
+- container_of(work, struct mptsas_hotplug_event, work);
++ MPT_ADAPTER *ioc;
++ MpiEventDataSasExpanderStatusChange_t* expander_data;
++ struct mptsas_portinfo *port_info;
++ __le64 sas_address;
++ int i;
+
+- MPT_ADAPTER *ioc = ev->ioc;
+- struct mptsas_phyinfo *phy_info;
+- struct sas_rphy *rphy;
+- struct sas_port *port;
+- struct scsi_device *sdev;
+- struct scsi_target * starget;
+- struct sas_identify identify;
+- char *ds = NULL;
+- struct mptsas_devinfo sas_device;
+- VirtTarget *vtarget;
+- VirtDevice *vdevice;
++ ioc = fw_event->ioc;
++ expander_data = (MpiEventDataSasExpanderStatusChange_t *)
++ fw_event->event_data;
++ memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
++ port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
++
++ if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
++ if (port_info) {
++ for (i = 0; i < port_info->num_phys; i++) {
++ port_info->phy_info[i].portinfo = port_info;
++ port_info->phy_info[i].handle =
++ le16_to_cpu(expander_data->DevHandle);
++ port_info->phy_info[i].identify.sas_address =
++ le64_to_cpu(sas_address);
++ port_info->phy_info[i].identify.handle_parent =
++ le16_to_cpu(expander_data->ParentDevHandle);
++ }
++ mptsas_expander_refresh(ioc, port_info);
++ } else if (!port_info && expander_data->NumPhys)
++ mptsas_expander_event_add(ioc, expander_data);
++ } else if (expander_data->ReasonCode ==
++ MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
++ mptsas_expander_delete(ioc, port_info);
+
+- mutex_lock(&ioc->sas_discovery_mutex);
+- switch (ev->event_type) {
+- case MPTSAS_DEL_DEVICE:
++ mptsas_free_fw_event(ioc, fw_event);
++}
+
+- phy_info = NULL;
+- if (ev->phys_disk_num_valid) {
+- if (ev->hidden_raid_component){
+- if (mptsas_sas_device_pg0(ioc, &sas_device,
+- (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
+- MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
+- (ev->channel << 8) + ev->id)) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
+- phy_info = mptsas_find_phyinfo_by_sas_address(
+- ioc, sas_device.sas_address);
+- }else
+- phy_info = mptsas_find_phyinfo_by_phys_disk_num(
+- ioc, ev->channel, ev->phys_disk_num);
+- }
+
+- if (!phy_info)
+- phy_info = mptsas_find_phyinfo_by_target(ioc,
+- ev->channel, ev->id);
++/**
++ * mptsas_expander_add -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @handle:
++ *
++ */
++struct mptsas_portinfo *
++mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
++{
++ struct mptsas_portinfo buffer, *port_info;
++ int i;
+
+- /*
+- * Sanity checks, for non-existing phys and remote rphys.
+- */
+- if (!phy_info){
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
+- if (!phy_info->port_details) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
+- rphy = mptsas_get_rphy(phy_info);
+- if (!rphy) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
++ if ((mptsas_sas_expander_pg0(ioc, &buffer,
++ (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
++ MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
++ return NULL;
+
+- port = mptsas_get_port(phy_info);
+- if (!port) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
++ port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_ATOMIC);
++ if (!port_info) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: exit at line=%d\n", ioc->name,
++ __FUNCTION__, __LINE__));
++ return NULL;
++ }
++ port_info->num_phys = buffer.num_phys;
++ port_info->phy_info = buffer.phy_info;
++ for (i = 0; i < port_info->num_phys; i++)
++ port_info->phy_info[i].portinfo = port_info;
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_add_tail(&port_info->list, &ioc->sas_topology);
++ mutex_unlock(&ioc->sas_topology_mutex);
++ printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
++ "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
++ (unsigned long long)buffer.phy_info[0].identify.sas_address);
++ mptsas_expander_refresh(ioc, port_info);
++ return port_info;
++}
+
+- starget = mptsas_get_starget(phy_info);
+- if (starget) {
+- vtarget = starget->hostdata;
++static void
++mptsas_send_link_status_event(struct fw_event_work *fw_event)
++{
++ MPT_ADAPTER *ioc;
++ MpiEventDataSasPhyLinkStatus_t *link_data;
++ struct mptsas_portinfo *port_info;
++ struct mptsas_phyinfo *phy_info = NULL;
++ __le64 sas_address;
++ u8 phy_num;
++ u8 link_rate;
+
+- if (!vtarget) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
++ ioc = fw_event->ioc;
++ link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
+
+- /*
+- * Handling RAID components
+- */
+- if (ev->phys_disk_num_valid &&
+- ev->hidden_raid_component) {
+- printk(MYIOC_s_INFO_FMT
+- "RAID Hidding: channel=%d, id=%d, "
+- "physdsk %d \n", ioc->name, ev->channel,
+- ev->id, ev->phys_disk_num);
+- vtarget->id = ev->phys_disk_num;
+- vtarget->tflags |=
+- MPT_TARGET_FLAGS_RAID_COMPONENT;
+- mptsas_reprobe_target(starget, 1);
+- phy_info->attached.phys_disk_num =
+- ev->phys_disk_num;
+- break;
++ memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
++ sas_address = le64_to_cpu(sas_address);
++ link_rate = link_data->LinkRates >> 4;
++ phy_num = link_data->PhyNum;
++
++ port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
++ if (port_info) {
++ phy_info = &port_info->phy_info[phy_num];
++ if (phy_info)
++ phy_info->negotiated_link_rate = link_rate;
++ }
++
++ if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
++ link_rate == MPI_SAS_IOUNIT0_RATE_3_0) {
++
++ if (!port_info) {
++ if (ioc->old_sas_discovery_protocal) {
++ port_info = mptsas_expander_add(ioc,
++ le16_to_cpu(link_data->DevHandle));
++ if (port_info)
++ goto out;
+ }
++ goto out;
+ }
++ if (port_info == ioc->hba_port_info)
++ mptsas_probe_hba_phys(ioc);
++ else
++ mptsas_expander_refresh(ioc, port_info);
++ } else if (phy_info && phy_info->phy) {
++ if (link_rate == MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
++ phy_info->phy->negotiated_linkrate =
++ SAS_PHY_DISABLED;
++ else if (link_rate ==
++ MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
++ phy_info->phy->negotiated_linkrate =
++ SAS_LINK_RATE_FAILED;
++ else
++ phy_info->phy->negotiated_linkrate =
++ SAS_LINK_RATE_UNKNOWN;
++ }
++ out:
++ mptsas_free_fw_event(ioc, fw_event);
++}
+
+- if (phy_info->attached.device_info &
+- MPI_SAS_DEVICE_INFO_SSP_TARGET)
+- ds = "ssp";
+- if (phy_info->attached.device_info &
+- MPI_SAS_DEVICE_INFO_STP_TARGET)
+- ds = "stp";
+- if (phy_info->attached.device_info &
+- MPI_SAS_DEVICE_INFO_SATA_DEVICE)
+- ds = "sata";
+-
+- printk(MYIOC_s_INFO_FMT
+- "removing %s device, channel %d, id %d, phy %d\n",
+- ioc->name, ds, ev->channel, ev->id, phy_info->phy_id);
+- dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
+- "delete port (%d)\n", ioc->name, port->port_identifier);
+- sas_port_delete(port);
+- mptsas_port_delete(ioc, phy_info->port_details);
+- break;
+- case MPTSAS_ADD_DEVICE:
+-
+- if (ev->phys_disk_num_valid)
+- mpt_findImVolumes(ioc);
+
+- /*
+- * Refresh sas device pg0 data
+- */
+- if (mptsas_sas_device_pg0(ioc, &sas_device,
+- (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
+- MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
+- (ev->channel << 8) + ev->id)) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
++static void
++mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
++{
++ MPT_ADAPTER *ioc;
++ EventDataQueueFull_t *qfull_data;
++ struct sas_device_info *sas_info;
++ struct scsi_device *sdev;
++ int depth;
++ int id = -1;
++ int channel = -1;
++ int fw_id, fw_channel;
++ u16 current_depth;
++
++
++ ioc = fw_event->ioc;
++ qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
++ fw_id = qfull_data->TargetID;
++ fw_channel = qfull_data->Bus;
++ current_depth = le16_to_cpu(qfull_data->CurrentDepth);
++
++ /* if hidden raid component, look for the volume id */
++ down(&ioc->sas_device_info_mutex);
++ if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
++ list_for_each_entry(sas_info, &ioc->sas_device_info_list,
++ list) {
++ if (sas_info->is_cached ||
++ sas_info->is_logical_volume)
++ continue;
++ if (sas_info->is_hidden_raid_component &&
++ (sas_info->fw.channel == fw_channel &&
++ sas_info->fw.id == fw_id)) {
++ id = sas_info->volume_id;
++ channel = MPTSAS_RAID_CHANNEL;
++ goto out;
++ }
+ }
+-
+- __mptsas_discovery_work(ioc);
+-
+- phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
+- sas_device.sas_address);
+-
+- if (!phy_info || !phy_info->port_details) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
++ } else {
++ list_for_each_entry(sas_info, &ioc->sas_device_info_list,
++ list) {
++ if (sas_info->is_cached ||
++ sas_info->is_hidden_raid_component ||
++ sas_info->is_logical_volume)
++ continue;
++ if (sas_info->fw.channel == fw_channel &&
++ sas_info->fw.id == fw_id) {
++ id = sas_info->os.id;
++ channel = sas_info->os.channel;
++ goto out;
++ }
+ }
+
+- starget = mptsas_get_starget(phy_info);
+- if (starget && (!ev->hidden_raid_component)){
+-
+- vtarget = starget->hostdata;
++ }
+
+- if (!vtarget) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
+- /*
+- * Handling RAID components
+- */
+- if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
+- printk(MYIOC_s_INFO_FMT
+- "RAID Exposing: channel=%d, id=%d, "
+- "physdsk %d \n", ioc->name, ev->channel,
+- ev->id, ev->phys_disk_num);
+- vtarget->tflags &=
+- ~MPT_TARGET_FLAGS_RAID_COMPONENT;
+- vtarget->id = ev->id;
+- mptsas_reprobe_target(starget, 0);
+- phy_info->attached.phys_disk_num = ~0;
++ out:
++ up(&ioc->sas_device_info_mutex);
++
++ if (id != -1) {
++ shost_for_each_device(sdev, ioc->sh) {
++ if (sdev->id == id && sdev->channel == channel) {
++ if (current_depth > sdev->queue_depth) {
++ sdev_printk(KERN_INFO, sdev,
++ "strange observation, the queue "
++ "depth is (%d) meanwhile fw queue "
++ "depth (%d)\n", sdev->queue_depth,
++ current_depth);
++ continue;
++ }
++ depth = scsi_track_queue_full(sdev,
++ current_depth - 1);
++ if (depth > 0)
++ sdev_printk(KERN_INFO, sdev,
++ "Queue depth reduced to (%d)\n",
++ depth);
++ else if (depth < 0)
++ sdev_printk(KERN_INFO, sdev,
++ "Tagged Command Queueing is being "
++ "disabled\n");
++ else if (depth == 0)
++ sdev_printk(KERN_INFO, sdev,
++ "Queue depth not changed yet\n");
+ }
+- break;
+ }
++ }
+
+- if (mptsas_get_rphy(phy_info)) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- if (ev->channel) printk("%d\n", __LINE__);
+- break;
+- }
++ mptsas_free_fw_event(ioc, fw_event);
++}
+
+- port = mptsas_get_port(phy_info);
+- if (!port) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break;
+- }
+- memcpy(&phy_info->attached, &sas_device,
+- sizeof(struct mptsas_devinfo));
++/**
++ * mptsas_firmware_event_work - work thread for processing fw events
++ * @work: work queue payload containing info describing the event
++ * Context: user
++ *
++ */
++static void
++mptsas_firmware_event_work(struct work_struct *work)
++{
++ struct fw_event_work *fw_event =
++ container_of(work, struct fw_event_work, work.work);
++ MPT_ADAPTER *ioc = fw_event->ioc;
++
++ /* special rescan topology handling */
++ if (fw_event->event == -1) {
++ devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: rescan after "
++ "reset\n", ioc->name,__FUNCTION__));
++ mptsas_not_responding_devices(ioc);
++ mptsas_scan_sas_topology(ioc);
++ mptsas_free_fw_event(ioc, fw_event);
++ return;
++ }
+
+- if (phy_info->attached.device_info &
+- MPI_SAS_DEVICE_INFO_SSP_TARGET)
+- ds = "ssp";
+- if (phy_info->attached.device_info &
+- MPI_SAS_DEVICE_INFO_STP_TARGET)
+- ds = "stp";
+- if (phy_info->attached.device_info &
+- MPI_SAS_DEVICE_INFO_SATA_DEVICE)
+- ds = "sata";
+-
+- printk(MYIOC_s_INFO_FMT
+- "attaching %s device, channel %d, id %d, phy %d\n",
+- ioc->name, ds, ev->channel, ev->id, ev->phy_id);
++ /* events handling turned off during host reset */
++ if (ioc->fw_events_off) {
++ mptsas_free_fw_event(ioc, fw_event);
++ return;
++ }
+
+- mptsas_parse_device_info(&identify, &phy_info->attached);
+- rphy = sas_end_device_alloc(port);
+- if (!rphy) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- break; /* non-fatal: an rphy can be added later */
+- }
++ devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: fw_event=(0x%p), "
++ "event = (0x%02x)\n", ioc->name,__FUNCTION__, fw_event,
++ (fw_event->event & 0xFF)));
+
+- rphy->identify = identify;
+- if (sas_rphy_add(rphy)) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
+- "%s: exit at line=%d\n", ioc->name,
+- __func__, __LINE__));
+- sas_rphy_free(rphy);
+- break;
+- }
+- mptsas_set_rphy(ioc, phy_info, rphy);
++ switch (fw_event->event) {
++ case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
++ mptsas_send_sas_event(fw_event);
+ break;
+- case MPTSAS_ADD_RAID:
+- sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
+- ev->id, 0);
+- if (sdev) {
+- scsi_device_put(sdev);
+- break;
+- }
+- printk(MYIOC_s_INFO_FMT
+- "attaching raid volume, channel %d, id %d\n",
+- ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
+- scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, ev->id, 0);
+- mpt_findImVolumes(ioc);
++ case MPI_EVENT_INTEGRATED_RAID:
++ mptsas_send_raid_event(fw_event);
+ break;
+- case MPTSAS_DEL_RAID:
+- sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
+- ev->id, 0);
+- if (!sdev)
+- break;
+- printk(MYIOC_s_INFO_FMT
+- "removing raid volume, channel %d, id %d\n",
+- ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
+- vdevice = sdev->hostdata;
+- scsi_remove_device(sdev);
+- scsi_device_put(sdev);
+- mpt_findImVolumes(ioc);
++ case MPI_EVENT_IR2:
++ mptsas_send_ir2_event(fw_event);
+ break;
+- case MPTSAS_ADD_INACTIVE_VOLUME:
+- mptsas_adding_inactive_raid_components(ioc,
+- ev->channel, ev->id);
++ case MPI_EVENT_PERSISTENT_TABLE_FULL:
++ mptbase_sas_persist_operation(ioc,
++ MPI_SAS_OP_CLEAR_NOT_PRESENT);
++ mptsas_free_fw_event(ioc, fw_event);
+ break;
+- case MPTSAS_IGNORE_EVENT:
+- default:
++ case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
++ mptsas_broadcast_primative_work(fw_event);
++ break;
++ case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
++ mptsas_send_expander_event(fw_event);
++ break;
++ case MPI_EVENT_SAS_PHY_LINK_STATUS:
++ mptsas_send_link_status_event(fw_event);
++ break;
++ case MPI_EVENT_QUEUE_FULL:
++ mptsas_handle_queue_full_event(fw_event);
+ break;
+ }
+-
+- mutex_unlock(&ioc->sas_discovery_mutex);
+- kfree(ev);
+ }
+
+-static void
+-mptsas_send_sas_event(MPT_ADAPTER *ioc,
+- EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
+-{
+- struct mptsas_hotplug_event *ev;
+- u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
+- __le64 sas_address;
+
+- if ((device_info &
+- (MPI_SAS_DEVICE_INFO_SSP_TARGET |
+- MPI_SAS_DEVICE_INFO_STP_TARGET |
+- MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
+- return;
++/**
++ * mptsas_event_process -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @reply:
++ *
++ **/
++static int
++mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
++{
++ u32 event = le32_to_cpu(reply->Event);
++ int sz, event_data_sz;
++ struct fw_event_work *fw_event;
++ unsigned long delay;
+
+- switch (sas_event_data->ReasonCode) {
+- case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
++ /* events turned off due to host reset or driver unloading */
++ if (ioc->fw_events_off)
++ return 0;
+
+- mptsas_target_reset_queue(ioc, sas_event_data);
++ delay = msecs_to_jiffies(1);
++ switch (event) {
++ case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
++ {
++ EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
++ (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
++ if (broadcast_event_data->Primitive !=
++ MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
++ return 0;
++ if (ioc->broadcast_aen_busy)
++ return 0;
++ ioc->broadcast_aen_busy = 1;
+ break;
++ }
++ case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
++ {
++ EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
++ (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
+
+- case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
+- ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+- if (!ev) {
+- printk(MYIOC_s_WARN_FMT "lost hotplug event\n", ioc->name);
+- break;
++ if (sas_event_data->ReasonCode ==
++ MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
++ mptsas_target_reset_queue(ioc, sas_event_data);
++ return 0;
+ }
++ break;
++ }
++ case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
++ {
++ MpiEventDataSasExpanderStatusChange_t *expander_data =
++ (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
+
+- INIT_WORK(&ev->work, mptsas_hotplug_work);
+- ev->ioc = ioc;
+- ev->handle = le16_to_cpu(sas_event_data->DevHandle);
+- ev->parent_handle =
+- le16_to_cpu(sas_event_data->ParentDevHandle);
+- ev->channel = sas_event_data->Bus;
+- ev->id = sas_event_data->TargetID;
+- ev->phy_id = sas_event_data->PhyNum;
+- memcpy(&sas_address, &sas_event_data->SASAddress,
+- sizeof(__le64));
+- ev->sas_address = le64_to_cpu(sas_address);
+- ev->device_info = device_info;
++ if (ioc->old_sas_discovery_protocal)
++ return 0;
+
+- if (sas_event_data->ReasonCode &
+- MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
+- ev->event_type = MPTSAS_ADD_DEVICE;
+- else
+- ev->event_type = MPTSAS_DEL_DEVICE;
+- schedule_work(&ev->work);
++ if (expander_data->ReasonCode ==
++ MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
++ ioc->device_missing_delay)
++ delay = HZ * ioc->device_missing_delay;
+ break;
+- case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
+- /*
+- * Persistent table is full.
+- */
+- INIT_WORK(&ioc->sas_persist_task,
+- mptsas_persist_clear_table);
+- schedule_work(&ioc->sas_persist_task);
++ }
++ case MPI_EVENT_SAS_DISCOVERY:
++ {
++ u32 discovery_status;
++ EventDataSasDiscovery_t *discovery_data =
++ (EventDataSasDiscovery_t *)reply->Data;
++
++ discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
++ ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
++ if (ioc->old_sas_discovery_protocal && !discovery_status)
++ mptsas_queue_rescan(ioc);
++ return 0;
++ }
++ case MPI_EVENT_INTEGRATED_RAID:
++ case MPI_EVENT_PERSISTENT_TABLE_FULL:
++ case MPI_EVENT_IR2:
++ case MPI_EVENT_SAS_PHY_LINK_STATUS:
++ case MPI_EVENT_QUEUE_FULL:
+ break;
+- /*
+- * TODO, handle other events
+- */
+- case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
+- case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
+- case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
+- case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
+- case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
+- case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
+- case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
+ default:
+- break;
++ return 0;
+ }
++
++ event_data_sz = ((reply->MsgLength * 4) -
++ offsetof(EventNotificationReply_t, Data));
++ sz = offsetof(struct fw_event_work, event_data) + event_data_sz;
++ fw_event = kzalloc(sz, GFP_ATOMIC);
++ if (!fw_event) {
++ printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
++ __FUNCTION__, __LINE__);
++ return 0;
++ }
++ memcpy(fw_event->event_data, reply->Data, event_data_sz);
++ fw_event->event = event;
++ fw_event->ioc = ioc;
++ mptsas_add_fw_event(ioc, fw_event, delay);
++ return 0;
+ }
+-static void
+-mptsas_send_raid_event(MPT_ADAPTER *ioc,
+- EVENT_DATA_RAID *raid_event_data)
++
++
++/* Delete a volume when no longer listed in ioc pg2
++ */
++static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
+ {
+- struct mptsas_hotplug_event *ev;
+- int status = le32_to_cpu(raid_event_data->SettingsStatus);
+- int state = (status >> 8) & 0xff;
++ struct scsi_device *sdev;
++ int i;
+
+- if (ioc->bus_type != SAS)
++ sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
++ if (!sdev)
+ return;
++ if (!ioc->raid_data.pIocPg2)
++ goto out;
++ if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
++ goto out;
++ for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
++ if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
++ goto release_sdev;
++ out:
++ printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
++ "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,id);
++ scsi_remove_device(sdev);
++ release_sdev:
++ scsi_device_put(sdev);
++}
++
++static void
++mptsas_not_responding_devices(MPT_ADAPTER *ioc)
++{
++ struct mptsas_portinfo buffer, *port_info;
++ struct sas_device_info *sas_info;
++ struct mptsas_devinfo sas_device;
++ u32 handle;
++ VirtTarget *vtarget = NULL;
++ struct mptsas_phyinfo *phy_info;
++ u8 found_expander;
+
+- ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+- if (!ev) {
+- printk(MYIOC_s_WARN_FMT "lost hotplug event\n", ioc->name);
++ if (ioc->disable_hotplug_remove)
+ return;
++
++ mpt_findImVolumes(ioc);
++
++ /* devices, logical volumes */
++ redo_device_scan:
++ list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
++ if (sas_info->is_cached)
++ continue;
++ if (!sas_info->is_logical_volume) {
++ sas_device.handle = 0;
++ mptsas_sas_device_pg0(ioc, &sas_device,
++ (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
++ MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
++ (sas_info->fw.channel << 8) +
++ sas_info->fw.id);
++ if (sas_device.handle)
++ continue;
++ /* delete device */
++ if ((vtarget = mptsas_find_vtarget(ioc,
++ sas_info->fw.channel,
++ sas_info->fw.id)))
++ vtarget->deleted = 1;
++ phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
++ sas_info->sas_address);
++ if (phy_info) {
++ mptsas_del_end_device(ioc, phy_info);
++ goto redo_device_scan;
++ }
++ } else
++ mptsas_volume_delete(ioc, sas_info->fw.id);
+ }
+
+- INIT_WORK(&ev->work, mptsas_hotplug_work);
+- ev->ioc = ioc;
+- ev->id = raid_event_data->VolumeID;
+- ev->channel = raid_event_data->VolumeBus;
+- ev->event_type = MPTSAS_IGNORE_EVENT;
++ /* expanders */
++ redo_expander_scan:
++ list_for_each_entry(port_info, &ioc->sas_topology, list) {
+
+- switch (raid_event_data->ReasonCode) {
+- case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
+- ev->phys_disk_num_valid = 1;
+- ev->phys_disk_num = raid_event_data->PhysDiskNum;
+- ev->event_type = MPTSAS_ADD_DEVICE;
+- break;
+- case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
+- ev->phys_disk_num_valid = 1;
+- ev->phys_disk_num = raid_event_data->PhysDiskNum;
+- ev->hidden_raid_component = 1;
+- ev->event_type = MPTSAS_DEL_DEVICE;
+- break;
+- case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
+- switch (state) {
+- case MPI_PD_STATE_ONLINE:
+- case MPI_PD_STATE_NOT_COMPATIBLE:
+- ev->phys_disk_num_valid = 1;
+- ev->phys_disk_num = raid_event_data->PhysDiskNum;
+- ev->hidden_raid_component = 1;
+- ev->event_type = MPTSAS_ADD_DEVICE;
+- break;
+- case MPI_PD_STATE_MISSING:
+- case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
+- case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
+- case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
+- ev->phys_disk_num_valid = 1;
+- ev->phys_disk_num = raid_event_data->PhysDiskNum;
+- ev->event_type = MPTSAS_DEL_DEVICE;
+- break;
+- default:
+- break;
++ if (port_info->phy_info &&
++ (!(port_info->phy_info[0].identify.device_info &
++ MPI_SAS_DEVICE_INFO_SMP_TARGET)))
++ continue;
++ found_expander = 0;
++ handle = 0xFFFF;
++ while (!mptsas_sas_expander_pg0(ioc, &buffer,
++ (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
++ MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
++ !found_expander) {
++
++ handle = buffer.phy_info[0].handle;
++ if (buffer.phy_info[0].identify.sas_address ==
++ port_info->phy_info[0].identify.sas_address) {
++ found_expander = 1;
++ }
++ kfree(buffer.phy_info);
+ }
+- break;
+- case MPI_EVENT_RAID_RC_VOLUME_DELETED:
+- ev->event_type = MPTSAS_DEL_RAID;
+- break;
+- case MPI_EVENT_RAID_RC_VOLUME_CREATED:
+- ev->event_type = MPTSAS_ADD_RAID;
+- break;
+- case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
+- switch (state) {
+- case MPI_RAIDVOL0_STATUS_STATE_FAILED:
+- case MPI_RAIDVOL0_STATUS_STATE_MISSING:
+- ev->event_type = MPTSAS_DEL_RAID;
+- break;
+- case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
+- case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
+- ev->event_type = MPTSAS_ADD_RAID;
+- break;
+- default:
+- break;
++
++ if (!found_expander) {
++ mptsas_expander_delete(ioc, port_info);
++ goto redo_expander_scan;
+ }
+- break;
+- default:
+- break;
+ }
+- schedule_work(&ev->work);
+ }
+
++/**
++ * mptsas_probe_expanders - adding expanders
++ * @ioc: Pointer to MPT_ADAPTER structure
++ *
++ **/
+ static void
+-mptsas_send_discovery_event(MPT_ADAPTER *ioc,
+- EVENT_DATA_SAS_DISCOVERY *discovery_data)
++mptsas_probe_expanders(MPT_ADAPTER *ioc)
+ {
+- struct mptsas_discovery_event *ev;
++ struct mptsas_portinfo buffer, *port_info;
++ u32 handle;
++ int i;
+
+- /*
+- * DiscoveryStatus
+- *
+- * This flag will be non-zero when firmware
+- * kicks off discovery, and return to zero
+- * once its completed.
+- */
+- if (discovery_data->DiscoveryStatus)
+- return;
++ handle = 0xFFFF;
++ while (!mptsas_sas_expander_pg0(ioc, &buffer,
++ (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
++ MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
+
+- ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+- if (!ev)
+- return;
+- INIT_WORK(&ev->work, mptsas_discovery_work);
+- ev->ioc = ioc;
+- schedule_work(&ev->work);
+-};
++ handle = buffer.phy_info[0].handle;
++ port_info = mptsas_find_portinfo_by_sas_address(ioc,
++ buffer.phy_info[0].identify.sas_address);
++
++ if (port_info) {
++ /* refreshing handles */
++ for (i = 0; i < buffer.num_phys; i++) {
++ port_info->phy_info[i].handle = handle;
++ port_info->phy_info[i].identify.handle_parent =
++ buffer.phy_info[0].identify.handle_parent;
++ }
++ mptsas_expander_refresh(ioc, port_info);
++ kfree(buffer.phy_info);
++ continue;
++ }
++
++ port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
++ if (!port_info) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "%s: exit at line=%d\n", ioc->name,
++ __FUNCTION__, __LINE__));
++ return;
++ }
++ port_info->num_phys = buffer.num_phys;
++ port_info->phy_info = buffer.phy_info;
++ for (i = 0; i < port_info->num_phys; i++)
++ port_info->phy_info[i].portinfo = port_info;
++ mutex_lock(&ioc->sas_topology_mutex);
++ list_add_tail(&port_info->list, &ioc->sas_topology);
++ mutex_unlock(&ioc->sas_topology_mutex);
++ printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
++ "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
++ (unsigned long long)buffer.phy_info[0].identify.sas_address);
++ mptsas_expander_refresh(ioc, port_info);
++ }
++}
+
+-/*
+- * mptsas_send_ir2_event - handle exposing hidden disk when
+- * an inactive raid volume is added
+- *
+- * @ioc: Pointer to MPT_ADAPTER structure
+- * @ir2_data
+- *
+- */
+ static void
+-mptsas_send_ir2_event(MPT_ADAPTER *ioc, PTR_MPI_EVENT_DATA_IR2 ir2_data)
++mptsas_probe_devices(MPT_ADAPTER *ioc)
+ {
+- struct mptsas_hotplug_event *ev;
++ u16 retry_count;
++ u16 handle;
++ struct mptsas_devinfo sas_device;
++ struct mptsas_phyinfo *phy_info;
++ enum device_state state;
+
+- if (ir2_data->ReasonCode !=
+- MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED)
+- return;
++ handle = 0xFFFF;
++ while (!(mptsas_sas_device_pg0(ioc, &sas_device,
++ MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
++
++ handle = sas_device.handle;
++
++ if ((sas_device.device_info &
++ (MPI_SAS_DEVICE_INFO_SSP_TARGET |
++ MPI_SAS_DEVICE_INFO_STP_TARGET |
++ MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
++ continue;
+
+- ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+- if (!ev)
+- return;
++ phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
++ if (!phy_info)
++ continue;
+
+- INIT_WORK(&ev->work, mptsas_hotplug_work);
+- ev->ioc = ioc;
+- ev->id = ir2_data->TargetID;
+- ev->channel = ir2_data->Bus;
+- ev->event_type = MPTSAS_ADD_INACTIVE_VOLUME;
++ if (mptsas_get_rphy(phy_info))
++ continue;
+
+- schedule_work(&ev->work);
+-};
++ state = DEVICE_RETRY;
++ retry_count = 0;
++ while(state == DEVICE_RETRY) {
++ state = mptsas_test_unit_ready(ioc, sas_device.channel,
++ sas_device.id, retry_count++);
++ ssleep(1);
++ }
++ if (state == DEVICE_READY)
++ mptsas_add_end_device(ioc, phy_info);
++ }
++}
+
+-static int
+-mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
++/**
++ * mptsas_scan_sas_topology -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @sas_address:
++ *
++ **/
++static void
++mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
+ {
+- int rc=1;
+- u8 event = le32_to_cpu(reply->Event) & 0xFF;
++ struct scsi_device *sdev;
++ int i;
+
+- if (!ioc->sh)
+- goto out;
++ mptsas_probe_hba_phys(ioc);
++ mptsas_probe_expanders(ioc);
++ mptsas_probe_devices(ioc);
+
+ /*
+- * sas_discovery_ignore_events
+- *
+- * This flag is to prevent anymore processing of
+- * sas events once mptsas_remove function is called.
+- */
+- if (ioc->sas_discovery_ignore_events) {
+- rc = mptscsih_event_process(ioc, reply);
+- goto out;
+- }
+-
+- switch (event) {
+- case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
+- mptsas_send_sas_event(ioc,
+- (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
+- break;
+- case MPI_EVENT_INTEGRATED_RAID:
+- mptsas_send_raid_event(ioc,
+- (EVENT_DATA_RAID *)reply->Data);
+- break;
+- case MPI_EVENT_PERSISTENT_TABLE_FULL:
+- INIT_WORK(&ioc->sas_persist_task,
+- mptsas_persist_clear_table);
+- schedule_work(&ioc->sas_persist_task);
+- break;
+- case MPI_EVENT_SAS_DISCOVERY:
+- mptsas_send_discovery_event(ioc,
+- (EVENT_DATA_SAS_DISCOVERY *)reply->Data);
+- break;
+- case MPI_EVENT_IR2:
+- mptsas_send_ir2_event(ioc,
+- (PTR_MPI_EVENT_DATA_IR2)reply->Data);
+- break;
+- default:
+- rc = mptscsih_event_process(ioc, reply);
+- break;
++ Reporting RAID volumes.
++ */
++ if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
++ !ioc->raid_data.pIocPg2->NumActiveVolumes)
++ return;
++ for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
++ if ((sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
++ ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0))) {
++ scsi_device_put(sdev);
++ continue;
++ }
++ printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
++ "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
++ ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
++ scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
++ ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
+ }
+- out:
+-
+- return rc;
+ }
+
++/**
++ * mptsas_probe -
++ * @pdev:
++ * @id:
++ *
++ **/
+ static int
+ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+ {
+@@ -3129,6 +5071,7 @@ mptsas_probe(struct pci_dev *pdev, const
+ return r;
+
+ ioc = pci_get_drvdata(pdev);
++ mptsas_fw_event_off(ioc);
+ ioc->DoneCtx = mptsasDoneCtx;
+ ioc->TaskCtx = mptsasTaskCtx;
+ ioc->InternalCtx = mptsasInternalCtx;
+@@ -3173,7 +5116,7 @@ mptsas_probe(struct pci_dev *pdev, const
+ ioc->name);
+ error = -1;
+ goto out_mptsas_probe;
+- }
++ }
+
+ spin_lock_irqsave(&ioc->FreeQlock, flags);
+
+@@ -3187,10 +5130,9 @@ mptsas_probe(struct pci_dev *pdev, const
+
+ /* set 16 byte cdb's */
+ sh->max_cmd_len = 16;
+-
++ sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
+ sh->max_id = ioc->pfacts[0].PortSCSIID;
+ sh->max_lun = max_lun;
+-
+ sh->transportt = mptsas_transport_template;
+
+ /* Required entry.
+@@ -3199,10 +5141,10 @@ mptsas_probe(struct pci_dev *pdev, const
+
+ INIT_LIST_HEAD(&ioc->sas_topology);
+ mutex_init(&ioc->sas_topology_mutex);
+- mutex_init(&ioc->sas_discovery_mutex);
+ mutex_init(&ioc->sas_mgmt.mutex);
+ init_completion(&ioc->sas_mgmt.done);
+
++
+ /* Verify that we won't exceed the maximum
+ * number of chain buffers
+ * We can optimize: ZZ = req_sz/sizeof(SGE)
+@@ -3212,17 +5154,16 @@ mptsas_probe(struct pci_dev *pdev, const
+ * A slightly different algorithm is required for
+ * 64bit SGEs.
+ */
+- scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
++
++ scale = ioc->req_sz/ioc->SGE_size;
++ if (ioc->sg_addr_size == sizeof(u64)) {
+ numSGE = (scale - 1) *
+ (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
+- sizeof(u32));
++ (ioc->req_sz - 60) / ioc->SGE_size;
+ } else {
+ numSGE = 1 + (scale - 1) *
+ (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
+- sizeof(u32));
++ (ioc->req_sz - 64) / ioc->SGE_size;
+ }
+
+ if (numSGE < sh->sg_tablesize) {
+@@ -3250,34 +5191,17 @@ mptsas_probe(struct pci_dev *pdev, const
+ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
+ ioc->name, ioc->ScsiLookup));
+
+- /* Clear the TM flags
+- */
+- hd->tmPending = 0;
+- hd->tmState = TM_STATE_NONE;
+- hd->resetPending = 0;
+- hd->abortSCpnt = NULL;
+-
+- /* Clear the pointer used to store
+- * single-threaded commands, i.e., those
+- * issued during a bus scan, dv and
+- * configuration pages.
+- */
+- hd->cmdPtr = NULL;
+-
+- /* Initialize this SCSI Hosts' timers
+- * To use, set the timer expires field
+- * and add_timer
+- */
+- init_timer(&hd->timer);
+- hd->timer.data = (unsigned long) hd;
+- hd->timer.function = mptscsih_timer_expired;
+-
++ ioc->sdev_queue_depth = mpt_sdev_queue_depth;
+ ioc->sas_data.ptClear = mpt_pt_clear;
+-
+- init_waitqueue_head(&hd->scandv_waitq);
+- hd->scandv_wait_done = 0;
+ hd->last_queue_full = 0;
++ ioc->disable_hotplug_remove = mpt_disable_hotplug_remove;
++ if (ioc->disable_hotplug_remove)
++ printk(MYIOC_s_INFO_FMT "disabling hotplug remove\n", ioc->name);
++
+ INIT_LIST_HEAD(&hd->target_reset_list);
++ INIT_LIST_HEAD(&ioc->sas_device_info_list);
++ init_MUTEX(&ioc->sas_device_info_mutex);
++
+ spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+
+ if (ioc->sas_data.ptClear==1) {
+@@ -3292,8 +5216,11 @@ mptsas_probe(struct pci_dev *pdev, const
+ goto out_mptsas_probe;
+ }
+
++ /* older firmware doesn't support expander events */
++ if ((ioc->facts.HeaderVersion >> 8) < 0xE)
++ ioc->old_sas_discovery_protocal = 1;
+ mptsas_scan_sas_topology(ioc);
+-
++ mptsas_fw_event_on(ioc);
+ return 0;
+
+ out_mptsas_probe:
+@@ -3302,13 +5229,23 @@ mptsas_probe(struct pci_dev *pdev, const
+ return error;
+ }
+
+-static void __devexit mptsas_remove(struct pci_dev *pdev)
++/**
++ * mptsas_remove -
++ * @pdev:
++ *
++ **/
++static void __devexit
++mptsas_remove(struct pci_dev *pdev)
+ {
+ MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
+ struct mptsas_portinfo *p, *n;
+ int i;
+
+- ioc->sas_discovery_ignore_events = 1;
++ mptsas_fw_event_off(ioc);
++ mptsas_cleanup_fw_event_q(ioc);
++
++ mptsas_del_device_components(ioc);
++
+ sas_remove_host(ioc->sh);
+
+ mutex_lock(&ioc->sas_topology_mutex);
+@@ -3316,11 +5253,12 @@ static void __devexit mptsas_remove(stru
+ list_del(&p->list);
+ for (i = 0 ; i < p->num_phys ; i++)
+ mptsas_port_delete(ioc, p->phy_info[i].port_details);
++
+ kfree(p->phy_info);
+ kfree(p);
+ }
+ mutex_unlock(&ioc->sas_topology_mutex);
+-
++ ioc->hba_port_info = NULL;
+ mptscsih_remove(pdev);
+ }
+
+@@ -3352,6 +5290,10 @@ static struct pci_driver mptsas_driver =
+ #endif
+ };
+
++/**
++ * mptsas_init -
++ *
++ **/
+ static int __init
+ mptsas_init(void)
+ {
+@@ -3365,10 +5307,12 @@ mptsas_init(void)
+ return -ENODEV;
+
+ mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
+- mptsasTaskCtx = mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
++ mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER);
+ mptsasInternalCtx =
+ mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
+ mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
++ mptsasDeviceResetCtx =
++ mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
+
+ mpt_event_register(mptsasDoneCtx, mptsas_event_process);
+ mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
+@@ -3380,6 +5324,10 @@ mptsas_init(void)
+ return error;
+ }
+
++/**
++ * mptsas_exit -
++ *
++ **/
+ static void __exit
+ mptsas_exit(void)
+ {
+@@ -3393,6 +5341,7 @@ mptsas_exit(void)
+ mpt_deregister(mptsasInternalCtx);
+ mpt_deregister(mptsasTaskCtx);
+ mpt_deregister(mptsasDoneCtx);
++ mpt_deregister(mptsasDeviceResetCtx);
+ }
+
+ module_init(mptsas_init);
+--- a/drivers/message/fusion/mptsas.h
++++ b/drivers/message/fusion/mptsas.h
+@@ -50,9 +50,10 @@
+ /*{-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
+ struct mptsas_target_reset_event {
+- struct list_head list;
+- EVENT_DATA_SAS_DEVICE_STATUS_CHANGE sas_event_data;
++ struct list_head list;
++ MpiEventDataSasDeviceStatusChange_t sas_event_data;
+ u8 target_reset_issued;
++ unsigned long time_count;
+ };
+
+ enum mptsas_hotplug_action {
+@@ -61,11 +62,34 @@ enum mptsas_hotplug_action {
+ MPTSAS_ADD_RAID,
+ MPTSAS_DEL_RAID,
+ MPTSAS_ADD_INACTIVE_VOLUME,
++ MPTSAS_ADD_PHYSDISK,
++ MPTSAS_ADD_PHYSDISK_REPROBE,
++ MPTSAS_DEL_PHYSDISK,
++ MPTSAS_DEL_PHYSDISK_REPROBE,
++ MPTSAS_REQUEUE_EVENT,
+ MPTSAS_IGNORE_EVENT,
+ };
+
++struct sas_mapping{
++ u8 id;
++ u8 channel;
++};
++
++struct sas_device_info {
++ struct list_head list;
++ struct sas_mapping os; /* operating system mapping*/
++ struct sas_mapping fw; /* firmware mapping */
++ u64 sas_address;
++ u32 device_info; /* specific bits for devices */
++ u16 slot; /* enclosure slot id */
++ u64 enclosure_logical_id; /*enclosure address */
++ u8 is_logical_volume; /* is this logical volume */
++ u8 is_hidden_raid_component; /* this belongs to volume */
++ u8 volume_id; /* this valid when is_hidden_raid_component set */
++ u8 is_cached; /* cached data for a removed device */
++};
++
+ struct mptsas_hotplug_event {
+- struct work_struct work;
+ MPT_ADAPTER *ioc;
+ enum mptsas_hotplug_action event_type;
+ u64 sas_address;
+@@ -73,17 +97,28 @@ struct mptsas_hotplug_event {
+ u8 id;
+ u32 device_info;
+ u16 handle;
+- u16 parent_handle;
+ u8 phy_id;
+- u8 phys_disk_num_valid; /* hrc (hidden raid component) */
+ u8 phys_disk_num; /* hrc - unique index*/
+- u8 hidden_raid_component; /* hrc - don't expose*/
++ struct scsi_device *sdev;
+ };
+
+-struct mptsas_discovery_event {
++
++struct fw_event_work {
++ struct list_head list;
++ struct delayed_work work;
++ MPT_ADAPTER *ioc;
++ u32 event;
++ u8 retries;
++ u8 event_data[1];
++};
++
++#if 0
++struct mptsas_link_status_event {
+ struct work_struct work;
++ MpiEventDataSasPhyLinkStatus_t link_data;
+ MPT_ADAPTER *ioc;
+ };
++#endif
+
+ /*
+ * SAS topology structures
+@@ -113,32 +148,35 @@ struct mptsas_devinfo {
+ * Specific details on ports, wide/narrow
+ */
+ struct mptsas_portinfo_details{
+- u16 num_phys; /* number of phys belong to this port */
+- u64 phy_bitmask; /* TODO, extend support for 255 phys */
+- struct sas_rphy *rphy; /* transport layer rphy object */
++ u16 num_phys; /* number of phys beloing to this port */
++ u64 phy_bitmask; /* this needs extending to support 128 phys */
++ struct sas_rphy *rphy; /* rphy for end devices */
+ struct sas_port *port; /* transport layer port object */
+ struct scsi_target *starget;
+ struct mptsas_portinfo *port_info;
+ };
+
+ struct mptsas_phyinfo {
+- u16 handle; /* unique id to address this */
+- u8 phy_id; /* phy index */
+- u8 port_id; /* firmware port identifier */
++ u16 handle; /* handle for this phy */
++ u8 phy_id; /* phy index */
++ u8 port_id; /* port number this phy is part of */
+ u8 negotiated_link_rate; /* nego'd link rate for this phy */
+- u8 hw_link_rate; /* hardware max/min phys link rate */
++ u8 hw_link_rate; /* hardware max/min phys link rate */
+ u8 programmed_link_rate; /* programmed max/min phy link rate */
+ u8 sas_port_add_phy; /* flag to request sas_port_add_phy*/
++ u8 change_count; /* change count of the phy */
++ u8 port_flags; /* info wrt host sas ports */
++ u32 phy_info; /* various info wrt the phy */
+ struct mptsas_devinfo identify; /* point to phy device info */
+ struct mptsas_devinfo attached; /* point to attached device info */
+- struct sas_phy *phy; /* transport layer phy object */
++ struct sas_phy *phy;
+ struct mptsas_portinfo *portinfo;
+ struct mptsas_portinfo_details * port_details;
+ };
+
+ struct mptsas_portinfo {
+ struct list_head list;
+- u16 num_phys; /* number of phys */
++ u16 num_phys; /* number of phys */
+ struct mptsas_phyinfo *phy_info;
+ };
+
+@@ -156,3 +194,4 @@ struct mptsas_enclosure {
+
+ /*}-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ #endif
++
+--- a/drivers/message/fusion/mptscsih.c
++++ b/drivers/message/fusion/mptscsih.c
+@@ -53,7 +53,9 @@
+ #include <linux/delay.h> /* for mdelay */
+ #include <linux/interrupt.h> /* needed for in_interrupt() proto */
+ #include <linux/reboot.h> /* notifier code */
++#include <linux/sched.h>
+ #include <linux/workqueue.h>
++#include <linux/pci.h>
+
+ #include <scsi/scsi.h>
+ #include <scsi/scsi_cmnd.h>
+@@ -77,10 +79,15 @@ MODULE_LICENSE("GPL");
+ MODULE_VERSION(my_VERSION);
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++typedef struct _BIG_SENSE_BUF {
++ u8 data[MPT_SENSE_BUFFER_ALLOC];
++} BIG_SENSE_BUF;
++
++
+ /*
+ * Other private/forward protos...
+ */
+-static struct scsi_cmnd * mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
++struct scsi_cmnd * mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
+ static struct scsi_cmnd * mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i);
+ static void mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd);
+ static int SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *scmd);
+@@ -92,17 +99,10 @@ static int mptscsih_AddSGE(MPT_ADAPTER *
+ SCSIIORequest_t *pReq, int req_idx);
+ static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
+ static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
+-static int mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd);
+-static int mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout );
+-
+-static int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
+
+ int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
+ int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
+-
+-int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
+-static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
+-static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
++static void mptscsih_synchronize_cache(struct scsi_device *sdev, MPT_SCSI_HOST *hd, VirtDevice *vdevice);
+
+ void mptscsih_remove(struct pci_dev *);
+ void mptscsih_shutdown(struct pci_dev *);
+@@ -111,81 +111,17 @@ int mptscsih_suspend(struct pci_dev *p
+ int mptscsih_resume(struct pci_dev *pdev);
+ #endif
+
+-#define SNS_LEN(scp) SCSI_SENSE_BUFFERSIZE
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/**
+- * mptscsih_add_sge - Place a simple SGE at address pAddr.
+- * @pAddr: virtual address for SGE
+- * @flagslength: SGE flags and data transfer length
+- * @dma_addr: Physical address
+- *
+- * This routine places a MPT request frame back on the MPT adapter's
+- * FreeQ.
+- */
+-static inline void
+-mptscsih_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
+-{
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
+- SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
+- u32 tmp = dma_addr & 0xFFFFFFFF;
+-
+- pSge->FlagsLength = cpu_to_le32(flagslength);
+- pSge->Address.Low = cpu_to_le32(tmp);
+- tmp = (u32) ((u64)dma_addr >> 32);
+- pSge->Address.High = cpu_to_le32(tmp);
+-
+- } else {
+- SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
+- pSge->FlagsLength = cpu_to_le32(flagslength);
+- pSge->Address = cpu_to_le32(dma_addr);
+- }
+-} /* mptscsih_add_sge() */
++#define SNS_LEN(scp) sizeof((scp)->sense_buffer)
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mptscsih_add_chain - Place a chain SGE at address pAddr.
+- * @pAddr: virtual address for SGE
+- * @next: nextChainOffset value (u32's)
+- * @length: length of next SGL segment
+- * @dma_addr: Physical address
+- *
+- * This routine places a MPT request frame back on the MPT adapter's
+- * FreeQ.
+- */
+-static inline void
+-mptscsih_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
+-{
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
+- SGEChain64_t *pChain = (SGEChain64_t *) pAddr;
+- u32 tmp = dma_addr & 0xFFFFFFFF;
+-
+- pChain->Length = cpu_to_le16(length);
+- pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
+-
+- pChain->NextChainOffset = next;
+-
+- pChain->Address.Low = cpu_to_le32(tmp);
+- tmp = (u32) ((u64)dma_addr >> 32);
+- pChain->Address.High = cpu_to_le32(tmp);
+- } else {
+- SGEChain32_t *pChain = (SGEChain32_t *) pAddr;
+- pChain->Length = cpu_to_le16(length);
+- pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
+- pChain->NextChainOffset = next;
+- pChain->Address = cpu_to_le32(dma_addr);
+- }
+-} /* mptscsih_add_chain() */
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
+ * mptscsih_getFreeChainBuffer - Function to get a free chain
+ * from the MPT_SCSI_HOST FreeChainQ.
+ * @ioc: Pointer to MPT_ADAPTER structure
+ * @req_idx: Index of the SCSI IO request frame. (output)
+ *
+ * return SUCCESS or FAILED
+- */
++ **/
+ static inline int
+ mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
+ {
+@@ -195,7 +131,7 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
+ int chain_idx;
+
+ dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n",
+- ioc->name));
++ ioc->name));
+ spin_lock_irqsave(&ioc->FreeQlock, flags);
+ if (!list_empty(&ioc->FreeChainQ)) {
+ int offset;
+@@ -206,14 +142,13 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
+ offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
+ chain_idx = offset / ioc->req_sz;
+ rc = SUCCESS;
+- dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
+- ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
++ dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
++ ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
+ } else {
+ rc = FAILED;
+ chain_idx = MPT_HOST_NO_CHAIN;
+ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n",
+- ioc->name));
++ ioc->name));
+ }
+ spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+
+@@ -222,7 +157,7 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
+ } /* mptscsih_getFreeChainBuffer() */
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
+ * SCSIIORequest_t Message Frame.
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -230,7 +165,7 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
+ * @pReq: Pointer to SCSIIORequest_t structure
+ *
+ * Returns ...
+- */
++ **/
+ static int
+ mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
+ SCSIIORequest_t *pReq, int req_idx)
+@@ -281,10 +216,10 @@ mptscsih_AddSGE(MPT_ADAPTER *ioc, struct
+ */
+
+ nextSGEset:
+- numSgeSlots = ((frm_sz - sgeOffset) / (sizeof(u32) + sizeof(dma_addr_t)) );
++ numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size );
+ numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
+
+- sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | MPT_SGE_FLAGS_ADDRESSING | sgdir;
++ sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir;
+
+ /* Get first (num - 1) SG elements
+ * Skip any SG entries with a length of 0
+@@ -299,11 +234,11 @@ nextSGEset:
+ }
+
+ v2 = sg_dma_address(sg);
+- mptscsih_add_sge(psge, sgflags | thisxfer, v2);
++ ioc->add_sge(psge, sgflags | thisxfer, v2);
+
+ sg = sg_next(sg); /* Get next SG element from the OS */
+- psge += (sizeof(u32) + sizeof(dma_addr_t));
+- sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
++ psge += ioc->SGE_size;
++ sgeOffset += ioc->SGE_size;
+ sg_done++;
+ }
+
+@@ -320,12 +255,8 @@ nextSGEset:
+ thisxfer = sg_dma_len(sg);
+
+ v2 = sg_dma_address(sg);
+- mptscsih_add_sge(psge, sgflags | thisxfer, v2);
+- /*
+- sg = sg_next(sg);
+- psge += (sizeof(u32) + sizeof(dma_addr_t));
+- */
+- sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
++ ioc->add_sge(psge, sgflags | thisxfer, v2);
++ sgeOffset += ioc->SGE_size;
+ sg_done++;
+
+ if (chainSge) {
+@@ -334,7 +265,7 @@ nextSGEset:
+ * Update the chain element
+ * Offset and Length fields.
+ */
+- mptscsih_add_chain((char *)chainSge, 0, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
++ ioc->add_chain((char *)chainSge, 0, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
+ } else {
+ /* The current buffer is the original MF
+ * and there is no Chain buffer.
+@@ -367,7 +298,7 @@ nextSGEset:
+ * set properly).
+ */
+ if (sg_done) {
+- u32 *ptmp = (u32 *) (psge - (sizeof(u32) + sizeof(dma_addr_t)));
++ u32 *ptmp = (u32 *) (psge - ioc->SGE_size);
+ sgflags = le32_to_cpu(*ptmp);
+ sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
+ *ptmp = cpu_to_le32(sgflags);
+@@ -381,8 +312,8 @@ nextSGEset:
+ * Old chain element is now complete.
+ */
+ u8 nextChain = (u8) (sgeOffset >> 2);
+- sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
+- mptscsih_add_chain((char *)chainSge, nextChain, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
++ sgeOffset += ioc->SGE_size;
++ ioc->add_chain((char *)chainSge, nextChain, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
+ } else {
+ /* The original MF buffer requires a chain buffer -
+ * set the offset.
+@@ -461,7 +392,7 @@ mptscsih_issue_sep_command(MPT_ADAPTER *
+
+ if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
+ dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
+- ioc->name,__func__));
++ ioc->name,__FUNCTION__));
+ return;
+ }
+
+@@ -592,14 +523,14 @@ mptscsih_info_scsiio(MPT_ADAPTER *ioc, s
+ }
+
+ scsi_print_command(sc);
+- printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d\n",
+- ioc->name, pScsiReply->Bus, pScsiReply->TargetID);
+- printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, "
+- "resid = %d\n", ioc->name, scsi_bufflen(sc), sc->underflow,
+- scsi_get_resid(sc));
+- printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, "
+- "sc->result = %08X\n", ioc->name, le16_to_cpu(pScsiReply->TaskTag),
++ printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %d\n",
++ ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun);
++ printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, resid = %d\n",
++ ioc->name, scsi_bufflen(sc), sc->underflow, scsi_get_resid(sc));
++ printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, sc->result = %08X\n",
++ ioc->name, le16_to_cpu(pScsiReply->TaskTag),
+ le32_to_cpu(pScsiReply->TransferCount), sc->result);
++
+ printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), "
+ "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n",
+ ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus,
+@@ -625,7 +556,7 @@ mptscsih_info_scsiio(MPT_ADAPTER *ioc, s
+ #endif
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_io_done - Main SCSI IO callback routine registered to
+ * Fusion MPT (base) driver
+ * @ioc: Pointer to MPT_ADAPTER structure
+@@ -638,7 +569,7 @@ mptscsih_info_scsiio(MPT_ADAPTER *ioc, s
+ * load/init time via the mpt_register() API call.
+ *
+ * Returns 1 indicating alloc'd request frame ptr should be freed.
+- */
++ **/
+ int
+ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
+ {
+@@ -651,14 +582,15 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ VirtTarget *vtarget;
+
+ hd = shost_priv(ioc->sh);
++
+ req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
+ req_idx_MR = (mr != NULL) ?
+ le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
+ if ((req_idx != req_idx_MR) ||
+- (mf->u.frame.linkage.arg1 == 0xdeadbeaf)) {
+- printk(MYIOC_s_ERR_FMT "Received a mf that was already freed\n",
+- ioc->name);
+- printk (MYIOC_s_ERR_FMT
++ (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf)) {
++ printk(MYIOC_s_WARN_FMT
++ "Received a mf that was already freed\n", ioc->name);
++ printk (MYIOC_s_WARN_FMT
+ "req_idx=%x req_idx_MR=%x mf=%p mr=%p sc=%p\n",
+ ioc->name, req_idx, req_idx_MR, mf, mr,
+ mptscsih_get_scsi_lookup(ioc, req_idx_MR));
+@@ -693,7 +625,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+
+ if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
+ dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
++ "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task_tag=%d)\n",
+ ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
+ }else{
+ dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+@@ -706,6 +638,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ ;
+ } else {
+ u32 xfer_cnt;
++ u32 difftransfer;
+ u16 status;
+ u8 scsi_state, scsi_status;
+ u32 log_info;
+@@ -716,6 +649,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
+ scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
+ log_info = le32_to_cpu(pScsiReply->IOCLogInfo);
++ vdevice = sc->device->hostdata;
+
+ /*
+ * if we get a data underrun indication, yet no data was
+@@ -733,20 +667,9 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
+ mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
+
+- /*
+- * Look for + dump FCP ResponseInfo[]!
+- */
+- if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
+- pScsiReply->ResponseInfo) {
+- printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%d] "
+- "FCP_ResponseInfo=%08xh\n", ioc->name,
+- sc->device->host->host_no, sc->device->channel,
+- sc->device->id, sc->device->lun,
+- le32_to_cpu(pScsiReply->ResponseInfo));
+- }
+-
+ switch(status) {
+ case MPI_IOCSTATUS_BUSY: /* 0x0002 */
++ case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
+ /* CHECKME!
+ * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
+ * But not: DID_BUS_BUSY lest one risk
+@@ -771,7 +694,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
+ hd->sel_timeout[pScsiReq->TargetID]++;
+
+- vdevice = sc->device->hostdata;
+ if (!vdevice)
+ break;
+ vtarget = vdevice->vtarget;
+@@ -793,14 +715,11 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ }
+ }
+ } else if (ioc->bus_type == FC) {
+- /*
+- * The FC IOC may kill a request for variety of
+- * reasons, some of which may be recovered by a
+- * retry, some which are unlikely to be
+- * recovered. Return DID_ERROR instead of
+- * DID_RESET to permit retry of the command,
+- * just not an infinite number of them
+- */
++ /* The FC IOC may kill a request for variety of reasons,
++ some of which may be recovered by a retry, some which
++ are unlikely to be recovered. Return DID_ERROR instead
++ of DID_RESET to permit retry of the command, just not
++ an infinite number of them */
+ sc->result = DID_ERROR << 16;
+ break;
+ }
+@@ -810,12 +729,16 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ */
+
+ case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
+- case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
+ /* Linux handles an unsolicited DID_RESET better
+ * than an unsolicited DID_ABORT.
+ */
+ sc->result = DID_RESET << 16;
+
++ case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
++ if ( ioc->bus_type == FC )
++ sc->result = DID_ERROR << 16;
++ else
++ sc->result = DID_RESET << 16;
+ break;
+
+ case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
+@@ -824,9 +747,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ sc->result=DID_SOFT_ERROR << 16;
+ else /* Sufficient data transfer occurred */
+ sc->result = (DID_OK << 16) | scsi_status;
+- dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
+- ioc->name, sc->result, sc->device->channel, sc->device->id));
+ break;
+
+ case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
+@@ -835,11 +755,34 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ * precedence!
+ */
+ sc->result = (DID_OK << 16) | scsi_status;
+- if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
+- /* Have already saved the status and sense data
++
++ if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
++
++ /*
++ * For an Errata on LSI53C1030
++ * When the length of request data
++ * and transfer data are different
++ * with result of command (READ or VERIFY),
++ * DID_SOFT_ERROR is set.
+ */
+- ;
+- } else {
++ if (ioc->bus_type == SPI && vdevice &&
++ vdevice->vtarget->type == TYPE_DISK) {
++ if (pScsiReq->CDB[0] == READ_6 ||
++ pScsiReq->CDB[0] == READ_10 ||
++ pScsiReq->CDB[0] == READ_12 ||
++ pScsiReq->CDB[0] == READ_16 ||
++ pScsiReq->CDB[0] == VERIFY ||
++ pScsiReq->CDB[0] == VERIFY_16) {
++ if (scsi_bufflen(sc) !=
++ xfer_cnt) {
++ sc->result = DID_SOFT_ERROR << 16;
++ printk(MYIOC_s_WARN_FMT "Errata"
++ "on LSI53C1030 occurred. sc->request_bufflen=0x%02x, "
++ "xfer_cnt=0x%02x\n", ioc->name, scsi_bufflen(sc), xfer_cnt);
++ }
++ }
++ }
++
+ if (xfer_cnt < sc->underflow) {
+ if (scsi_status == SAM_STAT_BUSY)
+ sc->result = SAM_STAT_BUSY;
+@@ -848,7 +791,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ }
+ if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
+ /* What to do?
+- */
++ */
+ sc->result = DID_SOFT_ERROR << 16;
+ }
+ else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
+@@ -857,13 +800,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ }
+ }
+
+-
+- dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
+- ioc->name, sc->underflow));
+- dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
+-
+ /* Report Queue Full
+ */
+ if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
+@@ -879,6 +815,44 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ if (scsi_state == 0) {
+ ;
+ } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
++
++ /*
++ * For potential trouble on LSI53C1030. (date:2007.xx.)
++ * It is checked whether the length of request data is equal to
++ * the length of transfer and residual.
++ * MEDIUM_ERROR is set by incorrect data.
++ */
++ if (ioc->bus_type == SPI && vdevice &&
++ vdevice->vtarget->type == TYPE_DISK) {
++ if (sc->sense_buffer[2] & 0x20) {
++ difftransfer =
++ sc->sense_buffer[3] << 24 |
++ sc->sense_buffer[4] << 16 |
++ sc->sense_buffer[5] << 8 |
++ sc->sense_buffer[6];
++ if ((sc->sense_buffer[3] & 0x80) == 0x80) {
++ if (scsi_bufflen(sc) != xfer_cnt) {
++ sc->sense_buffer[2] = MEDIUM_ERROR;
++ sc->sense_buffer[12] = 0xff;
++ sc->sense_buffer[13] = 0xff;
++ printk(MYIOC_s_WARN_FMT "Errata on "
++ "LSI53C1030 occurred. sc->request_bufflen=0x%02x,"
++ "xfer_cnt=0x%02x\n", ioc->name, scsi_bufflen(sc), xfer_cnt);
++ }
++ } else {
++ if (scsi_bufflen(sc) != xfer_cnt + difftransfer) {
++ sc->sense_buffer[2] = MEDIUM_ERROR;
++ sc->sense_buffer[12] = 0xff;
++ sc->sense_buffer[13] = 0xff;
++ printk(MYIOC_s_WARN_FMT "Errata on "
++ "LSI53C1030 occurred. sc->request_bufflen=0x%02x,"
++ " xfer_cnt=0x%02x, difftransfer=0x%02x\n",
++ ioc->name, scsi_bufflen(sc) , xfer_cnt, difftransfer);
++ }
++ }
++ }
++ }
++
+ /*
+ * If running against circa 200003dd 909 MPT f/w,
+ * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
+@@ -890,7 +864,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+
+ }
+ else if (scsi_state &
+- (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
++ (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
+ ) {
+ /*
+ * What to do?
+@@ -926,7 +900,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
+ case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
+ case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
+- case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
+ case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
+ case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
+ case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
+@@ -957,7 +930,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ return 1;
+ }
+
+-/*
++/**
+ * mptscsih_flush_running_cmds - For each command found, search
+ * Scsi_Host instance taskQ and reply to OS.
+ * Called only if recovering from a FW reload.
+@@ -966,7 +939,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
+ * Returns: None.
+ *
+ * Must be called while new I/Os are being queued.
+- */
++ **/
+ static void
+ mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
+ {
+@@ -992,14 +965,14 @@ mptscsih_flush_running_cmds(MPT_SCSI_HOS
+ scsi_dma_unmap(sc);
+ sc->result = DID_RESET << 16;
+ sc->host_scribble = NULL;
+- sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
+- "completing cmds: fw_channel %d, fw_id %d, sc=%p,"
+- " mf = %p, idx=%x\n", ioc->name, channel, id, sc, mf, ii);
++ dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
++ "completing cmds: fw_channel %d, fw_id %d, sc=%p, mf = %p, "
++ "idx=%x\n", ioc->name, channel, id, sc, mf, ii));
+ sc->scsi_done(sc);
+ }
+ }
+
+-/*
++/**
+ * mptscsih_search_running_cmds - Delete any commands associated
+ * with the specified target and lun. Function called only
+ * when a lun is disable by mid-layer.
+@@ -1012,15 +985,15 @@ mptscsih_flush_running_cmds(MPT_SCSI_HOS
+ * Returns: None.
+ *
+ * Called from slave_destroy.
+- */
++ **/
+ static void
+ mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
+ {
+ SCSIIORequest_t *mf = NULL;
+ int ii;
+ struct scsi_cmnd *sc;
+- struct scsi_lun lun;
+- MPT_ADAPTER *ioc = hd->ioc;
++ struct scsi_lun lun;
++ MPT_ADAPTER *ioc = hd->ioc;
+ unsigned long flags;
+
+ spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
+@@ -1030,8 +1003,11 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
+ mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
+ if (mf == NULL)
+ continue;
+- /* If the device is a hidden raid component, then its
+- * expected that the mf->function will be RAID_SCSI_IO
++
++ /*
++ * If the device is a hidden raid component,
++ * then its expected that
++ * the function would be raid scsi io
+ */
+ if (vdevice->vtarget->tflags &
+ MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function !=
+@@ -1053,9 +1029,11 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
+ scsi_dma_unmap(sc);
+ sc->host_scribble = NULL;
+ sc->result = DID_NO_CONNECT << 16;
+- sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT "completing cmds: fw_channel %d,"
+- "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name, vdevice->vtarget->channel,
+- vdevice->vtarget->id, sc, mf, ii);
++ dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device,
++ MYIOC_s_FMT "completing cmds: fw_channel %d, "
++ "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name,
++ vdevice->vtarget->channel, vdevice->vtarget->id,
++ sc, mf, ii));
+ sc->scsi_done(sc);
+ spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
+ }
+@@ -1067,7 +1045,7 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_report_queue_full - Report QUEUE_FULL status returned
+ * from a SCSI target device.
+ * @sc: Pointer to scsi_cmnd structure
+@@ -1077,12 +1055,12 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
+ * This routine periodically reports QUEUE_FULL status returned from a
+ * SCSI target device. It reports this to the console via kernel
+ * printk() API call, not more than once every 10 seconds.
+- */
++ **/
+ static void
+ mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
+ {
+ long time = jiffies;
+- MPT_SCSI_HOST *hd;
++ MPT_SCSI_HOST *hd;
+ MPT_ADAPTER *ioc;
+
+ if (sc->device == NULL)
+@@ -1100,12 +1078,12 @@ mptscsih_report_queue_full(struct scsi_c
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_remove - Removed scsi devices
+ * @pdev: Pointer to pci_dev structure
+ *
+ *
+- */
++ **/
+ void
+ mptscsih_remove(struct pci_dev *pdev)
+ {
+@@ -1151,10 +1129,10 @@ mptscsih_remove(struct pci_dev *pdev)
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_shutdown - reboot notifier
+ *
+- */
++ **/
+ void
+ mptscsih_shutdown(struct pci_dev *pdev)
+ {
+@@ -1162,11 +1140,11 @@ mptscsih_shutdown(struct pci_dev *pdev)
+
+ #ifdef CONFIG_PM
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_suspend - Fusion MPT scsi driver suspend routine.
+ *
+ *
+- */
++ **/
+ int
+ mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
+ {
+@@ -1179,11 +1157,11 @@ mptscsih_suspend(struct pci_dev *pdev, p
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_resume - Fusion MPT scsi driver resume routine.
+ *
+ *
+- */
++ **/
+ int
+ mptscsih_resume(struct pci_dev *pdev)
+ {
+@@ -1205,7 +1183,7 @@ mptscsih_resume(struct pci_dev *pdev)
+ * (linux scsi_host_template.info routine)
+ *
+ * Returns pointer to buffer where information was written.
+- */
++ **/
+ const char *
+ mptscsih_info(struct Scsi_Host *SChost)
+ {
+@@ -1338,7 +1316,7 @@ mptscsih_proc_info(struct Scsi_Host *hos
+ * from a linux scsi_cmnd request and send it to the IOC.
+ *
+ * Returns 0. (rtn value discarded by linux scsi mid-layer)
+- */
++ **/
+ int
+ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
+ {
+@@ -1346,7 +1324,6 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
+ MPT_FRAME_HDR *mf;
+ SCSIIORequest_t *pScsiReq;
+ VirtDevice *vdevice = SCpnt->device->hostdata;
+- int lun;
+ u32 datalen;
+ u32 scsictl;
+ u32 scsidir;
+@@ -1357,24 +1334,20 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
+
+ hd = shost_priv(SCpnt->device->host);
+ ioc = hd->ioc;
+- lun = SCpnt->device->lun;
+ SCpnt->scsi_done = done;
+
+ dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p, done()=%p\n",
+ ioc->name, SCpnt, done));
+
+- if (hd->resetPending) {
+- dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n",
+- ioc->name, SCpnt));
++ if (ioc->taskmgmt_quiesce_io)
+ return SCSI_MLQUEUE_HOST_BUSY;
+- }
+
+ /*
+ * Put together a MPT SCSI request...
+ */
+ if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
+ dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
+- ioc->name));
++ ioc->name));
+ return SCSI_MLQUEUE_HOST_BUSY;
+ }
+
+@@ -1422,7 +1395,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
+ pScsiReq->CDBLength = SCpnt->cmd_len;
+ pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
+ pScsiReq->Reserved = 0;
+- pScsiReq->MsgFlags = mpt_msg_flags();
++ pScsiReq->MsgFlags = mpt_msg_flags(ioc);
+ int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN);
+ pScsiReq->Control = cpu_to_le32(scsictl);
+
+@@ -1448,7 +1421,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
+ */
+ if (datalen == 0) {
+ /* Add a NULL SGE */
+- mptscsih_add_sge((char *)&pScsiReq->SGL, MPT_SGE_FLAGS_SSIMPLE_READ | 0,
++ ioc->add_sge((char *)&pScsiReq->SGL, MPT_SGE_FLAGS_SSIMPLE_READ | 0,
+ (dma_addr_t) -1);
+ } else {
+ /* Add a 32 or 64 bit SGE */
+@@ -1472,7 +1445,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_freeChainBuffers - Function to free chain buffers associated
+ * with a SCSI IO request
+ * @hd: Pointer to the MPT_SCSI_HOST instance
+@@ -1480,7 +1453,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
+ *
+ * Called if SG chain buffer allocation fails and mptscsih callbacks.
+ * No return.
+- */
++ **/
+ static void
+ mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
+ {
+@@ -1527,243 +1500,457 @@ mptscsih_freeChainBuffers(MPT_ADAPTER *i
+ */
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/**
+- * mptscsih_TMHandler - Generic handler for SCSI Task Management.
+- * @hd: Pointer to MPT SCSI HOST structure
+- * @type: Task Management type
+- * @channel: channel number for task management
+- * @id: Logical Target ID for reset (if appropriate)
+- * @lun: Logical Unit for reset (if appropriate)
+- * @ctx2abort: Context for the task to be aborted (if appropriate)
+- * @timeout: timeout for task management control
+- *
+- * Fall through to mpt_HardResetHandler if: not operational, too many
+- * failed TM requests or handshake failure.
+- *
+- * Remark: Currently invoked from a non-interrupt thread (_bh).
+- *
+- * Note: With old EH code, at most 1 SCSI TaskMgmt function per IOC
+- * will be active.
+- *
+- * Returns 0 for SUCCESS, or %FAILED.
+- **/
+-int
+-mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout)
+-{
+- MPT_ADAPTER *ioc;
+- int rc = -1;
+- u32 ioc_raw_state;
+- unsigned long flags;
+-
+- ioc = hd->ioc;
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler Entered!\n", ioc->name));
+-
+- // SJR - CHECKME - Can we avoid this here?
+- // (mpt_HardResetHandler has this check...)
+- spin_lock_irqsave(&ioc->diagLock, flags);
+- if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)) {
+- spin_unlock_irqrestore(&ioc->diagLock, flags);
+- return FAILED;
+- }
+- spin_unlock_irqrestore(&ioc->diagLock, flags);
+-
+- /* Wait a fixed amount of time for the TM pending flag to be cleared.
+- * If we time out and not bus reset, then we return a FAILED status
+- * to the caller.
+- * The call to mptscsih_tm_pending_wait() will set the pending flag
+- * if we are
+- * successful. Otherwise, reload the FW.
+- */
+- if (mptscsih_tm_pending_wait(hd) == FAILED) {
+- if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler abort: "
+- "Timed out waiting for last TM (%d) to complete! \n",
+- ioc->name, hd->tmPending));
+- return FAILED;
+- } else if (type == MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler target "
+- "reset: Timed out waiting for last TM (%d) "
+- "to complete! \n", ioc->name,
+- hd->tmPending));
+- return FAILED;
+- } else if (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler bus reset: "
+- "Timed out waiting for last TM (%d) to complete! \n",
+- ioc->name, hd->tmPending));
+- return FAILED;
+- }
+- } else {
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- hd->tmPending |= (1 << type);
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+- }
+-
+- ioc_raw_state = mpt_GetIocState(ioc, 0);
+-
+- if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
+- printk(MYIOC_s_WARN_FMT
+- "TM Handler for type=%x: IOC Not operational (0x%x)!\n",
+- ioc->name, type, ioc_raw_state);
+- printk(MYIOC_s_WARN_FMT " Issuing HardReset!!\n", ioc->name);
+- if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
+- printk(MYIOC_s_WARN_FMT "TMHandler: HardReset "
+- "FAILED!!\n", ioc->name);
+- return FAILED;
+- }
+-
+- if (ioc_raw_state & MPI_DOORBELL_ACTIVE) {
+- printk(MYIOC_s_WARN_FMT
+- "TM Handler for type=%x: ioc_state: "
+- "DOORBELL_ACTIVE (0x%x)!\n",
+- ioc->name, type, ioc_raw_state);
+- return FAILED;
+- }
+-
+- /* Isse the Task Mgmt request.
+- */
+- if (hd->hard_resets < -1)
+- hd->hard_resets++;
+-
+- rc = mptscsih_IssueTaskMgmt(hd, type, channel, id, lun,
+- ctx2abort, timeout);
+- if (rc)
+- printk(MYIOC_s_INFO_FMT "Issue of TaskMgmt failed!\n",
+- ioc->name);
+- else
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issue of TaskMgmt Successful!\n",
+- ioc->name));
+-
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "TMHandler rc = %d!\n", ioc->name, rc));
+-
+- return rc;
+-}
+-
+-
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/**
+- * mptscsih_IssueTaskMgmt - Generic send Task Management function.
+- * @hd: Pointer to MPT_SCSI_HOST structure
+- * @type: Task Management type
+- * @channel: channel number for task management
+- * @id: Logical Target ID for reset (if appropriate)
+- * @lun: Logical Unit for reset (if appropriate)
+- * @ctx2abort: Context for the task to be aborted (if appropriate)
+- * @timeout: timeout for task management control
+- *
+- * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
+- * or a non-interrupt thread. In the former, must not call schedule().
+- *
+- * Not all fields are meaningfull for all task types.
+- *
+- * Returns 0 for SUCCESS, or FAILED.
+- *
+- **/
++
+ static int
+-mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout)
++mptscsih_scandv_bus_reset(MPT_ADAPTER *ioc)
+ {
+ MPT_FRAME_HDR *mf;
+ SCSITaskMgmt_t *pScsiTm;
++ SCSITaskMgmtReply_t *pScsiTmReply;
+ int ii;
+ int retval;
+- MPT_ADAPTER *ioc = hd->ioc;
++ unsigned long timeout;
++ unsigned long time_count;
++ u16 iocstatus;
++
++ mutex_lock(&ioc->taskmgmt_cmds.mutex);
++ if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ return -EPERM;
++ }
+
+- /* Return Fail to calling function if no message frames available.
++ /* Send request
+ */
+ if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "IssueTaskMgmt, no msg frames!!\n",
++ dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
+ ioc->name));
+- return FAILED;
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ retval = -ENOMEM;
++ goto out;
+ }
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt request @ %p\n",
+- ioc->name, mf));
+
+- /* Format the Request
+- */
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
++ ioc->name, mf));
++
+ pScsiTm = (SCSITaskMgmt_t *) mf;
+- pScsiTm->TargetID = id;
+- pScsiTm->Bus = channel;
+- pScsiTm->ChainOffset = 0;
++ 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->ChainOffset = 0;
+ pScsiTm->Reserved = 0;
+- pScsiTm->TaskType = type;
+ pScsiTm->Reserved1 = 0;
+- pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
+- ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
+-
+- int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
+-
++ pScsiTm->TaskMsgContext = 0;
++ for (ii= 0; ii < 8; ii++)
++ pScsiTm->LUN[ii] = 0;
+ for (ii=0; ii < 7; ii++)
+ pScsiTm->Reserved2[ii] = 0;
+
+- pScsiTm->TaskMsgContext = ctx2abort;
+-
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt: ctx2abort (0x%08x) "
+- "type=%d\n", ioc->name, ctx2abort, type));
++ switch (ioc->bus_type) {
++ case FC:
++ timeout = 40;
++ break;
++ case SAS:
++ timeout = 30;
++ break;
++ case SPI:
++ default:
++ timeout = 2;
++ break;
++ }
+
+- DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
++ ioc->name, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, timeout));
+
++ INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
++ retval = 0;
++ time_count = jiffies;
+ if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
+ (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
+ mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
+ else {
+ retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
+- sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
+- if (retval) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "send_handshake FAILED!"
+- " (hd %p, ioc %p, mf %p, rc=%d) \n", ioc->name, hd,
+- ioc, mf, retval));
+- goto fail_out;
++ sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
++ if (retval != 0) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt send_handshake FAILED!"
++ " (ioc %p, mf %p, rc=%d) \n", ioc->name,
++ ioc, mf, retval));
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ goto out;
+ }
+ }
+
+- if(mptscsih_tm_wait_for_completion(hd, timeout) == FAILED) {
+- dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "task management request TIMED OUT!"
+- " (hd %p, ioc %p, mf %p) \n", ioc->name, hd,
+- ioc, mf));
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling HardReset! \n",
+- ioc->name));
+- retval = mpt_HardResetHandler(ioc, CAN_SLEEP);
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rc=%d \n",
+- ioc->name, retval));
+- goto fail_out;
++ /* 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));
++ mpt_free_msg_frame(ioc, mf);
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ retval = -1; /* return failure */
++ goto out;
+ }
+
+- /*
+- * Handle success case, see if theres a non-zero ioc_status.
+- */
+- if (hd->tm_iocstatus == MPI_IOCSTATUS_SUCCESS ||
+- hd->tm_iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
+- hd->tm_iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
+- retval = 0;
+- else
+- retval = FAILED;
++ 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 out;
++ }
+
+- return retval;
++ pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
++ "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
++ "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
++ pScsiTmReply->TargetID, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
++ le16_to_cpu(pScsiTmReply->IOCStatus),
++ le32_to_cpu(pScsiTmReply->IOCLogInfo),
++ pScsiTmReply->ResponseCode,
++ le32_to_cpu(pScsiTmReply->TerminationCount)));
+
+- fail_out:
++ iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
+
+- /*
+- * Free task management mf, and corresponding tm flags
+- */
+- mpt_free_msg_frame(ioc, mf);
+- hd->tmPending = 0;
+- hd->tmState = TM_STATE_NONE;
+- return FAILED;
++ if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
++ iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED ||
++ iocstatus == MPI_IOCSTATUS_SUCCESS)
++ retval = 0;
++ else {
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt failed\n", ioc->name));
++ retval = -1; /* return failure */
++ }
++
++ out:
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ return retval;
+ }
+
+-static int
+-mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
++int
++mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
+ {
+- switch (ioc->bus_type) {
+- case FC:
+- return 40;
+- case SAS:
+- return 10;
++ MPT_SCSI_HOST *hd;
++
++ if ((ioc->sh == NULL) || (ioc->sh->hostdata == NULL))
++ return 0;
++
++ switch (reset_phase) {
++ case MPT_IOC_SETUP_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
++ break;
++ case MPT_IOC_PRE_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
++ hd = shost_priv(ioc->sh);
++ mptscsih_flush_running_cmds(hd);
++ break;
++ case MPT_IOC_POST_RESET:
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
++ if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ ioc->internal_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
++ complete(&ioc->internal_cmds.done);
++ }
++ break;
++ default:
++ break;
++ }
++ return 1; /* currently means nothing really */
++}
++
++void
++mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
++{
++ char *desc;
++
++ switch (response_code) {
++ case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
++ desc = "The task completed.";
++ break;
++ case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
++ desc = "The IOC received an invalid frame status.";
++ break;
++ case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
++ desc = "The task type is not supported.";
++ break;
++ case MPI_SCSITASKMGMT_RSP_TM_FAILED:
++ desc = "The requested task failed.";
++ break;
++ case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
++ desc = "The task completed successfully.";
++ break;
++ case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
++ desc = "The LUN request is invalid.";
++ break;
++ case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
++ desc = "The task is in the IOC queue and has not been sent to target.";
++ break;
++ default:
++ desc = "unknown";
++ break;
++ }
++ printk(MYIOC_s_DEBUG_FMT "Response Code(0x%08x): F/W: %s\n",
++ ioc->name, response_code, desc);
++}
++
++static int
++mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type, SCSITaskMgmtReply_t *pScsiTmReply)
++{
++ u16 iocstatus;
++ u32 termination_count;
++ int retval;
++
++ if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
++ retval = FAILED;
++ goto out;
++ }
++
++ DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
++
++ iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
++ termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
++
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
++ "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
++ "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
++ pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
++ le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
++ termination_count));
++
++ if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
++ pScsiTmReply->ResponseCode)
++ mptscsih_taskmgmt_response_code(ioc,
++ pScsiTmReply->ResponseCode);
++
++ if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
++ retval = 0;
++ goto out;
++ }
++
++ retval = FAILED;
++ if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
++ if (termination_count == 1)
++ retval = 0;
++ goto out;
++ }
++
++ if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
++ iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
++ retval = 0;
++
++ out:
++ return retval;
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/**
++ * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @mf: Pointer to SCSI task mgmt request frame
++ * @mr: Pointer to SCSI task mgmt reply frame
++ *
++ * This routine is called from mptbase.c::mpt_interrupt() at the completion
++ * of any SCSI task management request.
++ * This routine is registered with the MPT (base) driver at driver
++ * load/init time via the mpt_register() API call.
++ *
++ * Returns 1 indicating alloc'd request frame ptr should be freed.
++ **/
++int
++mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
++{
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed (mf=%p, mr=%p)\n",
++ ioc->name, mf, mr));
++
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
++
++ if (!mr)
++ goto out;
++
++ ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
++ memcpy(ioc->taskmgmt_cmds.reply, mr,
++ min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
++ out:
++ if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
++ complete(&ioc->taskmgmt_cmds.done);
++ return 1;
++ }
++ return 0;
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/**
++ * mptscsih_IssueTaskMgmt - Generic send Task Management function.
++ * @hd: Pointer to MPT_SCSI_HOST structure
++ * @type: Task Management type
++ * @channel: channel number for task management
++ * @id: Logical Target ID for reset (if appropriate)
++ * @lun: Logical Unit for reset (if appropriate)
++ * @ctx2abort: Context for the task to be aborted (if appropriate)
++ * @timeout: timeout for task management control
++ *
++ * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
++ * or a non-interrupt thread. In the former, must not call schedule().
++ *
++ * Not all fields are meaningfull for all task types.
++ *
++ * Returns 0 for SUCCESS, or FAILED.
++ *
++ **/
++int
++mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout)
++{
++ MPT_FRAME_HDR *mf = NULL;
++ SCSITaskMgmt_t *pScsiTm;
++ int ii;
++ int retval;
++ MPT_ADAPTER *ioc = hd->ioc;
++ unsigned long timeleft;
++ u8 issue_hard_reset;
++ u32 ioc_raw_state;
++ unsigned long time_count;
++
++ issue_hard_reset = 0;
++ ioc_raw_state = mpt_GetIocState(ioc, 0);
++
++ if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
++ printk(MYIOC_s_WARN_FMT
++ "TaskMgmt type=%x: IOC Not operational (0x%x)!\n",
++ ioc->name, type, ioc_raw_state);
++ printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
++ ioc->name, __FUNCTION__);
++ if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
++ printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset "
++ "FAILED!!\n", ioc->name);
++ return 0;
++ }
++
++ if (ioc_raw_state & MPI_DOORBELL_ACTIVE) {
++ printk(MYIOC_s_WARN_FMT
++ "TaskMgmt type=%x: ioc_state: "
++ "DOORBELL_ACTIVE (0x%x)!\n",
++ ioc->name, type, ioc_raw_state);
++ return FAILED;
++ }
++
++ mutex_lock(&ioc->taskmgmt_cmds.mutex);
++ if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ retval = FAILED;
++ goto out;
++ }
++
++ /* Return Fail to calling function if no message frames available.
++ */
++ if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt no msg frames!!\n",
++ ioc->name));
++ retval = FAILED;
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ goto out;
++ }
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
++ ioc->name, mf));
++
++ /* Format the Request
++ */
++ pScsiTm = (SCSITaskMgmt_t *) mf;
++ pScsiTm->TargetID = id;
++ pScsiTm->Bus = channel;
++ pScsiTm->ChainOffset = 0;
++ pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
++
++ pScsiTm->Reserved = 0;
++ pScsiTm->TaskType = type;
++ pScsiTm->Reserved1 = 0;
++ pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
++ ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
++
++ int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
++
++ for (ii=0; ii < 7; ii++)
++ pScsiTm->Reserved2[ii] = 0;
++
++ pScsiTm->TaskMsgContext = ctx2abort;
++
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) "
++ "task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort,
++ type, timeout));
++
++ DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
++
++ INITIALIZE_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))
++ mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
++ else {
++ retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
++ sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
++ if (retval) {
++ dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt handshake FAILED!"
++ " (mf=%p, rc=%d) \n", ioc->name, mf, retval));
++ mpt_free_msg_frame(ioc, mf);
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ goto out;
++ }
++ }
++
++ timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
++ if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ retval = FAILED;
++ dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
++ "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf));
++ mpt_clear_taskmgmt_in_progress_flag(ioc);
++ if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
++ goto out;
++ issue_hard_reset = 1;
++ goto out;
++ }
++
++ retval = mptscsih_taskmgmt_reply(ioc, type,
++ (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply);
++
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "TaskMgmt completed (%d seconds)\n",
++ ioc->name, jiffies_to_msecs(jiffies - time_count)/1000));
++
++ out:
++
++ CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
++ if(issue_hard_reset) {
++ printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
++ ioc->name, __FUNCTION__);
++ if ((retval = mpt_SoftResetHandler(ioc, CAN_SLEEP)) != 0)
++ retval = mpt_HardResetHandler(ioc, CAN_SLEEP);
++ mpt_free_msg_frame(ioc, mf);
++ }
++
++ retval = (retval == 0) ? 0 : FAILED;
++ mutex_unlock(&ioc->taskmgmt_cmds.mutex);
++ return retval;
++}
++
++static int
++mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
++{
++ switch (ioc->bus_type) {
++ case FC:
++ return 40;
++ case SAS:
++ return 30;
+ case SPI:
+ default:
+- return 2;
++ return 10;
+ }
+ }
+
+@@ -1786,7 +1973,7 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
+ int retval;
+ VirtDevice *vdevice;
+ ulong sn = SCpnt->serial_number;
+- MPT_ADAPTER *ioc;
++ MPT_ADAPTER *ioc;
+
+ /* If we can't locate our host adapter structure, return FAILED status.
+ */
+@@ -1810,7 +1997,21 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
+ ioc->name, SCpnt));
+ SCpnt->result = DID_NO_CONNECT << 16;
+ SCpnt->scsi_done(SCpnt);
+- retval = 0;
++ retval = SUCCESS;
++ goto out;
++ }
++
++ /* Find this command
++ */
++ if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
++ /* Cmd not found in ScsiLookup.
++ * Do OS callback.
++ */
++ SCpnt->result = DID_RESET << 16;
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "task abort: command not in the active list! (sc=%p)\n",
++ ioc->name, SCpnt));
++ retval = SUCCESS;
+ goto out;
+ }
+
+@@ -1825,27 +2026,23 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
+ goto out;
+ }
+
+- /* Find this command
++ /* Task aborts are not supported for volumes.
+ */
+- if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
+- /* Cmd not found in ScsiLookup.
+- * Do OS callback.
+- */
++ if (vdevice->vtarget->raidVolume) {
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "task abort: raid volume (sc=%p)\n",
++ ioc->name, SCpnt));
+ SCpnt->result = DID_RESET << 16;
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
+- "Command not in the active list! (sc=%p)\n", ioc->name,
+- SCpnt));
+- retval = 0;
+- goto out;
+- }
+-
+- if (hd->resetPending) {
+ retval = FAILED;
+ goto out;
+ }
+
+- if (hd->timeouts < -1)
+- hd->timeouts++;
++ if(mpt_fwfault_debug)
++ mpt_halt_firmware(ioc);
++
++ if (ioc->timeouts < -1)
++ ioc->timeouts++;
++
+
+ /* Most important! Set TaskMsgContext to SCpnt's MsgContext!
+ * (the IO to be ABORT'd)
+@@ -1856,25 +2053,31 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
+ */
+ mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx);
+ ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
+-
+- hd->abortSCpnt = SCpnt;
+-
+- retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
++ mptscsih_IssueTaskMgmt(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
+ vdevice->vtarget->channel, vdevice->vtarget->id, vdevice->lun,
+ ctx2abort, mptscsih_get_tm_timeout(ioc));
+
++ /* check to see whether command actually completed and/or
++ * terminated
++ */
+ if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx &&
+- SCpnt->serial_number == sn)
++ SCpnt->serial_number == sn) {
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "task abort: command still in active list! (sc=%p)\n",
++ ioc->name, SCpnt));
+ retval = FAILED;
++ } else {
++ dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "task abort: command cleared from active list! (sc=%p)\n",
++ ioc->name, SCpnt));
++ retval = SUCCESS;
++ }
+
+ out:
+ printk(MYIOC_s_INFO_FMT "task abort: %s (sc=%p)\n",
+- ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
++ ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED" ), SCpnt);
+
+- if (retval == 0)
+- return SUCCESS;
+- else
+- return FAILED;
++ return retval;
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+@@ -1907,14 +2110,9 @@ mptscsih_dev_reset(struct scsi_cmnd * SC
+ ioc->name, SCpnt);
+ scsi_print_command(SCpnt);
+
+- if (hd->resetPending) {
+- retval = FAILED;
+- goto out;
+- }
+-
+ vdevice = SCpnt->device->hostdata;
+ if (!vdevice || !vdevice->vtarget) {
+- retval = 0;
++ retval = SUCCESS;
+ goto out;
+ }
+
+@@ -1925,12 +2123,12 @@ mptscsih_dev_reset(struct scsi_cmnd * SC
+ goto out;
+ }
+
+- retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
+- vdevice->vtarget->channel, vdevice->vtarget->id, 0, 0,
+- mptscsih_get_tm_timeout(ioc));
++ retval = mptscsih_IssueTaskMgmt(hd,
++ MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, vdevice->vtarget->channel,
++ vdevice->vtarget->id, 0, 0, mptscsih_get_tm_timeout(ioc));
+
+ out:
+- printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
++ printk(MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
+ ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
+
+ if (retval == 0)
+@@ -1955,12 +2153,12 @@ mptscsih_bus_reset(struct scsi_cmnd * SC
+ MPT_SCSI_HOST *hd;
+ int retval;
+ VirtDevice *vdevice;
+- MPT_ADAPTER *ioc;
++ MPT_ADAPTER *ioc;
+
+ /* If we can't locate our host adapter structure, return FAILED status.
+ */
+ if ((hd = shost_priv(SCpnt->device->host)) == NULL){
+- printk(KERN_ERR MYNAM ": bus reset: "
++ printk(KERN_ERR MYNAM ": bus_reset: "
+ "Can't locate host! (sc=%p)\n", SCpnt);
+ return FAILED;
+ }
+@@ -1970,11 +2168,13 @@ mptscsih_bus_reset(struct scsi_cmnd * SC
+ ioc->name, SCpnt);
+ scsi_print_command(SCpnt);
+
+- if (hd->timeouts < -1)
+- hd->timeouts++;
++ if (ioc->timeouts < -1)
++ ioc->timeouts++;
+
+ vdevice = SCpnt->device->hostdata;
+- retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
++ if (!vdevice || !vdevice->vtarget)
++ return SUCCESS;
++ retval = mptscsih_IssueTaskMgmt(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
+ vdevice->vtarget->channel, 0, 0, 0, mptscsih_get_tm_timeout(ioc));
+
+ printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
+@@ -1999,8 +2199,9 @@ int
+ mptscsih_host_reset(struct scsi_cmnd *SCpnt)
+ {
+ MPT_SCSI_HOST * hd;
+- int retval;
+- MPT_ADAPTER *ioc;
++ int status = SUCCESS;
++ MPT_ADAPTER *ioc;
++ int retval;
+
+ /* If we can't locate the host to reset, then we failed. */
+ if ((hd = shost_priv(SCpnt->device->host)) == NULL){
+@@ -2011,237 +2212,29 @@ mptscsih_host_reset(struct scsi_cmnd *SC
+
+ ioc = hd->ioc;
+ printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
+- ioc->name, SCpnt);
++ ioc->name, SCpnt);
+
+ /* If our attempts to reset the host failed, then return a failed
+ * status. The host will be taken off line by the SCSI mid-layer.
+ */
+- if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0) {
+- retval = FAILED;
+- } else {
+- /* Make sure TM pending is cleared and TM state is set to
+- * NONE.
+- */
+- retval = 0;
+- hd->tmPending = 0;
+- hd->tmState = TM_STATE_NONE;
+- }
++ if ((retval = mpt_SoftResetHandler(ioc, CAN_SLEEP)) != 0)
++ retval = mpt_HardResetHandler(ioc, CAN_SLEEP);
++
++ if (retval < 0)
++ status = FAILED;
++ else
++ status = SUCCESS;
+
+ printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
+ ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
+
+- return retval;
+-}
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/**
+- * mptscsih_tm_pending_wait - wait for pending task management request to complete
+- * @hd: Pointer to MPT host structure.
+- *
+- * Returns {SUCCESS,FAILED}.
+- */
+-static int
+-mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd)
+-{
+- unsigned long flags;
+- int loop_count = 4 * 10; /* Wait 10 seconds */
+- int status = FAILED;
+- MPT_ADAPTER *ioc = hd->ioc;
+-
+- do {
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- if (hd->tmState == TM_STATE_NONE) {
+- hd->tmState = TM_STATE_IN_PROGRESS;
+- hd->tmPending = 1;
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+- status = SUCCESS;
+- break;
+- }
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+- msleep(250);
+- } while (--loop_count);
+-
+ return status;
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+- * mptscsih_tm_wait_for_completion - wait for completion of TM task
+- * @hd: Pointer to MPT host structure.
+- * @timeout: timeout value
+- *
+- * Returns {SUCCESS,FAILED}.
+- */
+-static int
+-mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout )
+-{
+- unsigned long flags;
+- int loop_count = 4 * timeout;
+- int status = FAILED;
+- MPT_ADAPTER *ioc = hd->ioc;
+-
+- do {
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- if(hd->tmPending == 0) {
+- status = SUCCESS;
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+- break;
+- }
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+- msleep(250);
+- } while (--loop_count);
+-
+- return status;
+-}
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-static void
+-mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
+-{
+- char *desc;
+-
+- switch (response_code) {
+- case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
+- desc = "The task completed.";
+- break;
+- case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
+- desc = "The IOC received an invalid frame status.";
+- break;
+- case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
+- desc = "The task type is not supported.";
+- break;
+- case MPI_SCSITASKMGMT_RSP_TM_FAILED:
+- desc = "The requested task failed.";
+- break;
+- case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
+- desc = "The task completed successfully.";
+- break;
+- case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
+- desc = "The LUN request is invalid.";
+- break;
+- case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
+- desc = "The task is in the IOC queue and has not been sent to target.";
+- break;
+- default:
+- desc = "unknown";
+- break;
+- }
+- printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
+- ioc->name, response_code, desc);
+-}
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/**
+- * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
+- * @ioc: Pointer to MPT_ADAPTER structure
+- * @mf: Pointer to SCSI task mgmt request frame
+- * @mr: Pointer to SCSI task mgmt reply frame
+- *
+- * This routine is called from mptbase.c::mpt_interrupt() at the completion
+- * of any SCSI task management request.
+- * This routine is registered with the MPT (base) driver at driver
+- * load/init time via the mpt_register() API call.
+- *
+- * Returns 1 indicating alloc'd request frame ptr should be freed.
+- **/
+-int
+-mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
+-{
+- SCSITaskMgmtReply_t *pScsiTmReply;
+- SCSITaskMgmt_t *pScsiTmReq;
+- MPT_SCSI_HOST *hd;
+- unsigned long flags;
+- u16 iocstatus;
+- u8 tmType;
+- u32 termination_count;
+-
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed (mf=%p,mr=%p)\n",
+- ioc->name, mf, mr));
+- if (!ioc->sh) {
+- dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
+- "TaskMgmt Complete: NULL Scsi Host Ptr\n", ioc->name));
+- return 1;
+- }
+-
+- if (mr == NULL) {
+- dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
+- "ERROR! TaskMgmt Reply: NULL Request %p\n", ioc->name, mf));
+- return 1;
+- }
+-
+- hd = shost_priv(ioc->sh);
+- pScsiTmReply = (SCSITaskMgmtReply_t*)mr;
+- pScsiTmReq = (SCSITaskMgmt_t*)mf;
+- tmType = pScsiTmReq->TaskType;
+- iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
+- termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
+-
+- if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
+- pScsiTmReply->ResponseCode)
+- mptscsih_taskmgmt_response_code(ioc,
+- pScsiTmReply->ResponseCode);
+- DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
+-
+-#ifdef CONFIG_FUSION_LOGGING
+- if ((ioc->debug_level & MPT_DEBUG_REPLY) ||
+- (ioc->debug_level & MPT_DEBUG_TM ))
+- printk("%s: ha=%d [%d:%d:0] task_type=0x%02X "
+- "iocstatus=0x%04X\n\tloginfo=0x%08X response_code=0x%02X "
+- "term_cmnds=%d\n", __func__, ioc->id, pScsiTmReply->Bus,
+- pScsiTmReply->TargetID, pScsiTmReq->TaskType,
+- le16_to_cpu(pScsiTmReply->IOCStatus),
+- le32_to_cpu(pScsiTmReply->IOCLogInfo),pScsiTmReply->ResponseCode,
+- le32_to_cpu(pScsiTmReply->TerminationCount));
+-#endif
+- if (!iocstatus) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT " TaskMgmt SUCCESS\n", ioc->name));
+- hd->abortSCpnt = NULL;
+- goto out;
+- }
+-
+- /* Error? (anything non-zero?) */
+-
+- /* clear flags and continue.
+- */
+- switch (tmType) {
+-
+- case MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
+- if (termination_count == 1)
+- iocstatus = MPI_IOCSTATUS_SCSI_TASK_TERMINATED;
+- hd->abortSCpnt = NULL;
+- break;
+-
+- case MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS:
+-
+- /* If an internal command is present
+- * or the TM failed - reload the FW.
+- * FC FW may respond FAILED to an ABORT
+- */
+- if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED ||
+- hd->cmdPtr)
+- if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
+- printk(MYIOC_s_WARN_FMT " Firmware Reload FAILED!!\n", ioc->name);
+- break;
+-
+- case MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
+- default:
+- break;
+- }
+-
+- out:
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- hd->tmPending = 0;
+- hd->tmState = TM_STATE_NONE;
+- hd->tm_iocstatus = iocstatus;
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+-
+- return 1;
+-}
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
+ * This is anyones guess quite frankly.
+- */
++ **/
+ int
+ mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
+ sector_t capacity, int geom[])
+@@ -2278,40 +2271,82 @@ mptscsih_bios_param(struct scsi_device *
+ return 0;
+ }
+
+-/* Search IOC page 3 to determine if this is hidden physical disk
++/**
++ * Search IOC page 3 to determine if this is hidden physical disk
+ *
+- */
++ **/
+ int
+ mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
+ {
+ struct inactive_raid_component_info *component_info;
+- int i;
++ u8 i, j;
++ RaidPhysDiskPage1_t *phys_disk;
+ int rc = 0;
++ int num_paths;
+
+ if (!ioc->raid_data.pIocPg3)
+ goto out;
+ for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
+ if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
+- (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
++ (channel ==
++ ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
+ rc = 1;
+ goto out;
+ }
+ }
+
++ if (ioc->bus_type != SAS)
++ goto out;
++
++ /*
++ * Check if dual path
++ */
++ for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
++ num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
++ ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
++ if (num_paths < 2)
++ continue;
++ phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
++ (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
++ if (!phys_disk)
++ continue;
++ if ((mpt_raid_phys_disk_pg1(ioc,
++ ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
++ phys_disk))) {
++ kfree(phys_disk);
++ continue;
++ }
++ for (j = 0; j < num_paths; j++) {
++ if ((phys_disk->Path[j].Flags &
++ MPI_RAID_PHYSDISK1_FLAG_INVALID))
++ continue;
++ if ((phys_disk->Path[j].Flags &
++ MPI_RAID_PHYSDISK1_FLAG_BROKEN))
++ continue;
++ if ((id == phys_disk->Path[j].PhysDiskID) &&
++ (channel == phys_disk->Path[j].PhysDiskBus)) {
++ rc = 1;
++ kfree(phys_disk);
++ goto out;
++ }
++ }
++ kfree(phys_disk);
++ }
++
+ /*
+ * Check inactive list for matching phys disks
+ */
+ if (list_empty(&ioc->raid_data.inactive_list))
+ goto out;
+
+- mutex_lock(&ioc->raid_data.inactive_list_mutex);
++ down(&ioc->raid_data.inactive_list_mutex);
+ list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
+ list) {
+ if ((component_info->d.PhysDiskID == id) &&
+ (component_info->d.PhysDiskBus == channel))
+ rc = 1;
+ }
+- mutex_unlock(&ioc->raid_data.inactive_list_mutex);
++ up(&ioc->raid_data.inactive_list_mutex);
+
+ out:
+ return rc;
+@@ -2322,43 +2357,84 @@ u8
+ mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
+ {
+ struct inactive_raid_component_info *component_info;
+- int i;
++ int i,j;
++ RaidPhysDiskPage1_t *phys_disk;
+ int rc = -ENXIO;
++ u8 num_paths;
+
+ if (!ioc->raid_data.pIocPg3)
+ goto out;
+ for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
+ if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
+- (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
++ (channel ==
++ ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
+ rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
+ goto out;
+ }
+ }
+
++ if (ioc->bus_type != SAS)
++ goto out;
++
++ /*
++ * Check if dual path
++ */
++ for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
++ num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
++ ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
++ if (num_paths < 2)
++ continue;
++ phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
++ (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
++ if (!phys_disk)
++ continue;
++ if ((mpt_raid_phys_disk_pg1(ioc,
++ ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
++ phys_disk))) {
++ kfree(phys_disk);
++ continue;
++ }
++ for (j = 0; j < num_paths; j++) {
++ if ((phys_disk->Path[j].Flags &
++ MPI_RAID_PHYSDISK1_FLAG_INVALID))
++ continue;
++ if ((phys_disk->Path[j].Flags &
++ MPI_RAID_PHYSDISK1_FLAG_BROKEN))
++ continue;
++ if ((id == phys_disk->Path[j].PhysDiskID) &&
++ (channel == phys_disk->Path[j].PhysDiskBus)) {
++ rc = phys_disk->PhysDiskNum;
++ kfree(phys_disk);
++ goto out;
++ }
++ }
++ kfree(phys_disk);
++ }
++
+ /*
+ * Check inactive list for matching phys disks
+ */
+ if (list_empty(&ioc->raid_data.inactive_list))
+ goto out;
+
+- mutex_lock(&ioc->raid_data.inactive_list_mutex);
++ down(&ioc->raid_data.inactive_list_mutex);
+ list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
+ list) {
+ if ((component_info->d.PhysDiskID == id) &&
+ (component_info->d.PhysDiskBus == channel))
+ rc = component_info->d.PhysDiskNum;
+ }
+- mutex_unlock(&ioc->raid_data.inactive_list_mutex);
++ up(&ioc->raid_data.inactive_list_mutex);
+
+ out:
+ return rc;
+ }
+ EXPORT_SYMBOL(mptscsih_raid_id_to_num);
+
+-/*
++/**
+ * OS entry point to allow for host driver to free allocated memory
+ * Called if no device present or device being unloaded
+- */
++ **/
+ void
+ mptscsih_slave_destroy(struct scsi_device *sdev)
+ {
+@@ -2370,23 +2446,25 @@ mptscsih_slave_destroy(struct scsi_devic
+
+ starget = scsi_target(sdev);
+ vtarget = starget->hostdata;
++ vtarget->num_luns--;
+ vdevice = sdev->hostdata;
++ if (!vdevice)
++ return;
+
+ mptscsih_search_running_cmds(hd, vdevice);
+- vtarget->num_luns--;
+- mptscsih_synchronize_cache(hd, vdevice);
++ mptscsih_synchronize_cache(sdev, hd, vdevice);
+ kfree(vdevice);
+ sdev->hostdata = NULL;
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptscsih_change_queue_depth - This function will set a devices queue depth
+ * @sdev: per scsi_device pointer
+ * @qdepth: requested queue depth
+ *
+ * Adding support for new 'change_queue_depth' api.
+-*/
++ **/
+ int
+ mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
+ {
+@@ -2401,15 +2479,16 @@ mptscsih_change_queue_depth(struct scsi_
+ vtarget = starget->hostdata;
+
+ if (ioc->bus_type == SPI) {
+- if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
+- max_depth = 1;
+- else if (sdev->type == TYPE_DISK &&
+- vtarget->minSyncFactor <= MPT_ULTRA160)
++ if (sdev->type == TYPE_DISK &&
++ vtarget->minSyncFactor <= MPT_ULTRA160)
+ max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
+ else
+ max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
+ } else
+- max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
++ max_depth = ioc->sh->can_queue;
++
++ if (!sdev->tagged_supported)
++ max_depth = 1;
+
+ if (qdepth > max_depth)
+ qdepth = max_depth;
+@@ -2419,15 +2498,24 @@ mptscsih_change_queue_depth(struct scsi_
+ tagged = MSG_SIMPLE_TAG;
+
+ scsi_adjust_queue_depth(sdev, tagged, qdepth);
++
++ if (sdev->inquiry_len > 7)
++ sdev_printk(KERN_INFO, sdev, MYIOC_s_FMT "qdepth=%d, "
++ "tagged=%d, simple=%d, ordered=%d, scsi_level=%d, "
++ "cmd_que=%d\n", ioc->name, sdev->queue_depth,
++ sdev->tagged_supported, sdev->simple_tags,
++ sdev->ordered_tags, sdev->scsi_level,
++ (sdev->inquiry[7] & 2) >> 1);
++
+ return sdev->queue_depth;
+ }
+
+-/*
++/**
+ * OS entry point to adjust the queue_depths on a per-device basis.
+ * Called once per device the bus scan. Use it to force the queue_depth
+ * member to 1 if a device does not support Q tags.
+ * Return non-zero if fails.
+- */
++ **/
+ int
+ mptscsih_slave_configure(struct scsi_device *sdev)
+ {
+@@ -2436,52 +2524,37 @@ mptscsih_slave_configure(struct scsi_dev
+ VirtDevice *vdevice;
+ struct scsi_target *starget;
+ MPT_SCSI_HOST *hd = shost_priv(sh);
+- MPT_ADAPTER *ioc = hd->ioc;
++ MPT_ADAPTER *ioc = hd->ioc;
+
+ starget = scsi_target(sdev);
+ vtarget = starget->hostdata;
+ vdevice = sdev->hostdata;
++ vdevice->configured_lun = 1;
+
+- dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "device @ %p, channel=%d, id=%d, lun=%d\n",
+- ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
+- if (ioc->bus_type == SPI)
+- dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "sdtr %d wdtr %d ppr %d inq length=%d\n",
+- ioc->name, sdev->sdtr, sdev->wdtr,
+- sdev->ppr, sdev->inquiry_len));
++ if ((ioc->bus_type != SAS) && (sdev->id > sh->max_id)) {
++ /* error case, should never happen */
++ scsi_adjust_queue_depth(sdev, 0, 1);
++ goto slave_configure_exit;
++ }
+
+- vdevice->configured_lun = 1;
+- mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
++ mptscsih_change_queue_depth(sdev, ioc->sdev_queue_depth);
+
+- dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Queue depth=%d, tflags=%x\n",
+- ioc->name, sdev->queue_depth, vtarget->tflags));
+-
+- if (ioc->bus_type == SPI)
+- dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
+- ioc->name, vtarget->negoFlags, vtarget->maxOffset,
+- vtarget->minSyncFactor));
+-
+- dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "tagged %d, simple %d, ordered %d\n",
+- ioc->name,sdev->tagged_supported, sdev->simple_tags,
+- sdev->ordered_tags));
++slave_configure_exit:
+
+ return 0;
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * Private routines...
+ */
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/* Utility function to copy sense data from the scsi_cmnd buffer
++/**
++ * Utility function to copy sense data from the scsi_cmnd buffer
+ * to the FC and SCSI target structures.
+ *
+- */
++ **/
+ static void
+ mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
+ {
+@@ -2521,31 +2594,31 @@ mptscsih_copy_sense_data(struct scsi_cmn
+ ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
+
+ ioc->eventContext++;
+- if (ioc->pcidev->vendor ==
+- PCI_VENDOR_ID_IBM) {
+- mptscsih_issue_sep_command(ioc,
+- vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
+- vdevice->vtarget->tflags |=
+- MPT_TARGET_FLAGS_LED_ON;
++ if (ioc->pcidev->vendor == PCI_VENDOR_ID_IBM) {
++ mptscsih_issue_sep_command(ioc, vdevice->vtarget,
++ MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
++ vdevice->vtarget->tflags |= MPT_TARGET_FLAGS_LED_ON;
+ }
+ }
+ }
+ } else {
+ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
+- ioc->name));
++ ioc->name));
+ }
+ }
+
+ /**
+ * mptscsih_get_scsi_lookup
+- * @ioc: Pointer to MPT_ADAPTER structure
+- * @i: index into the array
+ *
+ * retrieves scmd entry from ScsiLookup[] array list
+ *
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @i: index into the array
++ *
+ * Returns the scsi_cmd pointer
++ *
+ **/
+-static struct scsi_cmnd *
++struct scsi_cmnd *
+ mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
+ {
+ unsigned long flags;
+@@ -2560,12 +2633,14 @@ mptscsih_get_scsi_lookup(MPT_ADAPTER *io
+
+ /**
+ * mptscsih_getclear_scsi_lookup
+- * @ioc: Pointer to MPT_ADAPTER structure
+- * @i: index into the array
+ *
+ * retrieves and clears scmd entry from ScsiLookup[] array list
+ *
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @i: index into the array
++ *
+ * Returns the scsi_cmd pointer
++ *
+ **/
+ static struct scsi_cmnd *
+ mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
+@@ -2602,10 +2677,14 @@ mptscsih_set_scsi_lookup(MPT_ADAPTER *io
+ }
+
+ /**
+- * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
++ * SCPNT_TO_LOOKUP_IDX
++ *
++ * search's for a given scmd in the ScsiLookup[] array list
++ *
+ * @ioc: Pointer to MPT_ADAPTER structure
+- * @sc: scsi_cmnd pointer
+- */
++ * @scmd: scsi_cmnd pointer
++ *
++ **/
+ static int
+ SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
+ {
+@@ -2627,380 +2706,226 @@ SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, st
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ int
+-mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
++mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
+ {
+- MPT_SCSI_HOST *hd;
+- unsigned long flags;
+-
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- ": IOC %s_reset routed to SCSI host driver!\n",
+- ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
+- reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
+-
+- /* If a FW reload request arrives after base installed but
+- * before all scsi hosts have been attached, then an alt_ioc
+- * may have a NULL sh pointer.
+- */
+- if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
+- return 0;
+- else
+- hd = shost_priv(ioc->sh);
+-
+- if (reset_phase == MPT_IOC_SETUP_RESET) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Setup-Diag Reset\n", ioc->name));
+-
+- /* Clean Up:
+- * 1. Set Hard Reset Pending Flag
+- * All new commands go to doneQ
+- */
+- hd->resetPending = 1;
+-
+- } else if (reset_phase == MPT_IOC_PRE_RESET) {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Pre-Diag Reset\n", ioc->name));
+-
+- /* 2. Flush running commands
+- * Clean ScsiLookup (and associated memory)
+- * AND clean mytaskQ
+- */
++ u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
+
+- /* 2b. Reply to OS all known outstanding I/O commands.
+- */
+- mptscsih_flush_running_cmds(hd);
++ devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "MPT event (=%02Xh) routed to SCSI host driver!\n",
++ ioc->name, event));
+
+- /* 2c. If there was an internal command that
+- * has not completed, configuration or io request,
+- * free these resources.
+- */
+- if (hd->cmdPtr) {
+- del_timer(&hd->timer);
+- mpt_free_msg_frame(ioc, hd->cmdPtr);
+- }
++ if ((event == MPI_EVENT_IOC_BUS_RESET ||
++ event == MPI_EVENT_EXT_BUS_RESET) &&
++ (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
++ ioc->soft_resets++;
+
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Pre-Reset complete.\n", ioc->name));
++ return 1; /* currently means nothing really */
++}
+
+- } else {
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Post-Diag Reset\n", ioc->name));
++int
++mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
++{
++ MPT_ADAPTER *ioc = hd->ioc;
++ MpiRaidActionRequest_t *pReq;
++ MPT_FRAME_HDR *mf;
++ int ret;
++ unsigned long timeleft;
+
+- /* Once a FW reload begins, all new OS commands are
+- * redirected to the doneQ w/ a reset status.
+- * Init all control structures.
+- */
++ mutex_lock(&ioc->internal_cmds.mutex);
+
+- /* 2. Chain Buffer initialization
+- */
++ /* Get and Populate a free Frame
++ */
++ if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
++ dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!\n",
++ ioc->name, __FUNCTION__));
++ ret = -EAGAIN;
++ goto out;
++ }
++ pReq = (MpiRaidActionRequest_t *)mf;
++ if (quiesce)
++ pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
++ else
++ pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
++ pReq->Reserved1 = 0;
++ pReq->ChainOffset = 0;
++ pReq->Function = MPI_FUNCTION_RAID_ACTION;
++ pReq->VolumeID = id;
++ pReq->VolumeBus = channel;
++ pReq->PhysDiskNum = 0;
++ pReq->MsgFlags = 0;
++ pReq->Reserved2 = 0;
++ pReq->ActionDataWord = 0; /* Reserved for this action */
+
+- /* 4. Renegotiate to all devices, if SPI
+- */
++ ioc->add_sge((char *)&pReq->ActionDataSGE,
++ MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
+
+- /* 5. Enable new commands to be posted
+- */
+- spin_lock_irqsave(&ioc->FreeQlock, flags);
+- hd->tmPending = 0;
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+- hd->resetPending = 0;
+- hd->tmState = TM_STATE_NONE;
++ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
++ ioc->name, pReq->Action, channel, id));
+
+- /* 6. If there was an internal command,
+- * wake this process up.
+- */
+- if (hd->cmdPtr) {
+- /*
+- * Wake up the original calling thread
+- */
+- hd->pLocal = &hd->localReply;
+- hd->pLocal->completion = MPT_SCANDV_DID_RESET;
+- hd->scandv_wait_done = 1;
+- wake_up(&hd->scandv_waitq);
+- hd->cmdPtr = NULL;
++ INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
++ mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
++ timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
++ if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ ret = -ETIME;
++ dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
++ ioc->name, __FUNCTION__));
++ if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
++ goto out;
++ if (!timeleft) {
++ printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
++ ioc->name, __FUNCTION__);
++ if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
++ mpt_HardResetHandler(ioc, CAN_SLEEP);
++ mpt_free_msg_frame(ioc, mf);
+ }
+-
+- dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Post-Reset complete.\n", ioc->name));
+-
++ goto out;
+ }
+
+- return 1; /* currently means nothing really */
++ ret = ioc->internal_cmds.completion_code;
++
++ out:
++ CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
++ mutex_unlock(&ioc->internal_cmds.mutex);
++ return ret;
+ }
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-int
+-mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
++/**
++ * mptscsih_get_completion_code -
++ * @ioc: Pointer to MPT_ADAPTER structure
++ * @reply:
++ * @cmd:
++ *
++ **/
++static int
++mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
+ {
+- MPT_SCSI_HOST *hd;
+- u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
++ SCSIIOReply_t *pReply;
++ MpiRaidActionReply_t *pr;
++ u8 scsi_status;
++ u16 status;
++ int completion_code;
+
+- devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
+- ioc->name, event));
++ pReply = (SCSIIOReply_t *)reply;
++ status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
++ scsi_status = pReply->SCSIStatus;
+
+- if (ioc->sh == NULL ||
+- ((hd = shost_priv(ioc->sh)) == NULL))
+- return 1;
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh, IOCLogInfo=%08xh\n",
++ ioc->name, status, pReply->SCSIState, scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
+
+- switch (event) {
+- case MPI_EVENT_UNIT_ATTENTION: /* 03 */
+- /* FIXME! */
+- break;
+- case MPI_EVENT_IOC_BUS_RESET: /* 04 */
+- case MPI_EVENT_EXT_BUS_RESET: /* 05 */
+- if (hd && (ioc->bus_type == SPI) && (hd->soft_resets < -1))
+- hd->soft_resets++;
+- break;
+- case MPI_EVENT_LOGOUT: /* 09 */
+- /* FIXME! */
++ switch(status) {
++
++ case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
++ completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
+ break;
+
+- case MPI_EVENT_RESCAN: /* 06 */
++ case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
++ case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
++ case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
++ case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
++ completion_code = MPT_SCANDV_DID_RESET;
+ break;
+
+- /*
+- * CHECKME! Don't think we need to do
+- * anything for these, but...
+- */
+- case MPI_EVENT_LINK_STATUS_CHANGE: /* 07 */
+- case MPI_EVENT_LOOP_STATE_CHANGE: /* 08 */
+- /*
+- * CHECKME! Falling thru...
+- */
++ case MPI_IOCSTATUS_BUSY:
++ case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
++ completion_code = MPT_SCANDV_BUSY;
+ break;
+
+- case MPI_EVENT_INTEGRATED_RAID: /* 0B */
++ case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
++ case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
++ case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
++ if (pReply->Function == MPI_FUNCTION_CONFIG) {
++ completion_code = MPT_SCANDV_GOOD;
++ } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
++ pr = (MpiRaidActionReply_t *)reply;
++ if (le16_to_cpu(pr->ActionStatus) == MPI_RAID_ACTION_ASTATUS_SUCCESS)
++ completion_code = MPT_SCANDV_GOOD;
++ else
++ completion_code = MPT_SCANDV_SOME_ERROR;
++ } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
++ completion_code = MPT_SCANDV_SENSE;
++ else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
++ if (req->u.scsireq.CDB[0] == INQUIRY)
++ completion_code = MPT_SCANDV_ISSUE_SENSE;
++ else
++ completion_code = MPT_SCANDV_DID_RESET;
++ }
++ else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
++ completion_code = MPT_SCANDV_DID_RESET;
++ else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
++ completion_code = MPT_SCANDV_DID_RESET;
++ else if (scsi_status == MPI_SCSI_STATUS_BUSY)
++ completion_code = MPT_SCANDV_BUSY;
++ else
++ completion_code = MPT_SCANDV_GOOD;
+ break;
+
+- case MPI_EVENT_NONE: /* 00 */
+- case MPI_EVENT_LOG_DATA: /* 01 */
+- case MPI_EVENT_STATE_CHANGE: /* 02 */
+- case MPI_EVENT_EVENT_CHANGE: /* 0A */
++ case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
++ if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
++ completion_code = MPT_SCANDV_DID_RESET;
++ else
++ completion_code = MPT_SCANDV_SOME_ERROR;
++ break;
+ default:
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": Ignoring event (=%02Xh)\n",
+- ioc->name, event));
++ completion_code = MPT_SCANDV_SOME_ERROR;
+ break;
+- }
+
+- return 1; /* currently means nothing really */
+-}
++ } /* switch(status) */
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
+- * Bus Scan and Domain Validation functionality ...
+- */
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ " completionCode set to %08xh\n", ioc->name, completion_code));
++ return completion_code;
++}
+
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
+- * mptscsih_scandv_complete - Scan and DV callback routine registered
+- * to Fustion MPT (base) driver.
+- *
++/**
++ * mptscsih_scandv_complete -
+ * @ioc: Pointer to MPT_ADAPTER structure
+- * @mf: Pointer to original MPT request frame
+- * @mr: Pointer to MPT reply frame (NULL if TurboReply)
++ * @req:
++ * @reply:
+ *
+- * This routine is called from mpt.c::mpt_interrupt() at the completion
+- * of any SCSI IO request.
+- * This routine is registered with the Fusion MPT (base) driver at driver
+- * load/init time via the mpt_register() API call.
+- *
+- * Returns 1 indicating alloc'd request frame ptr should be freed.
+- *
+- * Remark: Sets a completion code and (possibly) saves sense data
+- * in the IOC member localReply structure.
+- * Used ONLY for DV and other internal commands.
+- */
++ **/
+ int
+-mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
++mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
+ {
+- MPT_SCSI_HOST *hd;
+ SCSIIORequest_t *pReq;
+- int completionCode;
++ SCSIIOReply_t *pReply;
++ u8 cmd;
+ u16 req_idx;
++ u8 *sense_data;
++ int sz;
+
+- hd = shost_priv(ioc->sh);
+-
+- if ((mf == NULL) ||
+- (mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))) {
+- printk(MYIOC_s_ERR_FMT
+- "ScanDvComplete, %s req frame ptr! (=%p)\n",
+- ioc->name, mf?"BAD":"NULL", (void *) mf);
+- goto wakeup;
+- }
+-
+- del_timer(&hd->timer);
+- req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
+- mptscsih_set_scsi_lookup(ioc, req_idx, NULL);
+- pReq = (SCSIIORequest_t *) mf;
++ ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
++ ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
++ if (!reply)
++ goto out;
+
+- if (mf != hd->cmdPtr) {
+- printk(MYIOC_s_WARN_FMT "ScanDvComplete (mf=%p, cmdPtr=%p, idx=%d)\n",
+- ioc->name, (void *)mf, (void *) hd->cmdPtr, req_idx);
++ pReply = (SCSIIOReply_t *) reply;
++ pReq = (SCSIIORequest_t *) req;
++ ioc->internal_cmds.completion_code =
++ mptscsih_get_completion_code(ioc, req, reply);
++ ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
++ memcpy(ioc->internal_cmds.reply, reply,
++ min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
++ cmd = reply->u.hdr.Function;
++ if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
++ (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
++ (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
++ req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
++ sense_data = ((u8 *)ioc->sense_buf_pool +
++ (req_idx * MPT_SENSE_BUFFER_ALLOC));
++ sz = min_t(int, pReq->SenseBufferLength,
++ MPT_SENSE_BUFFER_ALLOC);
++ memcpy(ioc->internal_cmds.sense, sense_data, sz);
+ }
+- hd->cmdPtr = NULL;
+-
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScanDvComplete (mf=%p,mr=%p,idx=%d)\n",
+- ioc->name, mf, mr, req_idx));
+-
+- hd->pLocal = &hd->localReply;
+- hd->pLocal->scsiStatus = 0;
+-
+- /* If target struct exists, clear sense valid flag.
+- */
+- if (mr == NULL) {
+- completionCode = MPT_SCANDV_GOOD;
+- } else {
+- SCSIIOReply_t *pReply;
+- u16 status;
+- u8 scsi_status;
+-
+- pReply = (SCSIIOReply_t *) mr;
+-
+- status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
+- scsi_status = pReply->SCSIStatus;
+-
+-
+- switch(status) {
+-
+- case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
+- completionCode = MPT_SCANDV_SELECTION_TIMEOUT;
+- break;
+-
+- case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
+- case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
+- case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
+- case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
+- completionCode = MPT_SCANDV_DID_RESET;
+- break;
+-
+- case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
+- case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
+- case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
+- if (pReply->Function == MPI_FUNCTION_CONFIG) {
+- ConfigReply_t *pr = (ConfigReply_t *)mr;
+- completionCode = MPT_SCANDV_GOOD;
+- hd->pLocal->header.PageVersion = pr->Header.PageVersion;
+- hd->pLocal->header.PageLength = pr->Header.PageLength;
+- hd->pLocal->header.PageNumber = pr->Header.PageNumber;
+- hd->pLocal->header.PageType = pr->Header.PageType;
+-
+- } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
+- /* If the RAID Volume request is successful,
+- * return GOOD, else indicate that
+- * some type of error occurred.
+- */
+- MpiRaidActionReply_t *pr = (MpiRaidActionReply_t *)mr;
+- if (le16_to_cpu(pr->ActionStatus) == MPI_RAID_ACTION_ASTATUS_SUCCESS)
+- completionCode = MPT_SCANDV_GOOD;
+- else
+- completionCode = MPT_SCANDV_SOME_ERROR;
+- memcpy(hd->pLocal->sense, pr, sizeof(hd->pLocal->sense));
+-
+- } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
+- u8 *sense_data;
+- int sz;
+-
+- /* save sense data in global structure
+- */
+- completionCode = MPT_SCANDV_SENSE;
+- hd->pLocal->scsiStatus = scsi_status;
+- sense_data = ((u8 *)ioc->sense_buf_pool +
+- (req_idx * MPT_SENSE_BUFFER_ALLOC));
+-
+- sz = min_t(int, pReq->SenseBufferLength,
+- SCSI_STD_SENSE_BYTES);
+- memcpy(hd->pLocal->sense, sense_data, sz);
+-
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Check Condition, sense ptr %p\n",
+- ioc->name, sense_data));
+- } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
+- if (pReq->CDB[0] == INQUIRY)
+- completionCode = MPT_SCANDV_ISSUE_SENSE;
+- else
+- completionCode = MPT_SCANDV_DID_RESET;
+- }
+- else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
+- completionCode = MPT_SCANDV_DID_RESET;
+- else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
+- completionCode = MPT_SCANDV_DID_RESET;
+- else {
+- completionCode = MPT_SCANDV_GOOD;
+- hd->pLocal->scsiStatus = scsi_status;
+- }
+- break;
+-
+- case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
+- if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
+- completionCode = MPT_SCANDV_DID_RESET;
+- else
+- completionCode = MPT_SCANDV_SOME_ERROR;
+- break;
+-
+- default:
+- completionCode = MPT_SCANDV_SOME_ERROR;
+- break;
+-
+- } /* switch(status) */
+-
+- } /* end of address reply case */
+-
+- hd->pLocal->completion = completionCode;
+-
+- /* MF and RF are freed in mpt_interrupt
+- */
+-wakeup:
+- /* Free Chain buffers (will never chain) in scan or dv */
+- //mptscsih_freeChainBuffers(ioc, req_idx);
+-
+- /*
+- * Wake up the original calling thread
+- */
+- hd->scandv_wait_done = 1;
+- wake_up(&hd->scandv_waitq);
+-
++ out:
++ if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
++ return 0;
++ ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
++ complete(&ioc->internal_cmds.done);
+ return 1;
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/* mptscsih_timer_expired - Call back for timer process.
+- * Used only for dv functionality.
+- * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
+- *
+- */
+-void
+-mptscsih_timer_expired(unsigned long data)
+-{
+- MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) data;
+- MPT_ADAPTER *ioc = hd->ioc;
+-
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Timer Expired! Cmd %p\n", ioc->name, hd->cmdPtr));
+-
+- if (hd->cmdPtr) {
+- MPIHeader_t *cmd = (MPIHeader_t *)hd->cmdPtr;
+-
+- if (cmd->Function == MPI_FUNCTION_SCSI_IO_REQUEST) {
+- /* Desire to issue a task management request here.
+- * TM requests MUST be single threaded.
+- * If old eh code and no TM current, issue request.
+- * If new eh code, do nothing. Wait for OS cmd timeout
+- * for bus reset.
+- */
+- } else {
+- /* Perform a FW reload */
+- if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0) {
+- printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
+- }
+- }
+- } else {
+- /* This should NEVER happen */
+- printk(MYIOC_s_WARN_FMT "Null cmdPtr!!!!\n", ioc->name);
+- }
+-
+- /* No more processing.
+- * TM call will generate an interrupt for SCSI TM Management.
+- * The FW will reply to all outstanding commands, callback will finish cleanup.
+- * Hard reset clean-up will free all resources.
+- */
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Timer Expired Complete!\n", ioc->name));
+-
+- return;
+-}
+-
+-
+-/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mptscsih_do_cmd - Do internal command.
+ * @hd: MPT_SCSI_HOST pointer
+@@ -3019,28 +2944,33 @@ mptscsih_timer_expired(unsigned long dat
+ * 0 if good
+ *
+ * > 0 if command complete but some type of completion error.
+- */
+-static int
++ **/
++int
+ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
+ {
+ MPT_FRAME_HDR *mf;
+ SCSIIORequest_t *pScsiReq;
+- SCSIIORequest_t ReqCopy;
+ int my_idx, ii, dir;
+- int rc, cmdTimeout;
+- int in_isr;
++ int timeout;
+ char cmdLen;
+ char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+- char cmd = io->cmd;
+- MPT_ADAPTER *ioc = hd->ioc;
++ u8 cmd = io->cmd;
++ MPT_ADAPTER *ioc = hd->ioc;
++ int ret = 0;
++ unsigned long timeleft;
++ unsigned long flags;
+
+- in_isr = in_interrupt();
+- if (in_isr) {
+- dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Internal SCSI IO request not allowed in ISR context!\n",
+- ioc->name));
+- return -EPERM;
++ /* don't send internal command during diag reset */
++ spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
++ if (ioc->ioc_reset_in_progress) {
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
++ dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: busy with host reset\n", ioc->name, __FUNCTION__));
++ return MPT_SCANDV_BUSY;
+ }
++ spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+
++ mutex_lock(&ioc->internal_cmds.mutex);
+
+ /* Set command specific information
+ */
+@@ -3050,13 +2980,13 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+ dir = MPI_SCSIIO_CONTROL_READ;
+ CDB[0] = cmd;
+ CDB[4] = io->size;
+- cmdTimeout = 10;
++ timeout = 10;
+ break;
+
+ case TEST_UNIT_READY:
+ cmdLen = 6;
+ dir = MPI_SCSIIO_CONTROL_READ;
+- cmdTimeout = 10;
++ timeout = 10;
+ break;
+
+ case START_STOP:
+@@ -3064,7 +2994,7 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+ dir = MPI_SCSIIO_CONTROL_READ;
+ CDB[0] = cmd;
+ CDB[4] = 1; /*Spin up the disk */
+- cmdTimeout = 15;
++ timeout = 15;
+ break;
+
+ case REQUEST_SENSE:
+@@ -3072,7 +3002,7 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+ CDB[0] = cmd;
+ CDB[4] = io->size;
+ dir = MPI_SCSIIO_CONTROL_READ;
+- cmdTimeout = 10;
++ timeout = 10;
+ break;
+
+ case READ_BUFFER:
+@@ -3091,7 +3021,7 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+ CDB[6] = (io->size >> 16) & 0xFF;
+ CDB[7] = (io->size >> 8) & 0xFF;
+ CDB[8] = io->size & 0xFF;
+- cmdTimeout = 10;
++ timeout = 10;
+ break;
+
+ case WRITE_BUFFER:
+@@ -3106,21 +3036,21 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+ CDB[6] = (io->size >> 16) & 0xFF;
+ CDB[7] = (io->size >> 8) & 0xFF;
+ CDB[8] = io->size & 0xFF;
+- cmdTimeout = 10;
++ timeout = 10;
+ break;
+
+ case RESERVE:
+ cmdLen = 6;
+ dir = MPI_SCSIIO_CONTROL_READ;
+ CDB[0] = cmd;
+- cmdTimeout = 10;
++ timeout = 10;
+ break;
+
+ case RELEASE:
+ cmdLen = 6;
+ dir = MPI_SCSIIO_CONTROL_READ;
+ CDB[0] = cmd;
+- cmdTimeout = 10;
++ timeout = 10;
+ break;
+
+ case SYNCHRONIZE_CACHE:
+@@ -3128,20 +3058,42 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+ dir = MPI_SCSIIO_CONTROL_READ;
+ CDB[0] = cmd;
+ // CDB[1] = 0x02; /* set immediate bit */
+- cmdTimeout = 10;
++ timeout = 10;
++ break;
++
++ case REPORT_LUNS:
++ cmdLen = 12;
++ dir = MPI_SCSIIO_CONTROL_READ;
++ CDB[0] = cmd;
++ CDB[6] = (io->size >> 24) & 0xFF;
++ CDB[7] = (io->size >> 16) & 0xFF;
++ CDB[8] = (io->size >> 8) & 0xFF;
++ CDB[9] = io->size & 0xFF;
++ timeout = 10;
++ break;
++
++ case TRANSPORT_LAYER_RETRIES:
++ CDB[0] = cmd;
++ CDB[1] = 0x01;
++ cmdLen = 6;
++ dir = MPI_SCSIIO_CONTROL_READ;
++ timeout = 10;
+ break;
+
+ default:
+ /* Error Case */
+- return -EFAULT;
++ ret = -EFAULT;
++ goto out;
+ }
+
+ /* Get and Populate a free Frame
++ * MsgContext set in mpt_get_msg_frame call
+ */
+ if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
+- dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "No msg frames!\n",
+- ioc->name));
+- return -EBUSY;
++ dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
++ ioc->name, __FUNCTION__));
++ ret = MPT_SCANDV_BUSY;
++ goto out;
+ }
+
+ pScsiReq = (SCSIIORequest_t *) mf;
+@@ -3164,14 +3116,10 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+
+ pScsiReq->CDBLength = cmdLen;
+ pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
+-
+ pScsiReq->Reserved = 0;
+-
+- pScsiReq->MsgFlags = mpt_msg_flags();
+- /* MsgContext set in mpt_get_msg_fram call */
++ pScsiReq->MsgFlags = mpt_msg_flags(ioc);
+
+ int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
+-
+ if (io->flags & MPT_ICFLAG_TAGGED_CMD)
+ pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
+ else
+@@ -3179,74 +3127,61 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+
+ if (cmd == REQUEST_SENSE) {
+ pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Untagged! 0x%2x\n",
+- ioc->name, cmd));
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: Untagged! 0x%02x\n", ioc->name, __FUNCTION__, cmd));
+ }
+
+- for (ii=0; ii < 16; ii++)
+- pScsiReq->CDB[ii] = CDB[ii];
++ for (ii = 0; ii < 16; ii++)
++ pScsiReq->CDB[ii] = CDB[ii];
+
+ pScsiReq->DataLength = cpu_to_le32(io->size);
+ pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
+ + (my_idx * MPT_SENSE_BUFFER_ALLOC));
+
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Command 0x%x for (%d:%d:%d)\n",
+- ioc->name, cmd, io->channel, io->id, io->lun));
+-
+- if (dir == MPI_SCSIIO_CONTROL_READ) {
+- mpt_add_sge((char *) &pScsiReq->SGL,
+- MPT_SGE_FLAGS_SSIMPLE_READ | io->size,
+- io->data_dma);
+- } else {
+- mpt_add_sge((char *) &pScsiReq->SGL,
+- MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size,
+- io->data_dma);
+- }
+-
+- /* The ISR will free the request frame, but we need
+- * the information to initialize the target. Duplicate.
+- */
+- memcpy(&ReqCopy, pScsiReq, sizeof(SCSIIORequest_t));
+-
+- /* Issue this command after:
+- * finish init
+- * add timer
+- * Wait until the reply has been received
+- * ScsiScanDvCtx callback function will
+- * set hd->pLocal;
+- * set scandv_wait_done and call wake_up
+- */
+- hd->pLocal = NULL;
+- hd->timer.expires = jiffies + HZ*cmdTimeout;
+- hd->scandv_wait_done = 0;
+-
+- /* Save cmd pointer, for resource free if timeout or
+- * FW reload occurs
+- */
+- hd->cmdPtr = mf;
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%d\n",
++ ioc->name, __FUNCTION__, cmd, io->channel, io->id, io->lun));
++
++ if (dir == MPI_SCSIIO_CONTROL_READ)
++ ioc->add_sge((char *) &pScsiReq->SGL,
++ MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
++ else
++ ioc->add_sge((char *) &pScsiReq->SGL,
++ MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
+
+- add_timer(&hd->timer);
++ INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
+ mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
+- wait_event(hd->scandv_waitq, hd->scandv_wait_done);
+-
+- if (hd->pLocal) {
+- rc = hd->pLocal->completion;
+- hd->pLocal->skip = 0;
+-
+- /* Always set fatal error codes in some cases.
+- */
+- if (rc == MPT_SCANDV_SELECTION_TIMEOUT)
+- rc = -ENXIO;
+- else if (rc == MPT_SCANDV_SOME_ERROR)
+- rc = -rc;
+- } else {
+- rc = -EFAULT;
+- /* This should never happen. */
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "_do_cmd: Null pLocal!!!\n",
+- ioc->name));
++ timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
++ timeout*HZ);
++ if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ ret = MPT_SCANDV_DID_RESET;
++ dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
++ "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __FUNCTION__,
++ cmd));
++ if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(ioc, mf);
++ goto out;
++ }
++ if (!timeleft) {
++ if (!mptscsih_scandv_bus_reset(ioc))
++ goto out;
++ printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
++ ioc->name, __FUNCTION__);
++ if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
++ mpt_HardResetHandler(ioc, CAN_SLEEP);
++ mpt_free_msg_frame(ioc, mf);
++ }
++ goto out;
+ }
+
+- return rc;
++ ret = ioc->internal_cmds.completion_code;
++ devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
++ ioc->name, __FUNCTION__, ret));
++
++ out:
++ CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
++ mutex_unlock(&ioc->internal_cmds.mutex);
++ return ret;
+ }
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+@@ -3260,9 +3195,10 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
+ *
+ */
+ static void
+-mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
++mptscsih_synchronize_cache(struct scsi_device *sdev, MPT_SCSI_HOST *hd, VirtDevice *vdevice)
+ {
+ INTERNAL_CMD iocmd;
++ MPT_ADAPTER *ioc = hd->ioc;
+
+ /* Ignore hidden raid components, this is handled when the command
+ * is sent to the volume
+@@ -3274,23 +3210,23 @@ mptscsih_synchronize_cache(MPT_SCSI_HOST
+ !vdevice->configured_lun)
+ return;
+
+- /* Following parameters will not change
+- * in this routine.
+- */
++ memset(&iocmd, 0, sizeof(INTERNAL_CMD));
+ iocmd.cmd = SYNCHRONIZE_CACHE;
+- iocmd.flags = 0;
+ iocmd.physDiskNum = -1;
+ iocmd.data = NULL;
+ iocmd.data_dma = -1;
+- iocmd.size = 0;
+- iocmd.rsvd = iocmd.rsvd2 = 0;
+ iocmd.channel = vdevice->vtarget->channel;
+ iocmd.id = vdevice->vtarget->id;
+ iocmd.lun = vdevice->lun;
+
++ sdev_printk(KERN_INFO, sdev, MYIOC_s_FMT "SYNCHRONIZE_CACHE: fw_channel %d,"
++ " fw_id %d\n", ioc->name, vdevice->vtarget->channel, vdevice->vtarget->id);
+ mptscsih_do_cmd(hd, &iocmd);
+ }
+
++/*
++ * shost attributes
++ */
+ static ssize_t
+ mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
+ char *buf)
+@@ -3464,13 +3400,44 @@ mptscsih_debug_level_store(struct device
+ return -EINVAL;
+
+ ioc->debug_level = val;
+- printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
+- ioc->name, ioc->debug_level);
++ printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n", ioc->name,
++ ioc->debug_level);
+ return strlen(buf);
+ }
+ static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
+ mptscsih_debug_level_show, mptscsih_debug_level_store);
+
++static ssize_t
++mptscsih_disable_hotplug_remove_show(struct device *dev, struct device_attribute *attr, char *buf)
++{
++ struct Scsi_Host *host = class_to_shost(dev);
++ MPT_SCSI_HOST *hd = shost_priv(host);
++ MPT_ADAPTER *ioc = hd->ioc;
++
++ return snprintf(buf, PAGE_SIZE, "%02xh\n", ioc->disable_hotplug_remove);
++}
++static ssize_t
++mptscsih_disable_hotplug_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
++{
++ struct Scsi_Host *host = class_to_shost(dev);
++ MPT_SCSI_HOST *hd = shost_priv(host);
++ MPT_ADAPTER *ioc = hd->ioc;
++ int val = 0;
++
++ if (sscanf(buf, "%x", &val) != 1)
++ return -EINVAL;
++
++ ioc->disable_hotplug_remove = val;
++ if (ioc->disable_hotplug_remove)
++ printk(MYIOC_s_INFO_FMT "disabling hotplug remove\n",
++ ioc->name);
++ else
++ printk(MYIOC_s_INFO_FMT "eanbling hotplug remove\n", ioc->name);
++ return strlen(buf);
++}
++static DEVICE_ATTR(disable_hotplug_remove, S_IRUGO | S_IWUSR,
++ mptscsih_disable_hotplug_remove_show, mptscsih_disable_hotplug_remove_store);
++
+ struct device_attribute *mptscsih_host_attrs[] = {
+ &dev_attr_version_fw,
+ &dev_attr_version_bios,
+@@ -3484,6 +3451,7 @@ struct device_attribute *mptscsih_host_a
+ &dev_attr_io_delay,
+ &dev_attr_device_delay,
+ &dev_attr_debug_level,
++ &dev_attr_disable_hotplug_remove,
+ NULL,
+ };
+ EXPORT_SYMBOL(mptscsih_host_attrs);
+@@ -3510,7 +3478,9 @@ EXPORT_SYMBOL(mptscsih_scandv_complete);
+ EXPORT_SYMBOL(mptscsih_event_process);
+ EXPORT_SYMBOL(mptscsih_ioc_reset);
+ EXPORT_SYMBOL(mptscsih_change_queue_depth);
+-EXPORT_SYMBOL(mptscsih_timer_expired);
+-EXPORT_SYMBOL(mptscsih_TMHandler);
+-
++EXPORT_SYMBOL(mptscsih_IssueTaskMgmt);
++EXPORT_SYMBOL(mptscsih_do_cmd);
++EXPORT_SYMBOL(mptscsih_quiesce_raid);
++EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
++EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+--- a/drivers/message/fusion/mptscsih.h
++++ b/drivers/message/fusion/mptscsih.h
+@@ -60,6 +60,7 @@
+ #define MPT_SCANDV_SELECTION_TIMEOUT (0x00000008)
+ #define MPT_SCANDV_ISSUE_SENSE (0x00000010)
+ #define MPT_SCANDV_FALLBACK (0x00000020)
++#define MPT_SCANDV_BUSY (0x00000040)
+
+ #define MPT_SCANDV_MAX_RETRIES (10)
+
+@@ -71,6 +72,7 @@
+ #define MPT_ICFLAG_DID_RESET 0x20 /* Bus Reset occurred with this command */
+ #define MPT_ICFLAG_RESERVED 0x40 /* Reserved has been issued */
+
++
+ #define MPT_SCSI_CMD_PER_DEV_HIGH 64
+ #define MPT_SCSI_CMD_PER_DEV_LOW 32
+
+@@ -84,9 +86,11 @@
+ #define MPTSCSIH_DOMAIN_VALIDATION 1
+ #define MPTSCSIH_MAX_WIDTH 1
+ #define MPTSCSIH_MIN_SYNC 0x08
++#define MPTSCSIH_QAS 1
+ #define MPTSCSIH_SAF_TE 0
+ #define MPTSCSIH_PT_CLEAR 0
+
++#define TRANSPORT_LAYER_RETRIES 0xC2
+ #endif
+
+ typedef struct _internal_cmd {
+@@ -112,7 +116,7 @@ extern int mptscsih_resume(struct pci_de
+ extern int mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length, int func);
+ extern const char * mptscsih_info(struct Scsi_Host *SChost);
+ extern int mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *));
+-extern void mptscsih_slave_destroy(struct scsi_device *device);
++extern void mptscsih_slave_destroy(struct scsi_device *sdev);
+ extern int mptscsih_slave_configure(struct scsi_device *device);
+ extern int mptscsih_abort(struct scsi_cmnd * SCpnt);
+ extern int mptscsih_dev_reset(struct scsi_cmnd * SCpnt);
+@@ -125,8 +129,11 @@ extern int mptscsih_scandv_complete(MPT_
+ extern int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
+ extern int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
+ extern int mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth);
+-extern void mptscsih_timer_expired(unsigned long data);
+-extern int mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
++extern int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
+ extern u8 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id);
+ extern int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id);
++extern int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
+ extern struct device_attribute *mptscsih_host_attrs[];
++extern int mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id);
++extern struct scsi_cmnd * mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
++extern void mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code);
+--- a/drivers/message/fusion/mptspi.c
++++ b/drivers/message/fusion/mptspi.c
+@@ -53,8 +53,10 @@
+ #include <linux/delay.h> /* for mdelay */
+ #include <linux/interrupt.h> /* needed for in_interrupt() proto */
+ #include <linux/reboot.h> /* notifier code */
++#include <linux/sched.h>
+ #include <linux/workqueue.h>
+ #include <linux/raid_class.h>
++#include <linux/pci.h>
+
+ #include <scsi/scsi.h>
+ #include <scsi/scsi_cmnd.h>
+@@ -83,6 +85,10 @@ static int mpt_saf_te = MPTSCSIH_SAF_TE;
+ module_param(mpt_saf_te, int, 0);
+ MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
+
++static int mpt_qas = MPTSCSIH_QAS;
++module_param(mpt_qas, int, 1);
++MODULE_PARM_DESC(mpt_qas, " Quick Arbitration and Selection (QAS) enabled=1, disabled=0 (default=MPTSCSIH_QAS=1)");
++
+ static void mptspi_write_offset(struct scsi_target *, int);
+ static void mptspi_write_width(struct scsi_target *, int);
+ static int mptspi_write_spi_device_pg1(struct scsi_target *,
+@@ -95,12 +101,12 @@ static u8 mptspiTaskCtx = MPT_MAX_PROTOC
+ static u8 mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
+
+ /**
+- * mptspi_setTargetNegoParms - Update the target negotiation parameters
++ * mptspi_setTargetNegoParms - Update the target negotiation parameters
+ * @hd: Pointer to a SCSI Host Structure
+ * @target: per target private data
+ * @sdev: SCSI device
+ *
+- * Update the target negotiation parameters based on the the Inquiry
++ * Update the target negotiation parameters based on the the Inquiry
+ * data, adapter capabilities, and NVRAM settings.
+ **/
+ static void
+@@ -131,7 +137,7 @@ mptspi_setTargetNegoParms(MPT_SCSI_HOST
+ if (scsi_device_sync(sdev)) {
+ factor = pspi_data->minSyncFactor;
+ if (!scsi_device_dt(sdev))
+- factor = MPT_ULTRA2;
++ factor = MPT_ULTRA2;
+ else {
+ if (!scsi_device_ius(sdev) &&
+ !scsi_device_qas(sdev))
+@@ -209,6 +215,10 @@ mptspi_setTargetNegoParms(MPT_SCSI_HOST
+ target->maxOffset = offset;
+ target->maxWidth = width;
+
++ spi_min_period(scsi_target(sdev)) = factor;
++ spi_max_offset(scsi_target(sdev)) = offset;
++ spi_max_width(scsi_target(sdev)) = width;
++
+ target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
+
+ /* Disable unused features.
+@@ -230,7 +240,7 @@ mptspi_setTargetNegoParms(MPT_SCSI_HOST
+ */
+
+ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
++ "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
+ }
+ }
+
+@@ -262,7 +272,7 @@ mptspi_writeIOCPage4(MPT_SCSI_HOST *hd,
+ */
+ if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
+ dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
+- "writeIOCPage4 : no msg frames!\n",ioc->name));
++ "writeIOCPage4 : no msg frames!\n", ioc->name));
+ return -EAGAIN;
+ }
+
+@@ -300,11 +310,11 @@ mptspi_writeIOCPage4(MPT_SCSI_HOST *hd,
+ flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
+ (IOCPage4Ptr->Header.PageLength + ii) * 4;
+
+- mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
++ ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
+
+ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+ "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
+- ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
++ ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
+
+ mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
+
+@@ -371,7 +381,7 @@ mptspi_initTarget(MPT_SCSI_HOST *hd, Vir
+ * non-zero = true
+ * zero = false
+ *
+- */
++ **/
+ static int
+ mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
+ {
+@@ -399,12 +409,11 @@ static int mptspi_target_alloc(struct sc
+ struct Scsi_Host *shost = dev_to_shost(&starget->dev);
+ struct _MPT_SCSI_HOST *hd = shost_priv(shost);
+ VirtTarget *vtarget;
+- MPT_ADAPTER *ioc;
++ MPT_ADAPTER *ioc = hd->ioc;
+
+ if (hd == NULL)
+ return -ENODEV;
+
+- ioc = hd->ioc;
+ vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
+ if (!vtarget)
+ return -ENOMEM;
+@@ -471,9 +480,12 @@ mptspi_target_destroy(struct scsi_target
+ static void
+ mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
+ {
+- ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
++ if (!(hd->ioc->debug_level & MPT_DEBUG_DV))
++ return;
++
++ starget_printk(KERN_DEBUG, starget, MYIOC_s_FMT "Wrote = 0x%08x"
+ " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
+- hd->ioc->name, starget->id, ii,
++ hd->ioc->name, ii,
+ ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
+ ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
+ ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
+@@ -483,7 +495,7 @@ mptspi_print_write_nego(struct _MPT_SCSI
+ ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
+ ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
+ ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
+- ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
++ ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "");
+ }
+
+ /**
+@@ -496,9 +508,12 @@ mptspi_print_write_nego(struct _MPT_SCSI
+ static void
+ mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
+ {
+- ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
++ if (!(hd->ioc->debug_level & MPT_DEBUG_DV))
++ return;
++
++ starget_printk(KERN_DEBUG, starget, MYIOC_s_FMT "Read = 0x%08x"
+ " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
+- hd->ioc->name, starget->id, ii,
++ hd->ioc->name, ii,
+ ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
+ ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
+ ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
+@@ -508,7 +523,7 @@ mptspi_print_read_nego(struct _MPT_SCSI_
+ ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
+ ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
+ ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
+- ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
++ ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "");
+ }
+
+ static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
+@@ -557,9 +572,11 @@ static int mptspi_read_spi_device_pg0(st
+ cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
+ cfg.dir = 0;
+ cfg.pageAddr = starget->id;
++ cfg.timeout = 60;
+
+ if (mpt_config(ioc, &cfg)) {
+- starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
++ starget_printk(KERN_ERR, starget,
++ MYIOC_s_FMT "mpt_config failed\n", ioc->name);
+ goto out_free;
+ }
+ err = 0;
+@@ -614,64 +631,11 @@ static void mptspi_read_parameters(struc
+ spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
+ }
+
+-static int
+-mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
+-{
+- MpiRaidActionRequest_t *pReq;
+- MPT_FRAME_HDR *mf;
+- MPT_ADAPTER *ioc = hd->ioc;
+-
+- /* Get and Populate a free Frame
+- */
+- if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
+- ddvprintk(ioc, printk(MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
+- ioc->name));
+- return -EAGAIN;
+- }
+- pReq = (MpiRaidActionRequest_t *)mf;
+- if (quiesce)
+- pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
+- else
+- pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
+- pReq->Reserved1 = 0;
+- pReq->ChainOffset = 0;
+- pReq->Function = MPI_FUNCTION_RAID_ACTION;
+- pReq->VolumeID = id;
+- pReq->VolumeBus = channel;
+- pReq->PhysDiskNum = 0;
+- pReq->MsgFlags = 0;
+- pReq->Reserved2 = 0;
+- pReq->ActionDataWord = 0; /* Reserved for this action */
+-
+- mpt_add_sge((char *)&pReq->ActionDataSGE,
+- MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
+-
+- ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
+- ioc->name, pReq->Action, channel, id));
+-
+- hd->pLocal = NULL;
+- hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
+- hd->scandv_wait_done = 0;
+-
+- /* Save cmd pointer, for resource free if timeout or
+- * FW reload occurs
+- */
+- hd->cmdPtr = mf;
+-
+- add_timer(&hd->timer);
+- mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
+- wait_event(hd->scandv_waitq, hd->scandv_wait_done);
+-
+- if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
+- return -1;
+-
+- return 0;
+-}
+-
+ static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
+ struct scsi_device *sdev)
+ {
+ VirtTarget *vtarget = scsi_target(sdev)->hostdata;
++ struct scsi_target *starget = scsi_target(sdev);
+ MPT_ADAPTER *ioc = hd->ioc;
+
+ /* no DV on RAID devices */
+@@ -679,11 +643,20 @@ static void mptspi_dv_device(struct _MPT
+ mptspi_is_raid(hd, sdev->id))
+ return;
+
++ if (ioc->debug_level & MPT_DEBUG_DV)
++ starget_printk(KERN_DEBUG, starget, MYIOC_s_FMT
++ "sdtr=%d, wdtr=%d, ppr=%d, min_period=0x%02x, "
++ "max_offset=0x%02x, max_width=%d, nego_flags=0x%02x, "
++ "tflags=0x%02x\n", ioc->name, sdev->sdtr, sdev->wdtr,
++ sdev->ppr, spi_min_period(starget),
++ spi_max_offset(starget), spi_max_width(starget),
++ vtarget->negoFlags, vtarget->tflags);
++
+ /* If this is a piece of a RAID, then quiesce first */
+ if (sdev->channel == 1 &&
+ mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
+- starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
+- "Integrated RAID quiesce failed\n", ioc->name);
++ starget_printk(KERN_ERR, scsi_target(sdev),
++ MYIOC_s_FMT "Integrated RAID quiesce failed\n", ioc->name);
+ return;
+ }
+
+@@ -693,8 +666,8 @@ static void mptspi_dv_device(struct _MPT
+
+ if (sdev->channel == 1 &&
+ mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
+- starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
+- "Integrated RAID resume failed\n", ioc->name);
++ starget_printk(KERN_ERR, scsi_target(sdev),
++ MYIOC_s_FMT "Integrated RAID resume failed\n", ioc->name);
+
+ mptspi_read_parameters(sdev->sdev_target);
+ spi_display_xfer_agreement(sdev->sdev_target);
+@@ -716,7 +689,7 @@ static int mptspi_slave_alloc(struct scs
+ vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
+ if (!vdevice) {
+ printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
+- ioc->name, sizeof(VirtDevice));
++ ioc->name, sizeof(VirtDevice));
+ return -ENOMEM;
+ }
+
+@@ -738,21 +711,13 @@ static int mptspi_slave_configure(struct
+ {
+ struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
+ VirtTarget *vtarget = scsi_target(sdev)->hostdata;
+- int ret;
++ int ret;
+
+ mptspi_initTarget(hd, vtarget, sdev);
+-
+ ret = mptscsih_slave_configure(sdev);
+-
+ if (ret)
+ return ret;
+
+- ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
+- " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
+- sdev->id, spi_min_period(scsi_target(sdev)),
+- spi_max_offset(scsi_target(sdev)),
+- spi_max_width(scsi_target(sdev))));
+-
+ if ((sdev->channel == 1 ||
+ !(mptspi_is_raid(hd, sdev->id))) &&
+ !spi_initial_dv(sdev->sdev_target))
+@@ -857,8 +822,8 @@ static int mptspi_write_spi_device_pg1(s
+
+ pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
+ if (pg1 == NULL) {
+- starget_printk(KERN_ERR, starget, MYIOC_s_FMT
+- "dma_alloc_coherent for parameters failed\n", ioc->name);
++ starget_printk(KERN_ERR, starget,
++ MYIOC_s_FMT "dma_alloc_coherent for parameters failed\n", ioc->name);
+ return -EINVAL;
+ }
+
+@@ -887,8 +852,8 @@ static int mptspi_write_spi_device_pg1(s
+ mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
+
+ if (mpt_config(ioc, &cfg)) {
+- starget_printk(KERN_ERR, starget, MYIOC_s_FMT
+- "mpt_config failed\n", ioc->name);
++ starget_printk(KERN_ERR, starget,
++ MYIOC_s_FMT "mpt_config failed\n", ioc->name);
+ goto out_free;
+ }
+ err = 0;
+@@ -963,14 +928,15 @@ static void mptspi_write_dt(struct scsi_
+ if (spi_period(starget) == -1)
+ mptspi_read_parameters(starget);
+
+- if (!dt && spi_period(starget) < 10)
+- spi_period(starget) = 10;
++ if (!dt) {
++ spi_qas(starget) = 0;
++ spi_iu(starget) = 0;
++ }
+
+ spi_dt(starget) = dt;
+
+ nego = mptspi_getRP(starget);
+
+-
+ pg1.RequestedParameters = cpu_to_le32(nego);
+ pg1.Reserved = 0;
+ pg1.Configuration = 0;
+@@ -986,9 +952,6 @@ static void mptspi_write_iu(struct scsi_
+ if (spi_period(starget) == -1)
+ mptspi_read_parameters(starget);
+
+- if (!iu && spi_period(starget) < 9)
+- spi_period(starget) = 9;
+-
+ spi_iu(starget) = iu;
+
+ nego = mptspi_getRP(starget);
+@@ -1030,9 +993,11 @@ static void mptspi_write_qas(struct scsi
+ struct _MPT_SCSI_HOST *hd = shost_priv(shost);
+ VirtTarget *vtarget = starget->hostdata;
+ u32 nego;
++ MPT_ADAPTER *ioc = hd->ioc;
+
+- if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
+- hd->ioc->spi_data.noQas)
++ if (!mpt_qas ||
++ (vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
++ ioc->spi_data.noQas)
+ spi_qas(starget) = 0;
+ else
+ spi_qas(starget) = qas;
+@@ -1053,8 +1018,8 @@ static void mptspi_write_width(struct sc
+
+ if (!width) {
+ spi_dt(starget) = 0;
+- if (spi_period(starget) < 10)
+- spi_period(starget) = 10;
++ spi_qas(starget) = 0;
++ spi_iu(starget) = 0;
+ }
+
+ spi_width(starget) = width;
+@@ -1074,7 +1039,8 @@ struct work_queue_wrapper {
+ int disk;
+ };
+
+-static void mpt_work_wrapper(struct work_struct *work)
++static void
++mpt_work_wrapper(struct work_struct *work)
+ {
+ struct work_queue_wrapper *wqw =
+ container_of(work, struct work_queue_wrapper, work);
+@@ -1105,12 +1071,12 @@ static void mpt_work_wrapper(struct work
+ if(vtarget->id != disk)
+ continue;
+
+- starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
+- "Integrated RAID requests DV of new device\n", ioc->name);
++ starget_printk(KERN_INFO, vtarget->starget,
++ MYIOC_s_FMT "Integrated RAID requests DV of new device\n", ioc->name);
+ mptspi_dv_device(hd, sdev);
+ }
+- shost_printk(KERN_INFO, shost, MYIOC_s_FMT
+- "Integrated RAID detects new device %d\n", ioc->name, disk);
++ shost_printk(KERN_INFO, shost,
++ MYIOC_s_FMT "Integrated RAID detects new device %d\n", ioc->name, disk);
+ scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
+ }
+
+@@ -1121,8 +1087,8 @@ static void mpt_dv_raid(struct _MPT_SCSI
+ MPT_ADAPTER *ioc = hd->ioc;
+
+ if (!wqw) {
+- shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
+- "Failed to act on RAID event for physical disk %d\n",
++ shost_printk(KERN_ERR, ioc->sh,
++ MYIOC_s_FMT "Failed to act on RAID event for physical disk %d\n",
+ ioc->name, disk);
+ return;
+ }
+@@ -1213,9 +1179,9 @@ static struct pci_device_id mptspi_pci_t
+ MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
+
+
+-/*
++/**
+ * renegotiate for a given target
+- */
++ **/
+ static void
+ mptspi_dv_renegotiate_work(struct work_struct *work)
+ {
+@@ -1261,32 +1227,33 @@ mptspi_dv_renegotiate(struct _MPT_SCSI_H
+ schedule_work(&wqw->work);
+ }
+
+-/*
++/**
+ * spi module reset handler
+- */
++ **/
+ static int
+ mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
+ {
++ struct _MPT_SCSI_HOST *hd = NULL;
+ int rc;
+
+ rc = mptscsih_ioc_reset(ioc, reset_phase);
++ if ((ioc->bus_type != SPI) || (!rc))
++ goto out;
+
+- /* only try to do a renegotiation if we're properly set up
+- * if we get an ioc fault on bringup, ioc->sh will be NULL */
+- if (reset_phase == MPT_IOC_POST_RESET &&
+- ioc->sh) {
+- struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
++ hd = shost_priv(ioc->sh);
++ if (!hd->ioc)
++ goto out;
+
++ if (ioc->active && reset_phase == MPT_IOC_POST_RESET)
+ mptspi_dv_renegotiate(hd);
+- }
+-
++ out:
+ return rc;
+ }
+
+ #ifdef CONFIG_PM
+-/*
++/**
+ * spi module resume handler
+- */
++ **/
+ static int
+ mptspi_resume(struct pci_dev *pdev)
+ {
+@@ -1303,13 +1270,13 @@ mptspi_resume(struct pci_dev *pdev)
+
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+-/*
++/**
+ * mptspi_probe - Installs scsi devices per bus.
+ * @pdev: Pointer to pci_dev structure
+ *
+ * Returns 0 for success, non-zero for failure.
+ *
+- */
++ **/
+ static int
+ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+ {
+@@ -1423,19 +1390,18 @@ mptspi_probe(struct pci_dev *pdev, const
+ * A slightly different algorithm is required for
+ * 64bit SGEs.
+ */
+- scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
+- if (sizeof(dma_addr_t) == sizeof(u64)) {
++ scale = ioc->req_sz/ioc->SGE_size;
++ if (ioc->sg_addr_size == sizeof(u64)) {
+ numSGE = (scale - 1) *
+ (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
+- sizeof(u32));
++ (ioc->req_sz - 60) / ioc->SGE_size;
+ } else {
+ numSGE = 1 + (scale - 1) *
+ (ioc->facts.MaxChainDepth-1) + scale +
+- (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
+- sizeof(u32));
++ (ioc->req_sz - 64) / ioc->SGE_size;
+ }
+
++
+ if (numSGE < sh->sg_tablesize) {
+ /* Reset this value */
+ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+@@ -1444,11 +1410,11 @@ mptspi_probe(struct pci_dev *pdev, const
+ sh->sg_tablesize = numSGE;
+ }
+
+- spin_unlock_irqrestore(&ioc->FreeQlock, flags);
+-
+ hd = shost_priv(sh);
+ hd->ioc = ioc;
+
++ spin_unlock_irqrestore(&ioc->FreeQlock, flags);
++
+ /* SCSI needs scsi_cmnd lookup table!
+ * (with size equal to req_depth*PtrSz!)
+ */
+@@ -1462,39 +1428,12 @@ mptspi_probe(struct pci_dev *pdev, const
+ dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
+ ioc->name, ioc->ScsiLookup));
+
+- /* Clear the TM flags
+- */
+- hd->tmPending = 0;
+- hd->tmState = TM_STATE_NONE;
+- hd->resetPending = 0;
+- hd->abortSCpnt = NULL;
+-
+- /* Clear the pointer used to store
+- * single-threaded commands, i.e., those
+- * issued during a bus scan, dv and
+- * configuration pages.
+- */
+- hd->cmdPtr = NULL;
+-
+- /* Initialize this SCSI Hosts' timers
+- * To use, set the timer expires field
+- * and add_timer
+- */
+- init_timer(&hd->timer);
+- hd->timer.data = (unsigned long) hd;
+- hd->timer.function = mptscsih_timer_expired;
+-
++ ioc->sdev_queue_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
+ ioc->spi_data.Saf_Te = mpt_saf_te;
+-
+- hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
+ ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
+- "saf_te %x\n",
+- ioc->name,
+- mpt_saf_te));
+- ioc->spi_data.noQas = 0;
++ "saf_te %x\n", ioc->name, mpt_saf_te));
++ ioc->spi_data.noQas = mpt_qas ? 0 : MPT_TARGET_NO_NEGO_QAS;
+
+- init_waitqueue_head(&hd->scandv_waitq);
+- hd->scandv_wait_done = 0;
+ hd->last_queue_full = 0;
+ hd->spi_pending = 0;
+
+@@ -1514,7 +1453,7 @@ mptspi_probe(struct pci_dev *pdev, const
+ * issue internal bus reset
+ */
+ if (ioc->spi_data.bus_reset)
+- mptscsih_TMHandler(hd,
++ mptscsih_IssueTaskMgmt(hd,
+ MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
+ 0, 0, 0, 0, 5);
+
+@@ -1544,7 +1483,7 @@ static struct pci_driver mptspi_driver =
+ * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
+ *
+ * Returns 0 for success, non-zero for failure.
+- */
++ **/
+ static int __init
+ mptspi_init(void)
+ {
+@@ -1574,7 +1513,8 @@ mptspi_init(void)
+ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
+ /**
+ * mptspi_exit - Unregisters MPT adapter(s)
+- */
++ *
++ **/
+ static void __exit
+ mptspi_exit(void)
+ {
+@@ -1582,7 +1522,6 @@ mptspi_exit(void)
+
+ mpt_reset_deregister(mptspiDoneCtx);
+ mpt_event_deregister(mptspiDoneCtx);
+-
+ mpt_deregister(mptspiInternalCtx);
+ mpt_deregister(mptspiTaskCtx);
+ mpt_deregister(mptspiDoneCtx);
+--- /dev/null
++++ b/drivers/message/fusion/rejected_ioctls/diag_buffer.c
+@@ -0,0 +1,667 @@
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/* REGISTER DIAG BUFFER Routine.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -EBUSY if previous command timout and IOC reset is not complete.
++ * -ENODEV if no such device/adapter
++ * -ETIME if timer expires
++ * -ENOMEM if memory allocation error
++ */
++static int
++mptctl_register_diag_buffer (unsigned long arg)
++{
++ mpt_diag_register_t __user *uarg = (void __user *) arg;
++ mpt_diag_register_t karg;
++ MPT_ADAPTER *ioc;
++ int iocnum, rc, ii;
++ void * request_data;
++ dma_addr_t request_data_dma;
++ u32 request_data_sz;
++ MPT_FRAME_HDR *mf;
++ DiagBufferPostRequest_t *diag_buffer_post_request;
++ DiagBufferPostReply_t *diag_buffer_post_reply;
++ u32 tmp;
++ u8 buffer_type;
++ unsigned long timeleft;
++
++ rc = 0;
++ if (copy_from_user(&karg, uarg, sizeof(mpt_diag_register_t))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in mpt_diag_register_t struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
++ (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
++ __FUNCTION__));
++ buffer_type = karg.data.BufferType;
++ if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ return -ENODEV;
++ }
++
++ if (ioc->DiagBuffer_Status[buffer_type] &
++ MPT_DIAG_BUFFER_IS_REGISTERED) {
++ printk(MYIOC_s_DEBUG_FMT "%s: already has a Registered "
++ "buffer for buffer_type=%x\n", ioc->name, __FUNCTION__,
++ buffer_type);
++ return -EFAULT;
++ }
++
++ /* Get a free request frame and save the message context.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
++ return -EAGAIN;
++
++ request_data = ioc->DiagBuffer[buffer_type];
++ request_data_sz = karg.data.RequestedBufferSize;
++
++ if (request_data) {
++ request_data_dma = ioc->DiagBuffer_dma[buffer_type];
++ if (request_data_sz != ioc->DiagBuffer_sz[buffer_type]) {
++ pci_free_consistent(ioc->pcidev,
++ ioc->DiagBuffer_sz[buffer_type],
++ request_data, request_data_dma);
++ request_data = NULL;
++ }
++ }
++
++ if (request_data == NULL) {
++ ioc->DiagBuffer_sz[buffer_type] = 0;
++ ioc->DiagBuffer_dma[buffer_type] = 0;
++ ioc->DataSize[buffer_type] = 0;
++ request_data = pci_alloc_consistent(
++ ioc->pcidev, request_data_sz, &request_data_dma);
++ if (request_data == NULL) {
++ printk(MYIOC_s_DEBUG_FMT "%s: pci_alloc_consistent"
++ " FAILED, (request_sz=%d)\n", ioc->name,
++ __FUNCTION__, request_data_sz);
++ mpt_free_msg_frame(ioc, mf);
++ return -EAGAIN;
++ }
++ ioc->DiagBuffer[buffer_type] = request_data;
++ ioc->DiagBuffer_sz[buffer_type] = request_data_sz;
++ ioc->DiagBuffer_dma[buffer_type] = request_data_dma;
++ }
++
++ ioc->DiagBuffer_Status[buffer_type] = 0;
++ diag_buffer_post_request = (DiagBufferPostRequest_t *)mf;
++ diag_buffer_post_request->Function = MPI_FUNCTION_DIAG_BUFFER_POST;
++ diag_buffer_post_request->ChainOffset = 0;
++ diag_buffer_post_request->BufferType = karg.data.BufferType;
++ diag_buffer_post_request->TraceLevel = ioc->TraceLevel[buffer_type] =
++ karg.data.TraceLevel;
++ diag_buffer_post_request->MsgFlags = 0;
++ diag_buffer_post_request->Reserved1 = 0;
++ diag_buffer_post_request->Reserved2 = 0;
++ diag_buffer_post_request->Reserved3 = 0;
++ diag_buffer_post_request->BufferAddress.High = 0;
++ if (buffer_type == MPI_DIAG_BUF_TYPE_EXTENDED)
++ ioc->ExtendedType[buffer_type] = karg.data.ExtendedType;
++ else
++ ioc->ExtendedType[buffer_type] = 0;
++ diag_buffer_post_request->ExtendedType =
++ cpu_to_le32(ioc->ExtendedType[buffer_type]);
++ ioc->UniqueId[buffer_type] = karg.data.UniqueId;
++ diag_buffer_post_request->BufferLength = cpu_to_le32(request_data_sz);
++ for (ii = 0; ii < 4; ii++) {
++ ioc->ProductSpecific[buffer_type][ii] =
++ karg.data.ProductSpecific[ii];
++ diag_buffer_post_request->ProductSpecific[ii] =
++ cpu_to_le32(ioc->ProductSpecific[buffer_type][ii]);
++ }
++
++ tmp = request_data_dma & 0xFFFFFFFF;
++ diag_buffer_post_request->BufferAddress.Low = cpu_to_le32(tmp);
++ if (ioc->sg_addr_size == sizeof(u64)) {
++ tmp = (u32)((u64)request_data_dma >> 32);
++ diag_buffer_post_request->BufferAddress.High = cpu_to_le32(tmp);
++ }
++
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
++ diag_buffer_post_request->MsgContext);
++ INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
++ mpt_put_msg_frame(mptctl_id, ioc, mf);
++ timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
++ MPT_IOCTL_DEFAULT_TIMEOUT*HZ);
++ if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ rc = -ETIME;
++ printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name,
++ __FUNCTION__);
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(ioc, mf);
++ goto out;
++ }
++ if (!timeleft)
++ mptctl_timeout_expired(ioc, mf);
++ goto out;
++ }
++
++ /* process the completed Reply Message Frame */
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: status=%x\n",
++ ioc->name, __FUNCTION__, ioc->ioctl_cmds.status));
++ rc = -EFAULT;
++ goto out;
++ }
++
++ diag_buffer_post_reply = (DiagBufferPostReply_t *)ioc->ioctl_cmds.reply;
++ if (le16_to_cpu(diag_buffer_post_reply->IOCStatus) ==
++ MPI_IOCSTATUS_SUCCESS) {
++ if (diag_buffer_post_reply->MsgLength > 5)
++ ioc->DataSize[buffer_type] =
++ le32_to_cpu(diag_buffer_post_reply->TransferLength);
++ ioc->DiagBuffer_Status[buffer_type] |=
++ MPT_DIAG_BUFFER_IS_REGISTERED;
++ } else {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: IOCStatus=%x "
++ "IOCLogInfo=%x\n", ioc->name, __FUNCTION__,
++ diag_buffer_post_reply->IOCStatus,
++ diag_buffer_post_reply->IOCLogInfo));
++ rc = -EFAULT;
++ }
++
++ out:
++
++ CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
++ if (rc)
++ pci_free_consistent(ioc->pcidev, request_data_sz,
++ request_data, request_data_dma);
++ return rc;
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/* RELEASE DIAG BUFFER Routine.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -EBUSY if previous command timout and IOC reset is not complete.
++ * -ENODEV if no such device/adapter
++ * -ETIME if timer expires
++ * -ENOMEM if memory allocation error
++ */
++static int
++mptctl_release_diag_buffer (unsigned long arg)
++{
++ mpt_diag_release_t __user *uarg = (void __user *) arg;
++ mpt_diag_release_t karg;
++ MPT_ADAPTER *ioc;
++ void * request_data;
++ int iocnum, rc;
++ MPT_FRAME_HDR *mf;
++ DiagReleaseRequest_t *diag_release;
++ DiagReleaseReply_t *diag_release_reply;
++ u8 buffer_type;
++ unsigned long timeleft;
++
++ rc = 0;
++ if (copy_from_user(&karg, uarg, sizeof(mpt_diag_release_t))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in mpt_diag_release_t struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
++ (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
++ __FUNCTION__));
++ buffer_type = karg.data.UniqueId & 0x000000ff;
++ if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ return -ENODEV;
++ }
++
++ if ((ioc->DiagBuffer_Status[buffer_type] &
++ MPT_DIAG_BUFFER_IS_REGISTERED) == 0 ) {
++ printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x is not "
++ "registered\n", ioc->name, __FUNCTION__, buffer_type);
++ return -EFAULT;
++ }
++
++ if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
++ printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not registered\n",
++ ioc->name, __FUNCTION__, karg.data.UniqueId);
++ return -EFAULT;
++ }
++
++ if (ioc->DiagBuffer_Status[buffer_type] & MPT_DIAG_BUFFER_IS_RELEASED) {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x "
++ "is already released\n", ioc->name, __FUNCTION__,
++ buffer_type));
++ return rc;
++ }
++
++ request_data = ioc->DiagBuffer[buffer_type];
++
++ if (request_data == NULL) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ return -ENODEV;
++ }
++
++ /* Get a free request frame and save the message context.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
++ return -EAGAIN;
++
++ diag_release = (DiagReleaseRequest_t *)mf;
++ diag_release->Function = MPI_FUNCTION_DIAG_RELEASE;
++ diag_release->BufferType = buffer_type;
++ diag_release->ChainOffset = 0;
++ diag_release->Reserved1 = 0;
++ diag_release->Reserved2 = 0;
++ diag_release->Reserved3 = 0;
++ diag_release->MsgFlags = 0;
++
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
++ diag_release->MsgContext);
++ INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
++ mpt_put_msg_frame(mptctl_id, ioc, mf);
++ timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
++ MPT_IOCTL_DEFAULT_TIMEOUT*HZ);
++ if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ rc = -ETIME;
++ printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name,
++ __FUNCTION__);
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(ioc, mf);
++ goto out;
++ }
++ if (!timeleft)
++ mptctl_timeout_expired(ioc, mf);
++ goto out;
++ }
++
++ /* process the completed Reply Message Frame */
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: status=%x\n",
++ ioc->name, __FUNCTION__, ioc->ioctl_cmds.status));
++ rc = -EFAULT;
++ goto out;
++ }
++
++ diag_release_reply = (DiagReleaseReply_t *)ioc->ioctl_cmds.reply;
++ if (le16_to_cpu(diag_release_reply->IOCStatus) !=
++ MPI_IOCSTATUS_SUCCESS) {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: IOCStatus=%x "
++ "IOCLogInfo=%x\n",
++ ioc->name, __FUNCTION__, diag_release_reply->IOCStatus,
++ diag_release_reply->IOCLogInfo));
++ rc = -EFAULT;
++ } else
++ ioc->DiagBuffer_Status[buffer_type] |=
++ MPT_DIAG_BUFFER_IS_RELEASED;
++
++ out:
++
++ CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
++ return rc;
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/* UNREGISTER DIAG BUFFER Routine.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -EBUSY if previous command timout and IOC reset is not complete.
++ * -ENODEV if no such device/adapter
++ * -ETIME if timer expires
++ * -ENOMEM if memory allocation error
++ */
++static int
++mptctl_unregister_diag_buffer (unsigned long arg)
++{
++ mpt_diag_unregister_t __user *uarg = (void __user *) arg;
++ mpt_diag_unregister_t karg;
++ MPT_ADAPTER *ioc;
++ int iocnum;
++ void * request_data;
++ dma_addr_t request_data_dma;
++ u32 request_data_sz;
++ u8 buffer_type;
++
++ if (copy_from_user(&karg, uarg, sizeof(mpt_diag_unregister_t))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in mpt_diag_unregister_t struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
++ (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
++ __FUNCTION__));
++ buffer_type = karg.data.UniqueId & 0x000000ff;
++ if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ return -ENODEV;
++ }
++
++ if ((ioc->DiagBuffer_Status[buffer_type] &
++ MPT_DIAG_BUFFER_IS_REGISTERED) == 0) {
++ printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x is not "
++ "registered\n", ioc->name, __FUNCTION__, buffer_type);
++ return -EFAULT;
++ }
++ if ((ioc->DiagBuffer_Status[buffer_type] &
++ MPT_DIAG_BUFFER_IS_RELEASED) == 0) {
++ printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x has not been "
++ "released\n", ioc->name, __FUNCTION__, buffer_type);
++ return -EFAULT;
++ }
++
++ if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
++ printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not registered\n",
++ ioc->name, __FUNCTION__, karg.data.UniqueId);
++ return -EFAULT;
++ }
++
++ request_data = ioc->DiagBuffer[buffer_type];
++ if (!request_data) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ return -ENODEV;
++ }
++
++ request_data_sz = ioc->DiagBuffer_sz[buffer_type];
++ request_data_dma = ioc->DiagBuffer_dma[buffer_type];
++ pci_free_consistent(ioc->pcidev, request_data_sz,
++ request_data, request_data_dma);
++ ioc->DiagBuffer[buffer_type] = NULL;
++ ioc->DiagBuffer_Status[buffer_type] = 0;
++ return 0;
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/* QUERY DIAG BUFFER Routine.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -EBUSY if previous command timout and IOC reset is not complete.
++ * -ENODEV if no such device/adapter
++ * -ETIME if timer expires
++ * -ENOMEM if memory allocation error
++ */
++static int
++mptctl_query_diag_buffer (unsigned long arg)
++{
++ mpt_diag_query_t __user *uarg = (void __user *)arg;
++ mpt_diag_query_t karg;
++ MPT_ADAPTER *ioc;
++ void * request_data;
++ int iocnum, ii, rc;
++ u8 buffer_type;
++
++ rc = -EFAULT;
++ if (copy_from_user(&karg, uarg, sizeof(mpt_diag_query_t))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in mpt_diag_query_t struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ karg.data.Flags = 0;
++ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
++ (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ goto out;
++ }
++
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
++ __FUNCTION__));
++ buffer_type = karg.data.BufferType;
++ if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ goto out;
++ }
++
++ if ((ioc->DiagBuffer_Status[buffer_type] &
++ MPT_DIAG_BUFFER_IS_REGISTERED) == 0) {
++ printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x is not "
++ "registered\n", ioc->name, __FUNCTION__, buffer_type);
++ goto out;
++ }
++
++ if (karg.data.UniqueId & 0xffffff00) {
++ if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
++ printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not "
++ "registered\n", ioc->name, __FUNCTION__,
++ karg.data.UniqueId);
++ goto out;
++ }
++ }
++
++ request_data = ioc->DiagBuffer[buffer_type];
++ if (!request_data) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ goto out;
++ }
++
++ rc = 0;
++ if (buffer_type == MPI_DIAG_BUF_TYPE_EXTENDED) {
++ if (karg.data.ExtendedType != ioc->ExtendedType[buffer_type])
++ goto out;
++ } else
++ karg.data.ExtendedType = 0;
++
++ if (ioc->DiagBuffer_Status[buffer_type] & MPT_DIAG_BUFFER_IS_RELEASED)
++ karg.data.Flags = 3;
++ else
++ karg.data.Flags = 7;
++ karg.data.TraceLevel = ioc->TraceLevel[buffer_type];
++ for (ii = 0; ii < 4; ii++)
++ karg.data.ProductSpecific[ii] =
++ ioc->ProductSpecific[buffer_type][ii];
++ karg.data.DataSize = ioc->DiagBuffer_sz[buffer_type];
++ karg.data.DriverAddedBufferSize = 0;
++ karg.data.UniqueId = ioc->UniqueId[buffer_type];
++
++ out:
++ if (copy_to_user(uarg, &karg, sizeof(mpt_diag_query_t))) {
++ printk(MYIOC_s_ERR_FMT "%s Unable to write mpt_diag_query_t "
++ "data @ %p\n", ioc->name, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++ return rc;
++}
++
++/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
++/* READ DIAG BUFFER Routine.
++ *
++ * Outputs: None.
++ * Return: 0 if successful
++ * -EFAULT if data unavailable
++ * -EBUSY if previous command timout and IOC reset is not complete.
++ * -ENODEV if no such device/adapter
++ * -ETIME if timer expires
++ * -ENOMEM if memory allocation error
++ */
++static int
++mptctl_read_diag_buffer (unsigned long arg)
++{
++ mpt_diag_read_buffer_t __user *uarg = (void __user *) arg;
++ mpt_diag_read_buffer_t karg;
++ MPT_ADAPTER *ioc;
++ void *request_data, *diagData;
++ dma_addr_t request_data_dma;
++ DiagBufferPostRequest_t *diag_buffer_post_request;
++ DiagBufferPostReply_t *diag_buffer_post_reply;
++ MPT_FRAME_HDR *mf;
++ int iocnum, rc, ii;
++ u8 buffer_type;
++ u32 tmp;
++ unsigned long timeleft;
++
++ rc = 0;
++ if (copy_from_user(&karg, uarg, sizeof(mpt_diag_read_buffer_t))) {
++ printk(KERN_ERR "%s@%d::%s - "
++ "Unable to read in mpt_diag_read_buffer_t struct @ %p\n",
++ __FILE__, __LINE__, __FUNCTION__, uarg);
++ return -EFAULT;
++ }
++
++ if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
++ (ioc == NULL)) {
++ printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
++ __FILE__, __FUNCTION__, __LINE__, iocnum);
++ return -ENODEV;
++ }
++
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
++ __FUNCTION__));
++ buffer_type = karg.data.UniqueId & 0x000000ff;
++ if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability "
++ "for buffer_type=%x\n", ioc->name, __FUNCTION__,
++ buffer_type);
++ return -EFAULT;
++ }
++
++ if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
++ printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not registered\n",
++ ioc->name, __FUNCTION__, karg.data.UniqueId);
++ return -EFAULT;
++ }
++
++ request_data = ioc->DiagBuffer[buffer_type];
++ if (!request_data) {
++ printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
++ return -EFAULT;
++ }
++
++ diagData = (void *)(request_data + karg.data.StartingOffset);
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: diagData=%p "
++ "request_data=%p StartingOffset=%x\n", ioc->name, __FUNCTION__,
++ diagData, request_data, karg.data.StartingOffset));
++
++ if (copy_to_user((void __user *)&uarg->data.DiagnosticData[0],
++ diagData, karg.data.BytesToRead)) {
++ printk(MYIOC_s_ERR_FMT "%s: Unable to write "
++ "mpt_diag_read_buffer_t data @ %p\n", ioc->name,
++ __FUNCTION__, diagData);
++ return -EFAULT;
++ }
++
++ if ((karg.data.Flags & MPI_FW_DIAG_FLAG_REREGISTER) == 0)
++ goto out;
++
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Reregister "
++ "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type));
++ if ((ioc->DiagBuffer_Status[buffer_type] &
++ MPT_DIAG_BUFFER_IS_RELEASED) == 0) {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x "
++ "is still registered\n", ioc->name, __FUNCTION__,
++ buffer_type));
++ return rc;
++ }
++ /* Get a free request frame and save the message context.
++ */
++ if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
++ return -EAGAIN;
++
++ diag_buffer_post_request = (DiagBufferPostRequest_t *)mf;
++ diag_buffer_post_request->Function = MPI_FUNCTION_DIAG_BUFFER_POST;
++ diag_buffer_post_request->ChainOffset = 0;
++ diag_buffer_post_request->BufferType = buffer_type;
++ diag_buffer_post_request->TraceLevel =
++ ioc->TraceLevel[buffer_type];
++ diag_buffer_post_request->MsgFlags = 0;
++ diag_buffer_post_request->Reserved1 = 0;
++ diag_buffer_post_request->Reserved2 = 0;
++ diag_buffer_post_request->Reserved3 = 0;
++ diag_buffer_post_request->BufferAddress.High = 0;
++ if ( buffer_type == MPI_DIAG_BUF_TYPE_EXTENDED )
++ diag_buffer_post_request->ExtendedType =
++ cpu_to_le32(ioc->ExtendedType[buffer_type]);
++ diag_buffer_post_request->BufferLength =
++ cpu_to_le32(ioc->DiagBuffer_sz[buffer_type]);
++ for (ii = 0; ii < 4; ii++)
++ diag_buffer_post_request->ProductSpecific[ii] =
++ cpu_to_le32(ioc->ProductSpecific[buffer_type][ii]);
++ request_data_dma = ioc->DiagBuffer_dma[buffer_type];
++ tmp = request_data_dma & 0xFFFFFFFF;
++ diag_buffer_post_request->BufferAddress.Low = cpu_to_le32(tmp);
++ if (ioc->sg_addr_size == sizeof(u64)) {
++ tmp = (u32)((u64)request_data_dma >> 32);
++ diag_buffer_post_request->BufferAddress.High = cpu_to_le32(tmp);
++ }
++
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
++ diag_buffer_post_request->MsgContext);
++ INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
++ mpt_put_msg_frame(mptctl_id, ioc, mf);
++ timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
++ MPT_IOCTL_DEFAULT_TIMEOUT*HZ);
++ if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
++ rc = -ETIME;
++ printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name,
++ __FUNCTION__);
++ if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
++ mpt_free_msg_frame(ioc, mf);
++ goto out;
++ }
++ if (!timeleft)
++ mptctl_timeout_expired(ioc, mf);
++ goto out;
++ }
++
++ /* process the completed Reply Message Frame */
++ if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: status=%x\n",
++ ioc->name, __FUNCTION__, ioc->ioctl_cmds.status));
++ rc = -EFAULT;
++ }
++
++ diag_buffer_post_reply = (DiagBufferPostReply_t *)ioc->ioctl_cmds.reply;
++ if (le16_to_cpu(diag_buffer_post_reply->IOCStatus) ==
++ MPI_IOCSTATUS_SUCCESS) {
++ if (diag_buffer_post_reply->MsgLength > 5)
++ ioc->DataSize[buffer_type] =
++ le32_to_cpu(diag_buffer_post_reply->TransferLength);
++ ioc->DiagBuffer_Status[buffer_type] |=
++ MPT_DIAG_BUFFER_IS_REGISTERED;
++ } else {
++ dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: IOCStatus=%x "
++ "IOCLogInfo=%x\n", ioc->name, __FUNCTION__,
++ diag_buffer_post_reply->IOCStatus,
++ diag_buffer_post_reply->IOCLogInfo));
++ rc = -EFAULT;
++ }
++
++ out:
++ CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
++ SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
++ return rc;
++}
+--- /dev/null
++++ b/drivers/message/fusion/rejected_ioctls/diag_buffer.h
+@@ -0,0 +1,101 @@
++#define MPTDIAGREGISTER _IOWR(MPT_MAGIC_NUMBER,26,mpt_diag_register_t)
++#define MPTDIAGRELEASE _IOWR(MPT_MAGIC_NUMBER,27,mpt_diag_release_t)
++#define MPTDIAGUNREGISTER _IOWR(MPT_MAGIC_NUMBER,28,mpt_diag_unregister_t)
++#define MPTDIAGQUERY _IOWR(MPT_MAGIC_NUMBER,29,mpt_diag_query_t)
++#define MPTDIAGREADBUFFER _IOWR(MPT_MAGIC_NUMBER,30,mpt_diag_read_buffer_t)
++
++#define MPI_FW_DIAG_IOCTL (0x80646961)
++#define MPI_FW_DIAG_TYPE_REGISTER (0x00000001)
++#define MPI_FW_DIAG_TYPE_UNREGISTER (0x00000002)
++#define MPI_FW_DIAG_TYPE_QUERY (0x00000003)
++#define MPI_FW_DIAG_TYPE_READ_BUFFER (0x00000004)
++#define MPI_FW_DIAG_TYPE_RELEASE (0x00000005)
++
++#define MPI_FW_DIAG_INVALID_UID (0x00000000)
++#define FW_DIAGNOSTIC_BUFFER_COUNT (3)
++#define FW_DIAGNOSTIC_UID_NOT_FOUND (0xFF)
++
++#define MPI_FW_DIAG_ERROR_SUCCESS (0x00000000)
++#define MPI_FW_DIAG_ERROR_FAILURE (0x00000001)
++#define MPI_FW_DIAG_ERROR_INVALID_PARAMETER (0x00000002)
++#define MPI_FW_DIAG_ERROR_POST_FAILED (0x00000010)
++#define MPI_FW_DIAG_ERROR_INVALID_UID (0x00000011)
++
++#define MPI_FW_DIAG_ERROR_RELEASE_FAILED (0x00000012)
++#define MPI_FW_DIAG_ERROR_NO_BUFFER (0x00000013)
++#define MPI_FW_DIAG_ERROR_ALREADY_RELEASED (0x00000014)
++
++#define MPT_DIAG_CAPABILITY(bufftype) (MPI_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER << bufftype)
++
++#define MPT_DIAG_BUFFER_IS_REGISTERED 1
++#define MPT_DIAG_BUFFER_IS_RELEASED 2
++
++typedef struct _MPI_FW_DIAG_REGISTER {
++ u8 TraceLevel;
++ u8 BufferType;
++ u16 Flags;
++ u32 ExtendedType;
++ u32 ProductSpecific[4];
++ u32 RequestedBufferSize;
++ u32 UniqueId;
++} MPI_FW_DIAG_REGISTER, *PTR_MPI_FW_DIAG_REGISTER;
++
++typedef struct _mpt_diag_register {
++ mpt_ioctl_header hdr;
++ MPI_FW_DIAG_REGISTER data;
++} mpt_diag_register_t;
++
++typedef struct _MPI_FW_DIAG_UNREGISTER {
++ u32 UniqueId;
++} MPI_FW_DIAG_UNREGISTER, *PTR_MPI_FW_DIAG_UNREGISTER;
++
++typedef struct _mpt_diag_unregister {
++ mpt_ioctl_header hdr;
++ MPI_FW_DIAG_UNREGISTER data;
++} mpt_diag_unregister_t;
++
++#define MPI_FW_DIAG_FLAG_APP_OWNED (0x0001)
++#define MPI_FW_DIAG_FLAG_BUFFER_VALID (0x0002)
++#define MPI_FW_DIAG_FLAG_FW_BUFFER_ACCESS (0x0004)
++
++typedef struct _MPI_FW_DIAG_QUERY {
++ u8 TraceLevel;
++ u8 BufferType;
++ u16 Flags;
++ u32 ExtendedType;
++ u32 ProductSpecific[4];
++ u32 DataSize;
++ u32 DriverAddedBufferSize;
++ u32 UniqueId;
++} MPI_FW_DIAG_QUERY, *PTR_MPI_FW_DIAG_QUERY;
++
++typedef struct _mpt_diag_query {
++ mpt_ioctl_header hdr;
++ MPI_FW_DIAG_QUERY data;
++} mpt_diag_query_t;
++
++typedef struct _MPI_FW_DIAG_RELEASE {
++ u32 UniqueId;
++} MPI_FW_DIAG_RELEASE, *PTR_MPI_FW_DIAG_RELEASE;
++
++typedef struct _mpt_diag_release {
++ mpt_ioctl_header hdr;
++ MPI_FW_DIAG_RELEASE data;
++} mpt_diag_release_t;
++
++#define MPI_FW_DIAG_FLAG_REREGISTER (0x0001)
++
++typedef struct _MPI_FW_DIAG_READ_BUFFER {
++ u8 Status;
++ u8 Reserved;
++ u16 Flags;
++ u32 StartingOffset;
++ u32 BytesToRead;
++ u32 UniqueId;
++ u32 DiagnosticData[1];
++} MPI_FW_DIAG_READ_BUFFER, *PTR_MPI_FW_DIAG_READ_BUFFER;
++
++typedef struct _mpt_diag_read_buffer {
++ mpt_ioctl_header hdr;
++ MPI_FW_DIAG_READ_BUFFER data;
++} mpt_diag_read_buffer_t;
projects / people / pmueller / ipfire-2.x.git / blobdiff