/* * Scsi Host Layer for MPT ( Message Passing Technology ) based controllers * * This code is based on drivers / scsi / mpt3sas / mpt3sas_scsih . c * Copyright ( C ) 2012 - 2014 LSI Corporation * Copyright ( C ) 2013 - 2014 Avago Technologies * ( mailto : MPT - FusionLinux . pdl @ avagotech . com ) * * This program is free software ; you can redistribute it and / or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation ; either version 2 * of the License , or ( at your option ) any later version . * * This program is distributed in the hope that it will be useful , * but WITHOUT ANY WARRANTY ; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the * GNU General Public License for more details . * * NO WARRANTY * THE PROGRAM IS PROVIDED ON AN " AS IS " BASIS , WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND , EITHER EXPRESS OR IMPLIED INCLUDING , WITHOUT * LIMITATION , ANY WARRANTIES OR CONDITIONS OF TITLE , NON - INFRINGEMENT , * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE . Each Recipient is * solely responsible for determining the appropriateness of using and * distributing the Program and assumes all risks associated with its * exercise of rights under this Agreement , including but not limited to * the risks and costs of program errors , damage to or loss of data , * programs or equipment , and unavailability or interruption of operations . * DISCLAIMER OF LIABILITY * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY * DIRECT , INDIRECT , INCIDENTAL , SPECIAL , EXEMPLARY , OR CONSEQUENTIAL * DAMAGES ( INCLUDING WITHOUT LIMITATION LOST PROFITS ) , HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY , WHETHER IN CONTRACT , STRICT LIABILITY , OR * TORT ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED * HEREUNDER , EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES * You should have received a copy of the GNU General Public License * along with this program ; if not , write to the Free Software * Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 , * USA . #include <linux/module.h>#include <linux/kernel.h>#include <linux/init.h>#include <linux/errno.h>#include <linux/blkdev.h>#include <linux/sched.h>#include <linux/workqueue.h>#include <linux/delay.h>#include <linux/pci.h>#include <linux/interrupt.h>#include <linux/raid_class.h>#include <linux/unaligned.h>#include "mpt3sas_base.h" #define RAID_CHANNEL 1 #define PCIE_CHANNEL 2 /* forward proto's */ static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc,struct _sas_node *sas_expander);static void _firmware_event_work(struct work_struct *work);static void _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc,struct _sas_device *sas_device);static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle,static int _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle);static void _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc,struct _pcie_device *pcie_device);static void struct MPT3SAS_ADAPTER *ioc, u16 handle);static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid);static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc);/* global parameters */ /* global ioc lock for list operations */ "GPL" );"mpt2sas" );/* local parameters */ static u8 scsi_io_cb_idx = -1 ;static u8 tm_cb_idx = -1 ;static u8 ctl_cb_idx = -1 ;static u8 base_cb_idx = -1 ;static u8 port_enable_cb_idx = -1 ;static u8 transport_cb_idx = -1 ;static u8 scsih_cb_idx = -1 ;static u8 config_cb_idx = -1 ;static int mpt2_ids;static int mpt3_ids;static u8 tm_tr_cb_idx = -1 ;static u8 tm_tr_volume_cb_idx = -1 ;static u8 tm_sas_control_cb_idx = -1 ;/* command line options */ static u32 logging_level;" bits for enabling additional logging info (default=0)" );static ushort max_sectors = 0 xFFFF;0444 );"max sectors, range 64 to 32767 default=32767" );static int missing_delay[2 ] = {-1 , -1 };int , NULL, 0444 );" device missing delay , io missing delay" );/* scsi-mid layer global parmeter is max_report_luns, which is 511 */ #define MPT3SAS_MAX_LUN (16895 )static u64 max_lun = MPT3SAS_MAX_LUN;0444 );" max lun, default=16895 " );static ushort hbas_to_enumerate;0444 );" 0 - enumerates both SAS 2.0 & SAS 3.0 generation HBAs\n \ 1 - enumerates only SAS 2 .0 generation HBAs\n \2 - enumerates only SAS 3 .0 generation HBAs (default =0 )"); /* diag_buffer_enable is bitwise * bit 0 set = TRACE * bit 1 set = SNAPSHOT * bit 2 set = EXTENDED * * Either bit can be set , or both static int diag_buffer_enable = -1 ;int , 0444 );" post diag buffers (TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)" );static int disable_discovery = -1 ;int , 0444 );" disable discovery " );/* permit overriding the host protection capabilities mask (EEDP/T10 PI) */ static int prot_mask = -1 ;int , 0444 );" host protection capabilities mask, def=7 " );static bool enable_sdev_max_qd;bool , 0444 );"Enable sdev max qd as can_queue, def=disabled(0)" );static int multipath_on_hba = -1 ;int , 0 );"Multipath support to add same target device\n\t\t" "as many times as it is visible to HBA from various paths\n\t\t" "(by default:\n\t\t" "\t SAS 2.0 & SAS 3.0 HBA - This will be disabled,\n\t\t" "\t SAS 3.5 HBA - This will be enabled)" );static int host_tagset_enable = 1 ;int , 0444 );"Shared host tagset enable/disable Default: enable(1)" );/* raid transport support */ static struct raid_template *mpt3sas_raid_template;static struct raid_template *mpt2sas_raid_template;/** * struct sense_info - common structure for obtaining sense keys * @ skey : sense key * @ asc : additional sense code * @ ascq : additional sense code qualifier struct sense_info {#define MPT3SAS_PROCESS_TRIGGER_DIAG (0 xFFFB)#define MPT3SAS_TURN_ON_PFA_LED (0 xFFFC)#define MPT3SAS_PORT_ENABLE_COMPLETE (0 xFFFD)#define MPT3SAS_ABRT_TASK_SET (0 xFFFE)#define MPT3SAS_REMOVE_UNRESPONDING_DEVICES (0 xFFFF)/* * SAS Log info code for a NCQ collateral abort after an NCQ error : * IOC_LOGINFO_PREFIX_PL | PL_LOGINFO_CODE_SATA_NCQ_FAIL_ALL_CMDS_AFTR_ERR * See : drivers / message / fusion / lsi / mpi_log_sas . h #define IOC_LOGINFO_SATA_NCQ_FAIL_AFTER_ERR 0 x31080000/** * struct fw_event_work - firmware event struct * @ list : link list framework * @ work : work object ( ioc - > fault_reset_work_q ) * @ ioc : per adapter object * @ device_handle : device handle * @ VF_ID : virtual function id * @ VP_ID : virtual port id * @ ignore : flag meaning this event has been marked to ignore * @ event : firmware event MPI2_EVENT_XXX defined in mpi2_ioc . h * @ refcount : kref for this event * @ event_data : reply event data payload follows * * This object stored on ioc - > fw_event_list . struct fw_event_work {struct list_head list;struct work_struct work;struct MPT3SAS_ADAPTER *ioc;struct kref refcount;char event_data[] __aligned(4 );static void fw_event_work_free(struct kref *r)struct fw_event_work, refcount));static void fw_event_work_get(struct fw_event_work *fw_work)static void fw_event_work_put(struct fw_event_work *fw_work)static struct fw_event_work *alloc_fw_event_work(int len)struct fw_event_work *fw_event;sizeof (*fw_event) + len, GFP_ATOMIC);if (!fw_event)return NULL;return fw_event;/** * struct _ scsi_io_transfer - scsi io transfer * @ handle : sas device handle ( assigned by firmware ) * @ is_raid : flag set for hidden raid components * @ dir : DMA_TO_DEVICE , DMA_FROM_DEVICE , * @ data_length : data transfer length * @ data_dma : dma pointer to data * @ sense : sense data * @ lun : lun number * @ cdb_length : cdb length * @ cdb : cdb contents * @ timeout : timeout for this command * @ VF_ID : virtual function id * @ VP_ID : virtual port id * @ valid_reply : flag set for reply message * @ sense_length : sense length * @ ioc_status : ioc status * @ scsi_state : scsi state * @ scsi_status : scsi staus * @ log_info : log information * @ transfer_length : data length transfer when there is a reply message * * Used for sending internal scsi commands to devices within this module . * Refer to _ scsi_send_scsi_io ( ) . struct _scsi_io_transfer {enum dma_data_direction dir;32 ];/* the following bits are only valid when 'valid_reply = 1' */ /** * _ scsih_set_debug_level - global setting of ioc - > logging_level . * @ val : value of the parameter to be set * @ kp : pointer to kernel_param structure * * Note : The logging levels are defined in mpt3sas_debug . h . static int const char *val, const struct kernel_param *kp)int ret = param_set_int(val, kp);struct MPT3SAS_ADAPTER *ioc;if (ret)return ret;"setting logging_level(0x%08x)\n" , logging_level);return 0 ;0644 );/** * _ scsih_srch_boot_sas_address - search based on sas_address * @ sas_address : sas address * @ boot_device : boot device object from bios page 2 * * Return : 1 when there ' s a match , 0 means no match . static inline int return (sas_address == le64_to_cpu(boot_device->SASAddress)) ? 1 : 0 ;/** * _ scsih_srch_boot_device_name - search based on device name * @ device_name : device name specified in INDENTIFY fram * @ boot_device : boot device object from bios page 2 * * Return : 1 when there ' s a match , 0 means no match . static inline int return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0 ;/** * _ scsih_srch_boot_encl_slot - search based on enclosure_logical_id / slot * @ enclosure_logical_id : enclosure logical id * @ slot_number : slot number * @ boot_device : boot device object from bios page 2 * * Return : 1 when there ' s a match , 0 means no match . static inline int return (enclosure_logical_id == le64_to_cpu(boot_device->1 : 0 ;/** * mpt3sas_get_port_by_id - get hba port entry corresponding to provided * port number from port list * @ ioc : per adapter object * @ port_id : port number * @ bypass_dirty_port_flag : when set look the matching hba port entry even * if hba port entry is marked as dirty . * * Search for hba port entry corresponding to provided port number , * if available return port object otherwise return NULL . struct hba_port *struct MPT3SAS_ADAPTER *ioc,struct hba_port *port, *port_next;/* * When multipath_on_hba is disabled then * search the hba_port entry using default * port id i . e . 255 if (!ioc->multipath_on_hba)if (port->port_id != port_id)continue ;if (bypass_dirty_port_flag)return port;if (port->flags & HBA_PORT_FLAG_DIRTY_PORT)continue ;return port;/* * Allocate hba_port object for default port id ( i . e . 255 ) * when multipath_on_hba is disabled for the HBA . * And add this object to port_table_list . if (!ioc->multipath_on_hba) {sizeof (struct hba_port), GFP_ATOMIC);if (!port)return NULL;"hba_port entry: %p, port: %d is added to hba_port list\n" ,return port;return NULL;/** * mpt3sas_get_vphy_by_phy - get virtual_phy object corresponding to phy number * @ ioc : per adapter object * @ port : hba_port object * @ phy : phy number * * Return virtual_phy object corresponding to phy number . struct virtual_phy *struct MPT3SAS_ADAPTER *ioc,struct hba_port *port, u32 phy)struct virtual_phy *vphy, *vphy_next;if (!port->vphys_mask)return NULL;if (vphy->phy_mask & (1 << phy))return vphy;return NULL;/** * _ scsih_is_boot_device - search for matching boot device . * @ sas_address : sas address * @ device_name : device name specified in INDENTIFY fram * @ enclosure_logical_id : enclosure logical id * @ slot : slot number * @ form : specifies boot device form * @ boot_device : boot device object from bios page 2 * * Return : 1 when there ' s a match , 0 means no match . static int int rc = 0 ;switch (form) {case MPI2_BIOSPAGE2_FORM_SAS_WWID:if (!sas_address)break ;break ;case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT:if (!enclosure_logical_id)break ;break ;case MPI2_BIOSPAGE2_FORM_DEVICE_NAME:if (!device_name)break ;break ;case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED:break ;return rc;/** * _ scsih_get_sas_address - set the sas_address for given device handle * @ ioc : ? * @ handle : device handle * @ sas_address : sas address * * Return : 0 success , non - zero when failure static int struct MPT3SAS_ADAPTER *ioc, u16 handle,0 ;if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,"failure at %s:%d/%s()!\n" ,return -ENXIO;if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {/* For HBA, vSES doesn't return HBA SAS address. Instead return * vSES ' s sas address . if ((handle <= ioc->sas_hba.num_phys) &&else return 0 ;/* we hit this because the given parent handle doesn't exist */ if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)return -ENXIO;/* else error case */ "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n" ,return -EIO;/** * _ scsih_determine_boot_device - determine boot device . * @ ioc : per adapter object * @ device : sas_device or pcie_device object * @ channel : SAS or PCIe channel * * Determines whether this device should be first reported device to * to scsi - ml or sas transport , this purpose is for persistent boot device . * There are primary , alternate , and current entries in bios page 2 . The order * priority is primary , alternate , then current . This routine saves * the corresponding device object . * The saved data to be used later in _ scsih_probe_boot_devices ( ) . static void struct MPT3SAS_ADAPTER *ioc, void *device,struct _sas_device *sas_device;struct _pcie_device *pcie_device;struct _raid_device *raid_device;/* only process this function when driver loads */ if (!ioc->is_driver_loading)return ;/* no Bios, return immediately */ if (!ioc->bios_pg3.BiosVersion)return ;if (channel == RAID_CHANNEL) {0 ;0 ;0 ;else if (channel == PCIE_CHANNEL) {0 ;0 ;0 ;else {if (!ioc->req_boot_device.device) {if (_scsih_is_boot_device(sas_address, device_name,"%s: req_boot_device(0x%016llx)\n" ,if (!ioc->req_alt_boot_device.device) {if (_scsih_is_boot_device(sas_address, device_name,"%s: req_alt_boot_device(0x%016llx)\n" ,if (!ioc->current_boot_device.device) {if (_scsih_is_boot_device(sas_address, device_name,"%s: current_boot_device(0x%016llx)\n" ,static struct _sas_device *struct MPT3SAS_ADAPTER *ioc,struct MPT3SAS_TARGET *tgt_priv)struct _sas_device *ret;if (ret)return ret;static struct _sas_device *struct MPT3SAS_ADAPTER *ioc,struct MPT3SAS_TARGET *tgt_priv)struct _sas_device *ret;unsigned long flags;return ret;static struct _pcie_device *struct MPT3SAS_ADAPTER *ioc,struct MPT3SAS_TARGET *tgt_priv)struct _pcie_device *ret;if (ret)return ret;/** * mpt3sas_get_pdev_from_target - pcie device search * @ ioc : per adapter object * @ tgt_priv : starget private object * * Context : This function will acquire ioc - > pcie_device_lock and will release * before returning the pcie_device object . * * This searches for pcie_device from target , then return pcie_device object . static struct _pcie_device *struct MPT3SAS_ADAPTER *ioc,struct MPT3SAS_TARGET *tgt_priv)struct _pcie_device *ret;unsigned long flags;return ret;/** * _ _ mpt3sas_get_sdev_by_rphy - sas device search * @ ioc : per adapter object * @ rphy : sas_rphy pointer * * Context : This function will acquire ioc - > sas_device_lock and will release * before returning the sas_device object . * * This searches for sas_device from rphy object * then return sas_device object . struct _sas_device *struct MPT3SAS_ADAPTER *ioc,struct sas_rphy *rphy)struct _sas_device *sas_device;if (sas_device->rphy != rphy)continue ;return sas_device;if (sas_device->rphy != rphy)continue ;return sas_device;return NULL;/** * _ _ mpt3sas_get_sdev_by_addr - get _ sas_device object corresponding to provided * sas address from sas_device_list list * @ ioc : per adapter object * @ sas_address : device sas address * @ port : port number * * Search for _ sas_device object corresponding to provided sas address , * if available return _ sas_device object address otherwise return NULL . struct _sas_device *struct MPT3SAS_ADAPTER *ioc,struct hba_port *port)struct _sas_device *sas_device;if (!port)return NULL;if (sas_device->sas_address != sas_address)continue ;if (sas_device->port != port)continue ;return sas_device;if (sas_device->sas_address != sas_address)continue ;if (sas_device->port != port)continue ;return sas_device;return NULL;/** * mpt3sas_get_sdev_by_addr - sas device search * @ ioc : per adapter object * @ sas_address : sas address * @ port : hba port entry * Context : Calling function should acquire ioc - > sas_device_lock * * This searches for sas_device based on sas_address & port number , * then return sas_device object . struct _sas_device *struct MPT3SAS_ADAPTER *ioc,struct hba_port *port)struct _sas_device *sas_device;unsigned long flags;return sas_device;static struct _sas_device *struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _sas_device *sas_device;if (sas_device->handle == handle)goto found_device;if (sas_device->handle == handle)goto found_device;return NULL;return sas_device;/** * mpt3sas_get_sdev_by_handle - sas device search * @ ioc : per adapter object * @ handle : sas device handle ( assigned by firmware ) * Context : Calling function should acquire ioc - > sas_device_lock * * This searches for sas_device based on sas_address , then return sas_device * object . struct _sas_device *struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _sas_device *sas_device;unsigned long flags;return sas_device;/** * _ scsih_display_enclosure_chassis_info - display device location info * @ ioc : per adapter object * @ sas_device : per sas device object * @ sdev : scsi device struct * @ starget : scsi target struct static void struct MPT3SAS_ADAPTER *ioc,struct _sas_device *sas_device, struct scsi_device *sdev,struct scsi_target *starget)if (sdev) {if (sas_device->enclosure_handle != 0 )"enclosure logical id (0x%016llx), slot(%d) \n" ,unsigned long long )if (sas_device->connector_name[0 ] != '\0' )"enclosure level(0x%04x), connector name( %s)\n" ,if (sas_device->is_chassis_slot_valid)"chassis slot(0x%04x)\n" ,else if (starget) {if (sas_device->enclosure_handle != 0 )"enclosure logical id(0x%016llx), slot(%d) \n" ,unsigned long long )if (sas_device->connector_name[0 ] != '\0' )"enclosure level(0x%04x), connector name( %s)\n" ,if (sas_device->is_chassis_slot_valid)"chassis slot(0x%04x)\n" ,else {if (sas_device->enclosure_handle != 0 )"enclosure logical id(0x%016llx), slot(%d)\n" ,if (sas_device->connector_name[0 ] != '\0' )"enclosure level(0x%04x), connector name( %s)\n" ,if (sas_device->is_chassis_slot_valid)"chassis slot(0x%04x)\n" ,/** * _ scsih_sas_device_remove - remove sas_device from list . * @ ioc : per adapter object * @ sas_device : the sas_device object * Context : This function will acquire ioc - > sas_device_lock . * * If sas_device is on the list , remove it and decrement its reference count . static void struct MPT3SAS_ADAPTER *ioc,struct _sas_device *sas_device)unsigned long flags;if (!sas_device)return ;"removing handle(0x%04x), sas_addr(0x%016llx)\n" ,/* * The lock serializes access to the list , but we still need to verify * that nobody removed the entry while we were waiting on the lock . if (!list_empty(&sas_device->list)) {/** * _ scsih_device_remove_by_handle - removing device object by handle * @ ioc : per adapter object * @ handle : device handle static void struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _sas_device *sas_device;unsigned long flags;if (ioc->shost_recovery)return ;if (sas_device) {if (sas_device) {/** * mpt3sas_device_remove_by_sas_address - removing device object by * sas address & port number * @ ioc : per adapter object * @ sas_address : device sas_address * @ port : hba port entry * * Return nothing . void struct MPT3SAS_ADAPTER *ioc,struct hba_port *port)struct _sas_device *sas_device;unsigned long flags;if (ioc->shost_recovery)return ;if (sas_device) {if (sas_device) {/** * _ scsih_sas_device_add - insert sas_device to the list . * @ ioc : per adapter object * @ sas_device : the sas_device object * Context : This function will acquire ioc - > sas_device_lock . * * Adding new object to the ioc - > sas_device_list . static void struct MPT3SAS_ADAPTER *ioc,struct _sas_device *sas_device)unsigned long flags;"%s: handle(0x%04x), sas_addr(0x%016llx)\n" ,if (ioc->hide_drives) {return ;if (!mpt3sas_transport_port_add(ioc, sas_device->handle,else if (!sas_device->starget) {/* * When asyn scanning is enabled , its not possible to remove * devices while scanning is turned on due to an oops in * scsi_sysfs_add_sdev ( ) - > add_device ( ) - > sysfs_addrm_start ( ) if (!ioc->is_driver_loading) {else /** * _ scsih_sas_device_init_add - insert sas_device to the list . * @ ioc : per adapter object * @ sas_device : the sas_device object * Context : This function will acquire ioc - > sas_device_lock . * * Adding new object at driver load time to the ioc - > sas_device_init_list . static void struct MPT3SAS_ADAPTER *ioc,struct _sas_device *sas_device)unsigned long flags;"%s: handle(0x%04x), sas_addr(0x%016llx)\n" ,0 );static struct _pcie_device *struct MPT3SAS_ADAPTER *ioc, u64 wwid)struct _pcie_device *pcie_device;if (pcie_device->wwid == wwid)goto found_device;if (pcie_device->wwid == wwid)goto found_device;return NULL;return pcie_device;/** * mpt3sas_get_pdev_by_wwid - pcie device search * @ ioc : per adapter object * @ wwid : wwid * * Context : This function will acquire ioc - > pcie_device_lock and will release * before returning the pcie_device object . * * This searches for pcie_device based on wwid , then return pcie_device object . static struct _pcie_device *struct MPT3SAS_ADAPTER *ioc, u64 wwid)struct _pcie_device *pcie_device;unsigned long flags;return pcie_device;static struct _pcie_device *struct MPT3SAS_ADAPTER *ioc, int id,int channel)struct _pcie_device *pcie_device;if (pcie_device->id == id && pcie_device->channel == channel)goto found_device;if (pcie_device->id == id && pcie_device->channel == channel)goto found_device;return NULL;return pcie_device;static struct _pcie_device *struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _pcie_device *pcie_device;if (pcie_device->handle == handle)goto found_device;if (pcie_device->handle == handle)goto found_device;return NULL;return pcie_device;/** * mpt3sas_get_pdev_by_handle - pcie device search * @ ioc : per adapter object * @ handle : Firmware device handle * * Context : This function will acquire ioc - > pcie_device_lock and will release * before returning the pcie_device object . * * This searches for pcie_device based on handle , then return pcie_device * object . struct _pcie_device *struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _pcie_device *pcie_device;unsigned long flags;return pcie_device;/** * _ scsih_set_nvme_max_shutdown_latency - Update max_shutdown_latency . * @ ioc : per adapter object * Context : This function will acquire ioc - > pcie_device_lock * * Update ioc - > max_shutdown_latency to that NVMe drives RTD3 Entry Latency * which has reported maximum among all available NVMe drives . * Minimum max_shutdown_latency will be six seconds . static void struct MPT3SAS_ADAPTER *ioc)struct _pcie_device *pcie_device;unsigned long flags;if (pcie_device->shutdown_latency) {if (shutdown_latency < pcie_device->shutdown_latency)/** * _ scsih_pcie_device_remove - remove pcie_device from list . * @ ioc : per adapter object * @ pcie_device : the pcie_device object * Context : This function will acquire ioc - > pcie_device_lock . * * If pcie_device is on the list , remove it and decrement its reference count . static void struct MPT3SAS_ADAPTER *ioc,struct _pcie_device *pcie_device)unsigned long flags;int was_on_pcie_device_list = 0 ;0 ;if (!pcie_device)return ;"removing handle(0x%04x), wwid(0x%016llx)\n" ,if (pcie_device->enclosure_handle != 0 )"removing enclosure logical id(0x%016llx), slot(%d)\n" ,if (pcie_device->connector_name[0 ] != '\0' )"removing enclosure level(0x%04x), connector name( %s)\n" ,if (!list_empty(&pcie_device->list)) {1 ;if (pcie_device->shutdown_latency == ioc->max_shutdown_latency)1 ;if (was_on_pcie_device_list) {/* * This device ' s RTD3 Entry Latency matches IOC ' s * max_shutdown_latency . Recalculate IOC ' s max_shutdown_latency * from the available drives as current drive is getting removed . if (update_latency)/** * _ scsih_pcie_device_remove_by_handle - removing pcie device object by handle * @ ioc : per adapter object * @ handle : device handle static void struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _pcie_device *pcie_device;unsigned long flags;int was_on_pcie_device_list = 0 ;0 ;if (ioc->shost_recovery)return ;if (pcie_device) {if (!list_empty(&pcie_device->list)) {1 ;if (pcie_device->shutdown_latency == ioc->max_shutdown_latency)1 ;if (was_on_pcie_device_list) {/* * This device ' s RTD3 Entry Latency matches IOC ' s * max_shutdown_latency . Recalculate IOC ' s max_shutdown_latency * from the available drives as current drive is getting removed . if (update_latency)/** * _ scsih_pcie_device_add - add pcie_device object * @ ioc : per adapter object * @ pcie_device : pcie_device object * * This is added to the pcie_device_list link list . static void struct MPT3SAS_ADAPTER *ioc,struct _pcie_device *pcie_device)unsigned long flags;"%s: handle (0x%04x), wwid(0x%016llx)\n" ,if (pcie_device->enclosure_handle != 0 )"%s: enclosure logical id(0x%016llx), slot( %d)\n" ,if (pcie_device->connector_name[0 ] != '\0' )"%s: enclosure level(0x%04x), connector name( %s)\n" ,if (pcie_device->access_status ==return ;if (scsi_add_device(ioc->shost, PCIE_CHANNEL, pcie_device->id, 0 )) {else if (!pcie_device->starget) {if (!ioc->is_driver_loading) {/*TODO-- Need to find out whether this condition will occur or not*/ else /* * _ scsih_pcie_device_init_add - insert pcie_device to the init list . * @ ioc : per adapter object * @ pcie_device : the pcie_device object * Context : This function will acquire ioc - > pcie_device_lock . * * Adding new object at driver load time to the ioc - > pcie_device_init_list . static void struct MPT3SAS_ADAPTER *ioc,struct _pcie_device *pcie_device)unsigned long flags;"%s: handle (0x%04x), wwid(0x%016llx)\n" ,if (pcie_device->enclosure_handle != 0 )"%s: enclosure logical id(0x%016llx), slot( %d)\n" ,if (pcie_device->connector_name[0 ] != '\0' )"%s: enclosure level(0x%04x), connector name( %s)\n" ,if (pcie_device->access_status !=/** * _ scsih_raid_device_find_by_id - raid device search * @ ioc : per adapter object * @ id : sas device target id * @ channel : sas device channel * Context : Calling function should acquire ioc - > raid_device_lock * * This searches for raid_device based on target id , then return raid_device * object . static struct _raid_device *struct MPT3SAS_ADAPTER *ioc, int id, int channel)struct _raid_device *raid_device, *r;if (raid_device->id == id && raid_device->channel == channel) {goto out;return r;/** * mpt3sas_raid_device_find_by_handle - raid device search * @ ioc : per adapter object * @ handle : sas device handle ( assigned by firmware ) * Context : Calling function should acquire ioc - > raid_device_lock * * This searches for raid_device based on handle , then return raid_device * object . struct _raid_device *struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _raid_device *raid_device, *r;if (raid_device->handle != handle)continue ;goto out;return r;/** * _ scsih_raid_device_find_by_wwid - raid device search * @ ioc : per adapter object * @ wwid : ? * Context : Calling function should acquire ioc - > raid_device_lock * * This searches for raid_device based on wwid , then return raid_device * object . static struct _raid_device *struct MPT3SAS_ADAPTER *ioc, u64 wwid)struct _raid_device *raid_device, *r;if (raid_device->wwid != wwid)continue ;goto out;return r;/** * _ scsih_raid_device_add - add raid_device object * @ ioc : per adapter object * @ raid_device : raid_device object * * This is added to the raid_device_list link list . static void struct MPT3SAS_ADAPTER *ioc,struct _raid_device *raid_device)unsigned long flags;"%s: handle(0x%04x), wwid(0x%016llx)\n" ,/** * _ scsih_raid_device_remove - delete raid_device object * @ ioc : per adapter object * @ raid_device : raid_device object * static void struct MPT3SAS_ADAPTER *ioc,struct _raid_device *raid_device)unsigned long flags;/** * mpt3sas_scsih_expander_find_by_handle - expander device search * @ ioc : per adapter object * @ handle : expander handle ( assigned by firmware ) * Context : Calling function should acquire ioc - > sas_device_lock * * This searches for expander device based on handle , then returns the * sas_node object . struct _sas_node *struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _sas_node *sas_expander, *r;if (sas_expander->handle != handle)continue ;goto out;return r;/** * mpt3sas_scsih_enclosure_find_by_handle - exclosure device search * @ ioc : per adapter object * @ handle : enclosure handle ( assigned by firmware ) * Context : Calling function should acquire ioc - > sas_device_lock * * This searches for enclosure device based on handle , then returns the * enclosure object . static struct _enclosure_node *struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _enclosure_node *enclosure_dev, *r;if (le16_to_cpu(enclosure_dev->pg0.EnclosureHandle) != handle)continue ;goto out;return r;/** * mpt3sas_scsih_expander_find_by_sas_address - expander device search * @ ioc : per adapter object * @ sas_address : sas address * @ port : hba port entry * Context : Calling function should acquire ioc - > sas_node_lock . * * This searches for expander device based on sas_address & port number , * then returns the sas_node object . struct _sas_node *struct MPT3SAS_ADAPTER *ioc,struct hba_port *port)struct _sas_node *sas_expander, *r = NULL;if (!port)return r;if (sas_expander->sas_address != sas_address)continue ;if (sas_expander->port != port)continue ;goto out;return r;/** * _ scsih_expander_node_add - insert expander device to the list . * @ ioc : per adapter object * @ sas_expander : the sas_device object * Context : This function will acquire ioc - > sas_node_lock . * * Adding new object to the ioc - > sas_expander_list . static void struct MPT3SAS_ADAPTER *ioc,struct _sas_node *sas_expander)unsigned long flags;/** * _ scsih_is_end_device - determines if device is an end device * @ device_info : bitfield providing information about the device . * Context : none * * Return : 1 if end device . static int if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE &&return 1 ;else return 0 ;/** * _ scsih_is_nvme_pciescsi_device - determines if * device is an pcie nvme / scsi device * @ device_info : bitfield providing information about the device . * Context : none * * Returns 1 if device is pcie device type nvme / scsi . static int if (((device_info & MPI26_PCIE_DEVINFO_MASK_DEVICE_TYPE)return 1 ;else return 0 ;/** * _ scsih_scsi_lookup_find_by_target - search for matching channel : id * @ ioc : per adapter object * @ id : target id * @ channel : channel * Context : This function will acquire ioc - > scsi_lookup_lock . * * This will search for a matching channel : id in the scsi_lookup array , * returning 1 if found . static u8struct MPT3SAS_ADAPTER *ioc, int id,int channel)int smid;struct scsi_cmnd *scmd;for (smid = 1 ;if (!scmd)continue ;if (scmd->device->id == id &&return 1 ;return 0 ;/** * _ scsih_scsi_lookup_find_by_lun - search for matching channel : id : lun * @ ioc : per adapter object * @ id : target id * @ lun : lun number * @ channel : channel * Context : This function will acquire ioc - > scsi_lookup_lock . * * This will search for a matching channel : id : lun in the scsi_lookup array , * returning 1 if found . static u8struct MPT3SAS_ADAPTER *ioc, int id,unsigned int lun, int channel)int smid;struct scsi_cmnd *scmd;for (smid = 1 ; smid <= ioc->shost->can_queue; smid++) {if (!scmd)continue ;if (scmd->device->id == id &&return 1 ;return 0 ;/** * mpt3sas_scsih_scsi_lookup_get - returns scmd entry * @ ioc : per adapter object * @ smid : system request message index * * Return : the smid stored scmd pointer . * Then will dereference the stored scmd pointer . struct scsi_cmnd *struct MPT3SAS_ADAPTER *ioc, u16 smid)struct scsi_cmnd *scmd = NULL;struct scsiio_tracker *st;1 ;if (smid > 0 &&/* * If SCSI IO request is outstanding at driver level then * DevHandle filed must be non - zero . If DevHandle is zero * then it means that this smid is free at driver level , * so return NULL . * / if ( ! mpi_request - > DevHandle ) return scmd ; scmd = scsi_host_find_tag ( ioc - > shost , unique_tag ) ; if ( scmd ) { st = scsi_cmd_priv ( scmd ) ; if ( st - > cb_idx = = 0 xFF | | st - > smid = = 0 ) scmd = NULL ; } } return scmd ; } / * * * scsih_change_queue_depth - setting device queue depth * @ sdev : scsi device struct * @ qdepth : requested queue depth * * Return : queue depth . * / static int scsih_change_queue_depth ( struct scsi_device * sdev , int qdepth ) { struct Scsi_Host * shost = sdev - > host ; int max_depth ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( shost ) ; struct MPT3SAS_DEVICE * sas_device_priv_data ; struct MPT3SAS_TARGET * sas_target_priv_data ; struct _ sas_device * sas_device ; unsigned long flags ; max_depth = shost - > can_queue ; / * * limit max device queue for SATA to 32 if enable_sdev_max_qd * is disabled . * / if ( ioc - > enable_sdev_max_qd | | ioc - > is_gen35_ioc ) goto not_sata ; sas_device_priv_data = sdev - > hostdata ; if ( ! sas_device_priv_data ) goto not_sata ; sas_target_priv_data = sas_device_priv_data - > sas_target ; if ( ! sas_target_priv_data ) goto not_sata ; if ( ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_VOLUME ) ) goto not_sata ; spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_from_target ( ioc , sas_target_priv_data ) ; if ( sas_device ) { if ( sas_device - > device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE ) max_depth = MPT3SAS_SATA_QUEUE_DEPTH ; sas_device_put ( sas_device ) ; } spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; not_sata : if ( ! sdev - > tagged_supported ) max_depth = 1 ; if ( qdepth > max_depth ) qdepth = max_depth ; scsi_change_queue_depth ( sdev , qdepth ) ; sdev_printk ( KERN_INFO , sdev , " qdepth ( % d ) , tagged ( % d ) , scsi_level ( % d ) , cmd_que ( % d ) \ n " , sdev - > queue_depth , sdev - > tagged_supported , sdev - > scsi_level , ( ( sdev - > inquiry [ 7 ] & 2 ) > > 1 ) ) ; return sdev - > queue_depth ; } / * * * mpt3sas_scsih_change_queue_depth - setting device queue depth * @ sdev : scsi device struct * @ qdepth : requested queue depth * * Returns nothing . * / void mpt3sas_scsih_change_queue_depth ( struct scsi_device * sdev , int qdepth ) { struct Scsi_Host * shost = sdev - > host ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( shost ) ; if ( ioc - > enable_sdev_max_qd ) qdepth = shost - > can_queue ; scsih_change_queue_depth ( sdev , qdepth ) ; } / * * * scsih_target_alloc - target add routine * @ starget : scsi target struct * * Return : 0 if ok . Any other return is assumed to be an error and * the device is ignored . * / static int scsih_target_alloc ( struct scsi_target * starget ) { struct Scsi_Host * shost = dev_to_shost ( & starget - > dev ) ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( shost ) ; struct MPT3SAS_TARGET * sas_target_priv_data ; struct _ sas_device * sas_device ; struct _ raid_device * raid_device ; struct _ pcie_device * pcie_device ; unsigned long flags ; struct sas_rphy * rphy ; sas_target_priv_data = kzalloc ( sizeof ( * sas_target_priv_data ) , GFP_KERNEL ) ; if ( ! sas_target_priv_data ) return - ENOMEM ; starget - > hostdata = sas_target_priv_data ; sas_target_priv_data - > starget = starget ; sas_target_priv_data - > handle = MPT3SAS_INVALID_DEVICE_HANDLE ; / * RAID volumes * / if ( starget - > channel = = RAID_CHANNEL ) { spin_lock_irqsave ( & ioc - > raid_device_lock , flags ) ; raid_device = _ scsih_raid_device_find_by_id ( ioc , starget - > id , starget - > channel ) ; if ( raid_device ) { sas_target_priv_data - > handle = raid_device - > handle ; sas_target_priv_data - > sas_address = raid_device - > wwid ; sas_target_priv_data - > flags | = MPT_TARGET_FLAGS_VOLUME ; if ( ioc - > is_warpdrive ) sas_target_priv_data - > raid_device = raid_device ; raid_device - > starget = starget ; } spin_unlock_irqrestore ( & ioc - > raid_device_lock , flags ) ; return 0 ; } / * PCIe devices * / if ( starget - > channel = = PCIE_CHANNEL ) { spin_lock_irqsave ( & ioc - > pcie_device_lock , flags ) ; pcie_device = _ _ mpt3sas_get_pdev_by_idchannel ( ioc , starget - > id , starget - > channel ) ; if ( pcie_device ) { sas_target_priv_data - > handle = pcie_device - > handle ; sas_target_priv_data - > sas_address = pcie_device - > wwid ; sas_target_priv_data - > port = NULL ; sas_target_priv_data - > pcie_dev = pcie_device ; pcie_device - > starget = starget ; pcie_device - > id = starget - > id ; pcie_device - > channel = starget - > channel ; sas_target_priv_data - > flags | = MPT_TARGET_FLAGS_PCIE_DEVICE ; if ( pcie_device - > fast_path ) sas_target_priv_data - > flags | = MPT_TARGET_FASTPATH_IO ; } spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; return 0 ; } / * sas / sata devices * / spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; rphy = dev_to_rphy ( starget - > dev . parent ) ; sas_device = _ _ mpt3sas_get_sdev_by_rphy ( ioc , rphy ) ; if ( sas_device ) { sas_target_priv_data - > handle = sas_device - > handle ; sas_target_priv_data - > sas_address = sas_device - > sas_address ; sas_target_priv_data - > port = sas_device - > port ; sas_target_priv_data - > sas_dev = sas_device ; sas_device - > starget = starget ; sas_device - > id = starget - > id ; sas_device - > channel = starget - > channel ; if ( test_bit ( sas_device - > handle , ioc - > pd_handles ) ) sas_target_priv_data - > flags | = MPT_TARGET_FLAGS_RAID_COMPONENT ; if ( sas_device - > fast_path ) sas_target_priv_data - > flags | = MPT_TARGET_FASTPATH_IO ; } spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; return 0 ; } / * * * scsih_target_destroy - target destroy routine * @ starget : scsi target struct * / static void scsih_target_destroy ( struct scsi_target * starget ) { struct Scsi_Host * shost = dev_to_shost ( & starget - > dev ) ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( shost ) ; struct MPT3SAS_TARGET * sas_target_priv_data ; struct _ sas_device * sas_device ; struct _ raid_device * raid_device ; struct _ pcie_device * pcie_device ; unsigned long flags ; sas_target_priv_data = starget - > hostdata ; if ( ! sas_target_priv_data ) return ; if ( starget - > channel = = RAID_CHANNEL ) { spin_lock_irqsave ( & ioc - > raid_device_lock , flags ) ; raid_device = _ scsih_raid_device_find_by_id ( ioc , starget - > id , starget - > channel ) ; if ( raid_device ) { raid_device - > starget = NULL ; raid_device - > sdev = NULL ; } spin_unlock_irqrestore ( & ioc - > raid_device_lock , flags ) ; goto out ; } if ( starget - > channel = = PCIE_CHANNEL ) { spin_lock_irqsave ( & ioc - > pcie_device_lock , flags ) ; pcie_device = _ _ mpt3sas_get_pdev_from_target ( ioc , sas_target_priv_data ) ; if ( pcie_device & & ( pcie_device - > starget = = starget ) & & ( pcie_device - > id = = starget - > id ) & & ( pcie_device - > channel = = starget - > channel ) ) pcie_device - > starget = NULL ; if ( pcie_device ) { / * * Corresponding get ( ) is in _ scsih_target_alloc ( ) * / sas_target_priv_data - > pcie_dev = NULL ; pcie_device_put ( pcie_device ) ; pcie_device_put ( pcie_device ) ; } spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; goto out ; } spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_from_target ( ioc , sas_target_priv_data ) ; if ( sas_device & & ( sas_device - > starget = = starget ) & & ( sas_device - > id = = starget - > id ) & & ( sas_device - > channel = = starget - > channel ) ) sas_device - > starget = NULL ; if ( sas_device ) { / * * Corresponding get ( ) is in _ scsih_target_alloc ( ) * / sas_target_priv_data - > sas_dev = NULL ; sas_device_put ( sas_device ) ; sas_device_put ( sas_device ) ; } spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; out : kfree ( sas_target_priv_data ) ; starget - > hostdata = NULL ; } / * * * scsih_sdev_init - device add routine * @ sdev : scsi device struct * * Return : 0 if ok . Any other return is assumed to be an error and * the device is ignored . * / static int scsih_sdev_init ( struct scsi_device * sdev ) { struct Scsi_Host * shost ; struct MPT3SAS_ADAPTER * ioc ; struct MPT3SAS_TARGET * sas_target_priv_data ; struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsi_target * starget ; struct _ raid_device * raid_device ; struct _ sas_device * sas_device ; struct _ pcie_device * pcie_device ; unsigned long flags ; sas_device_priv_data = kzalloc ( sizeof ( * sas_device_priv_data ) , GFP_KERNEL ) ; if ( ! sas_device_priv_data ) return - ENOMEM ; sas_device_priv_data - > lun = sdev - > lun ; sas_device_priv_data - > flags = MPT_DEVICE_FLAGS_INIT ; starget = scsi_target ( sdev ) ; sas_target_priv_data = starget - > hostdata ; sas_target_priv_data - > num_luns + + ; sas_device_priv_data - > sas_target = sas_target_priv_data ; sdev - > hostdata = sas_device_priv_data ; if ( ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT ) ) sdev - > no_uld_attach = 1 ; shost = dev_to_shost ( & starget - > dev ) ; ioc = shost_priv ( shost ) ; if ( starget - > channel = = RAID_CHANNEL ) { spin_lock_irqsave ( & ioc - > raid_device_lock , flags ) ; raid_device = _ scsih_raid_device_find_by_id ( ioc , starget - > id , starget - > channel ) ; if ( raid_device ) raid_device - > sdev = sdev ; / * raid is single lun * / spin_unlock_irqrestore ( & ioc - > raid_device_lock , flags ) ; } if ( starget - > channel = = PCIE_CHANNEL ) { spin_lock_irqsave ( & ioc - > pcie_device_lock , flags ) ; pcie_device = _ _ mpt3sas_get_pdev_by_wwid ( ioc , sas_target_priv_data - > sas_address ) ; if ( pcie_device & & ( pcie_device - > starget = = NULL ) ) { sdev_printk ( KERN_INFO , sdev , " % s : pcie_device - > starget set to starget @ % d \ n " , _ _ func__ , _ _ LINE__ ) ; pcie_device - > starget = starget ; } if ( pcie_device ) pcie_device_put ( pcie_device ) ; spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; } else if ( ! ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_VOLUME ) ) { spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_by_addr ( ioc , sas_target_priv_data - > sas_address , sas_target_priv_data - > port ) ; if ( sas_device & & ( sas_device - > starget = = NULL ) ) { sdev_printk ( KERN_INFO , sdev , " % s : sas_device - > starget set to starget @ % d \ n " , _ _ func__ , _ _ LINE__ ) ; sas_device - > starget = starget ; } if ( sas_device ) sas_device_put ( sas_device ) ; spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; } return 0 ; } / * * * scsih_sdev_destroy - device destroy routine * @ sdev : scsi device struct * / static void scsih_sdev_destroy ( struct scsi_device * sdev ) { struct MPT3SAS_TARGET * sas_target_priv_data ; struct scsi_target * starget ; struct Scsi_Host * shost ; struct MPT3SAS_ADAPTER * ioc ; struct _ sas_device * sas_device ; struct _ pcie_device * pcie_device ; unsigned long flags ; if ( ! sdev - > hostdata ) return ; starget = scsi_target ( sdev ) ; sas_target_priv_data = starget - > hostdata ; sas_target_priv_data - > num_luns - - ; shost = dev_to_shost ( & starget - > dev ) ; ioc = shost_priv ( shost ) ; if ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_PCIE_DEVICE ) { spin_lock_irqsave ( & ioc - > pcie_device_lock , flags ) ; pcie_device = _ _ mpt3sas_get_pdev_from_target ( ioc , sas_target_priv_data ) ; if ( pcie_device & & ! sas_target_priv_data - > num_luns ) pcie_device - > starget = NULL ; if ( pcie_device ) pcie_device_put ( pcie_device ) ; spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; } else if ( ! ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_VOLUME ) ) { spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_from_target ( ioc , sas_target_priv_data ) ; if ( sas_device & & ! sas_target_priv_data - > num_luns ) sas_device - > starget = NULL ; if ( sas_device ) sas_device_put ( sas_device ) ; spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; } kfree ( sdev - > hostdata ) ; sdev - > hostdata = NULL ; } / * * * _ scsih_display_sata_capabilities - sata capabilities * @ ioc : per adapter object * @ handle : device handle * @ sdev : scsi device struct * / static void _ scsih_display_sata_capabilities ( struct MPT3SAS_ADAPTER * ioc , u16 handle , struct scsi_device * sdev ) { Mpi2ConfigReply_t mpi_reply ; Mpi2SasDevicePage0_t sas_device_pg0 ; u32 ioc_status ; u16 flags ; u32 device_info ; if ( ( mpt3sas_config_get_sas_device_pg0 ( ioc , & mpi_reply , & sas_device_pg0 , MPI2_SAS_DEVICE_PGAD_FORM_HANDLE , handle ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } flags = le16_to_cpu ( sas_device_pg0 . Flags ) ; device_info = le32_to_cpu ( sas_device_pg0 . DeviceInfo ) ; sdev_printk ( KERN_INFO , sdev , " atapi ( % s ) , ncq ( % s ) , asyn_notify ( % s ) , smart ( % s ) , fua ( % s ) , " " sw_preserve ( % s ) \ n " , ( device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE ) ? " y " : " n " , ( flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED ) ? " y " : " n " , ( flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY ) ? " y " : " n " , ( flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED ) ? " y " : " n " , ( flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED ) ? " y " : " n " , ( flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE ) ? " y " : " n " ) ; } / * * raid transport support - * Enabled for SLES11 and newer , in older kernels the driver will panic when * unloading the driver followed by a load - I believe that the subroutine * raid_class_release ( ) is not cleaning up properly . * / / * * * scsih_is_raid - return boolean indicating device is raid volume * @ dev : the device struct object * / static int scsih_is_raid ( struct device * dev ) { struct scsi_device * sdev = to_scsi_device ( dev ) ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( sdev - > host ) ; if ( ioc - > is_warpdrive ) return 0 ; return ( sdev - > channel = = RAID_CHANNEL ) ? 1 : 0 ; } static int scsih_is_nvme ( struct device * dev ) { struct scsi_device * sdev = to_scsi_device ( dev ) ; return ( sdev - > channel = = PCIE_CHANNEL ) ? 1 : 0 ; } / * * * scsih_get_resync - get raid volume resync percent complete * @ dev : the device struct object * / static void scsih_get_resync ( struct device * dev ) { struct scsi_device * sdev = to_scsi_device ( dev ) ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( sdev - > host ) ; static struct _ raid_device * raid_device ; unsigned long flags ; Mpi2RaidVolPage0_t vol_pg0 ; Mpi2ConfigReply_t mpi_reply ; u32 volume_status_flags ; u8 percent_complete ; u16 handle ; percent_complete = 0 ; handle = 0 ; if ( ioc - > is_warpdrive ) goto out ; spin_lock_irqsave ( & ioc - > raid_device_lock , flags ) ; raid_device = _ scsih_raid_device_find_by_id ( ioc , sdev - > id , sdev - > channel ) ; if ( raid_device ) { handle = raid_device - > handle ; percent_complete = raid_device - > percent_complete ; } spin_unlock_irqrestore ( & ioc - > raid_device_lock , flags ) ; if ( ! handle ) goto out ; if ( mpt3sas_config_get_raid_volume_pg0 ( ioc , & mpi_reply , & vol_pg0 , MPI2_RAID_VOLUME_PGAD_FORM_HANDLE , handle , sizeof ( Mpi2RaidVolPage0_t ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; percent_complete = 0 ; goto out ; } volume_status_flags = le32_to_cpu ( vol_pg0 . VolumeStatusFlags ) ; if ( ! ( volume_status_flags & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS ) ) percent_complete = 0 ; out : switch ( ioc - > hba_mpi_version_belonged ) { case MPI2_VERSION : raid_set_resync ( mpt2sas_raid_template , dev , percent_complete ) ; break ; case MPI25_VERSION : case MPI26_VERSION : raid_set_resync ( mpt3sas_raid_template , dev , percent_complete ) ; break ; } } / * * * scsih_get_state - get raid volume level * @ dev : the device struct object * / static void scsih_get_state ( struct device * dev ) { struct scsi_device * sdev = to_scsi_device ( dev ) ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( sdev - > host ) ; static struct _ raid_device * raid_device ; unsigned long flags ; Mpi2RaidVolPage0_t vol_pg0 ; Mpi2ConfigReply_t mpi_reply ; u32 volstate ; enum raid_state state = RAID_STATE_UNKNOWN ; u16 handle = 0 ; spin_lock_irqsave ( & ioc - > raid_device_lock , flags ) ; raid_device = _ scsih_raid_device_find_by_id ( ioc , sdev - > id , sdev - > channel ) ; if ( raid_device ) handle = raid_device - > handle ; spin_unlock_irqrestore ( & ioc - > raid_device_lock , flags ) ; if ( ! raid_device ) goto out ; if ( mpt3sas_config_get_raid_volume_pg0 ( ioc , & mpi_reply , & vol_pg0 , MPI2_RAID_VOLUME_PGAD_FORM_HANDLE , handle , sizeof ( Mpi2RaidVolPage0_t ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } volstate = le32_to_cpu ( vol_pg0 . VolumeStatusFlags ) ; if ( volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS ) { state = RAID_STATE_RESYNCING ; goto out ; } switch ( vol_pg0 . VolumeState ) { case MPI2_RAID_VOL_STATE_OPTIMAL : case MPI2_RAID_VOL_STATE_ONLINE : state = RAID_STATE_ACTIVE ; break ; case MPI2_RAID_VOL_STATE_DEGRADED : state = RAID_STATE_DEGRADED ; break ; case MPI2_RAID_VOL_STATE_FAILED : case MPI2_RAID_VOL_STATE_MISSING : state = RAID_STATE_OFFLINE ; break ; } out : switch ( ioc - > hba_mpi_version_belonged ) { case MPI2_VERSION : raid_set_state ( mpt2sas_raid_template , dev , state ) ; break ; case MPI25_VERSION : case MPI26_VERSION : raid_set_state ( mpt3sas_raid_template , dev , state ) ; break ; } } / * * * _ scsih_set_level - set raid level * @ ioc : ? * @ sdev : scsi device struct * @ volume_type : volume type * / static void _ scsih_set_level ( struct MPT3SAS_ADAPTER * ioc , struct scsi_device * sdev , u8 volume_type ) { enum raid_level level = RAID_LEVEL_UNKNOWN ; switch ( volume_type ) { case MPI2_RAID_VOL_TYPE_RAID0 : level = RAID_LEVEL_0 ; break ; case MPI2_RAID_VOL_TYPE_RAID10 : level = RAID_LEVEL_10 ; break ; case MPI2_RAID_VOL_TYPE_RAID1E : level = RAID_LEVEL_1E ; break ; case MPI2_RAID_VOL_TYPE_RAID1 : level = RAID_LEVEL_1 ; break ; } switch ( ioc - > hba_mpi_version_belonged ) { case MPI2_VERSION : raid_set_level ( mpt2sas_raid_template , & sdev - > sdev_gendev , level ) ; break ; case MPI25_VERSION : case MPI26_VERSION : raid_set_level ( mpt3sas_raid_template , & sdev - > sdev_gendev , level ) ; break ; } } / * * * _ scsih_get_volume_capabilities - volume capabilities * @ ioc : per adapter object * @ raid_device : the raid_device object * * Return : 0 for success , else 1 * / static int _ scsih_get_volume_capabilities ( struct MPT3SAS_ADAPTER * ioc , struct _ raid_device * raid_device ) { Mpi2RaidVolPage0_t * vol_pg0 ; Mpi2RaidPhysDiskPage0_t pd_pg0 ; Mpi2SasDevicePage0_t sas_device_pg0 ; Mpi2ConfigReply_t mpi_reply ; u16 sz ; u8 num_pds ; if ( ( mpt3sas_config_get_number_pds ( ioc , raid_device - > handle , & num_pds ) ) | | ! num_pds ) { dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } raid_device - > num_pds = num_pds ; sz = struct_size ( vol_pg0 , PhysDisk , num_pds ) ; vol_pg0 = kzalloc ( sz , GFP_KERNEL ) ; if ( ! vol_pg0 ) { dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } if ( ( mpt3sas_config_get_raid_volume_pg0 ( ioc , & mpi_reply , vol_pg0 , MPI2_RAID_VOLUME_PGAD_FORM_HANDLE , raid_device - > handle , sz ) ) ) { dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; kfree ( vol_pg0 ) ; return 1 ; } raid_device - > volume_type = vol_pg0 - > VolumeType ; / * figure out what the underlying devices are by * obtaining the device_info bits for the 1 st device * / if ( ! ( mpt3sas_config_get_phys_disk_pg0 ( ioc , & mpi_reply , & pd_pg0 , MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM , vol_pg0 - > PhysDisk [ 0 ] . PhysDiskNum ) ) ) { if ( ! ( mpt3sas_config_get_sas_device_pg0 ( ioc , & mpi_reply , & sas_device_pg0 , MPI2_SAS_DEVICE_PGAD_FORM_HANDLE , le16_to_cpu ( pd_pg0 . DevHandle ) ) ) ) { raid_device - > device_info = le32_to_cpu ( sas_device_pg0 . DeviceInfo ) ; } } kfree ( vol_pg0 ) ; return 0 ; } / * * * _ scsih_enable_tlr - setting TLR flags * @ ioc : per adapter object * @ sdev : scsi device struct * * Enabling Transaction Layer Retries for tape devices when * vpd page 0 x90 is present * * / static void _ scsih_enable_tlr ( struct MPT3SAS_ADAPTER * ioc , struct scsi_device * sdev ) { / * only for TAPE * / if ( sdev - > type ! = TYPE_TAPE ) return ; if ( ! ( ioc - > facts . IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR ) ) return ; sas_enable_tlr ( sdev ) ; sdev_printk ( KERN_INFO , sdev , " TLR % s \ n " , sas_is_tlr_enabled ( sdev ) ? " Enabled " : " Disabled " ) ; return ; } / * * * scsih_sdev_configure - device configure routine . * @ sdev : scsi device struct * @ lim : queue limits * * Return : 0 if ok . Any other return is assumed to be an error and * the device is ignored . * / static int scsih_sdev_configure ( struct scsi_device * sdev , struct queue_limits * lim ) { struct Scsi_Host * shost = sdev - > host ; struct MPT3SAS_ADAPTER * ioc = shost_priv ( shost ) ; struct MPT3SAS_DEVICE * sas_device_priv_data ; struct MPT3SAS_TARGET * sas_target_priv_data ; struct _ sas_device * sas_device ; struct _ pcie_device * pcie_device ; struct _ raid_device * raid_device ; unsigned long flags ; int qdepth ; u8 ssp_target = 0 ; char * ds = " " ; char * r_level = " " ; u16 handle , volume_handle = 0 ; u64 volume_wwid = 0 ; qdepth = 1 ; sas_device_priv_data = sdev - > hostdata ; sas_device_priv_data - > configured_lun = 1 ; sas_device_priv_data - > flags & = ~ MPT_DEVICE_FLAGS_INIT ; sas_target_priv_data = sas_device_priv_data - > sas_target ; handle = sas_target_priv_data - > handle ; / * raid volume handling * / if ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_VOLUME ) { spin_lock_irqsave ( & ioc - > raid_device_lock , flags ) ; raid_device = mpt3sas_raid_device_find_by_handle ( ioc , handle ) ; spin_unlock_irqrestore ( & ioc - > raid_device_lock , flags ) ; if ( ! raid_device ) { dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } if ( _ scsih_get_volume_capabilities ( ioc , raid_device ) ) { dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } / * * WARPDRIVE : Initialize the required data for Direct IO * / mpt3sas_init_warpdrive_properties ( ioc , raid_device ) ; / * RAID Queue Depth Support * IS volume = underlying qdepth of drive type , either * MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH * IM / IME / R10 = 128 ( MPT3SAS_RAID_QUEUE_DEPTH ) * / if ( raid_device - > device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET ) { qdepth = MPT3SAS_SAS_QUEUE_DEPTH ; ds = " SSP " ; } else { qdepth = MPT3SAS_SATA_QUEUE_DEPTH ; if ( raid_device - > device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE ) ds = " SATA " ; else ds = " STP " ; } switch ( raid_device - > volume_type ) { case MPI2_RAID_VOL_TYPE_RAID0 : r_level = " RAID0 " ; break ; case MPI2_RAID_VOL_TYPE_RAID1E : qdepth = MPT3SAS_RAID_QUEUE_DEPTH ; if ( ioc - > manu_pg10 . OEMIdentifier & & ( le32_to_cpu ( ioc - > manu_pg10 . GenericFlags0 ) & MFG10_GF0_R10_DISPLAY ) & & ! ( raid_device - > num_pds % 2 ) ) r_level = " RAID10 " ; else r_level = " RAID1E " ; break ; case MPI2_RAID_VOL_TYPE_RAID1 : qdepth = MPT3SAS_RAID_QUEUE_DEPTH ; r_level = " RAID1 " ; break ; case MPI2_RAID_VOL_TYPE_RAID10 : qdepth = MPT3SAS_RAID_QUEUE_DEPTH ; r_level = " RAID10 " ; break ; case MPI2_RAID_VOL_TYPE_UNKNOWN : default : qdepth = MPT3SAS_RAID_QUEUE_DEPTH ; r_level = " RAIDX " ; break ; } if ( ! ioc - > hide_ir_msg ) sdev_printk ( KERN_INFO , sdev , " % s : handle ( 0 x % 04 x ) , wwid ( 0 x % 016 llx ) , " " pd_count ( % d ) , type ( % s ) \ n " , r_level , raid_device - > handle , ( unsigned long long ) raid_device - > wwid , raid_device - > num_pds , ds ) ; if ( shost - > max_sectors > MPT3SAS_RAID_MAX_SECTORS ) { lim - > max_hw_sectors = MPT3SAS_RAID_MAX_SECTORS ; sdev_printk ( KERN_INFO , sdev , " Set queue ' s max_sector to : % u \ n " , MPT3SAS_RAID_MAX_SECTORS ) ; } mpt3sas_scsih_change_queue_depth ( sdev , qdepth ) ; / * raid transport support * / if ( ! ioc - > is_warpdrive ) _ scsih_set_level ( ioc , sdev , raid_device - > volume_type ) ; return 0 ; } / * non - raid handling * / if ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT ) { if ( mpt3sas_config_get_volume_handle ( ioc , handle , & volume_handle ) ) { dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } if ( volume_handle & & mpt3sas_config_get_volume_wwid ( ioc , volume_handle , & volume_wwid ) ) { dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } } / * PCIe handling * / if ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_PCIE_DEVICE ) { spin_lock_irqsave ( & ioc - > pcie_device_lock , flags ) ; pcie_device = _ _ mpt3sas_get_pdev_by_wwid ( ioc , sas_device_priv_data - > sas_target - > sas_address ) ; if ( ! pcie_device ) { spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } qdepth = ioc - > max_nvme_qd ; ds = " NVMe " ; sdev_printk ( KERN_INFO , sdev , " % s : handle ( 0 x % 04 x ) , wwid ( 0 x % 016 llx ) , port ( % d ) \ n " , ds , handle , ( unsigned long long ) pcie_device - > wwid , pcie_device - > port_num ) ; if ( pcie_device - > enclosure_handle ! = 0 ) sdev_printk ( KERN_INFO , sdev , " % s : enclosure logical id ( 0 x % 016 llx ) , slot ( % d ) \ n " , ds , ( unsigned long long ) pcie_device - > enclosure_logical_id , pcie_device - > slot ) ; if ( pcie_device - > connector_name [ 0 ] ! = ' \ 0 ' ) sdev_printk ( KERN_INFO , sdev , " % s : enclosure level ( 0 x % 04 x ) , " " connector name ( % s ) \ n " , ds , pcie_device - > enclosure_level , pcie_device - > connector_name ) ; if ( pcie_device - > nvme_mdts ) lim - > max_hw_sectors = pcie_device - > nvme_mdts / 512 ; pcie_device_put ( pcie_device ) ; spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; mpt3sas_scsih_change_queue_depth ( sdev , qdepth ) ; lim - > virt_boundary_mask = ioc - > page_size - 1 ; return 0 ; } spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_by_addr ( ioc , sas_device_priv_data - > sas_target - > sas_address , sas_device_priv_data - > sas_target - > port ) ; if ( ! sas_device ) { spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; dfailprintk ( ioc , ioc_warn ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ) ; return 1 ; } sas_device - > volume_handle = volume_handle ; sas_device - > volume_wwid = volume_wwid ; if ( sas_device - > device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET ) { qdepth = ( sas_device - > port_type > 1 ) ? ioc - > max_wideport_qd : ioc - > max_narrowport_qd ; ssp_target = 1 ; if ( sas_device - > device_info & MPI2_SAS_DEVICE_INFO_SEP ) { sdev_printk ( KERN_INFO , sdev , " set ignore_delay_remove for handle ( 0 x % 04 x ) \ n " , sas_device_priv_data - > sas_target - > handle ) ; sas_device_priv_data - > ignore_delay_remove = 1 ; ds = " SES " ; } else ds = " SSP " ; } else { qdepth = ioc - > max_sata_qd ; if ( sas_device - > device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET ) ds = " STP " ; else if ( sas_device - > device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE ) ds = " SATA " ; } sdev_printk ( KERN_INFO , sdev , " % s : handle ( 0 x % 04 x ) , " \ " sas_addr ( 0 x % 016 llx ) , phy ( % d ) , device_name ( 0 x % 016 llx ) \ n " , ds , handle , ( unsigned long long ) sas_device - > sas_address , sas_device - > phy , ( unsigned long long ) sas_device - > device_name ) ; _ scsih_display_enclosure_chassis_info ( NULL , sas_device , sdev , NULL ) ; sas_device_put ( sas_device ) ; spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; if ( ! ssp_target ) _ scsih_display_sata_capabilities ( ioc , handle , sdev ) ; mpt3sas_scsih_change_queue_depth ( sdev , qdepth ) ; if ( ssp_target ) { sas_read_port_mode_page ( sdev ) ; _ scsih_enable_tlr ( ioc , sdev ) ; } return 0 ; } / * * * scsih_bios_param - fetch head , sector , cylinder info for a disk * @ sdev : scsi device struct * @ bdev : pointer to block device context * @ capacity : device size ( in 512 byte sectors ) * @ params : three element array to place output : * params [ 0 ] number of heads ( max 255 ) * params [ 1 ] number of sectors ( max 63 ) * params [ 2 ] number of cylinders * / static int scsih_bios_param ( struct scsi_device * sdev , struct block_device * bdev , sector_t capacity , int params [ ] ) { int heads ; int sectors ; sector_t cylinders ; ulong dummy ; heads = 64 ; sectors = 32 ; dummy = heads * sectors ; cylinders = capacity ; sector_div ( cylinders , dummy ) ; / * * Handle extended translation size for logical drives * > 1 Gb * / if ( ( ulong ) capacity > = 0 x200000 ) { heads = 255 ; sectors = 63 ; dummy = heads * sectors ; cylinders = capacity ; sector_div ( cylinders , dummy ) ; } / * return result * / params [ 0 ] = heads ; params [ 1 ] = sectors ; params [ 2 ] = cylinders ; return 0 ; } / * * * _ scsih_response_code - translation of device response code * @ ioc : per adapter object * @ response_code : response code returned by the device * / static void _ scsih_response_code ( struct MPT3SAS_ADAPTER * ioc , u8 response_code ) { char * desc ; switch ( response_code ) { case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE : desc = " task management request completed " ; break ; case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME : desc = " invalid frame " ; break ; case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED : desc = " task management request not supported " ; break ; case MPI2_SCSITASKMGMT_RSP_TM_FAILED : desc = " task management request failed " ; break ; case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED : desc = " task management request succeeded " ; break ; case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN : desc = " invalid lun " ; break ; case 0 xA : desc = " overlapped tag attempted " ; break ; case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC : desc = " task queued , however not sent to target " ; break ; default : desc = " unknown " ; break ; } ioc_warn ( ioc , " response_code ( 0 x % 01 x ) : % s \ n " , response_code , desc ) ; } / * * * _ scsih_tm_done - tm completion routine * @ ioc : per adapter object * @ smid : system request message index * @ msix_index : MSIX table index supplied by the OS * @ reply : reply message frame ( lower 32 bit addr ) * Context : none . * * The callback handler when using scsih_issue_tm . * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / static u8 _ scsih_tm_done ( struct MPT3SAS_ADAPTER * ioc , u16 smid , u8 msix_index , u32 reply ) { MPI2DefaultReply_t * mpi_reply ; if ( ioc - > tm_cmds . status = = MPT3_CMD_NOT_USED ) return 1 ; if ( ioc - > tm_cmds . smid ! = smid ) return 1 ; ioc - > tm_cmds . status | = MPT3_CMD_COMPLETE ; mpi_reply = mpt3sas_base_get_reply_virt_addr ( ioc , reply ) ; if ( mpi_reply ) { memcpy ( ioc - > tm_cmds . reply , mpi_reply , mpi_reply - > MsgLength * 4 ) ; ioc - > tm_cmds . status | = MPT3_CMD_REPLY_VALID ; } ioc - > tm_cmds . status & = ~ MPT3_CMD_PENDING ; complete ( & ioc - > tm_cmds . done ) ; return 1 ; } / * * * mpt3sas_scsih_set_tm_flag - set per target tm_busy * @ ioc : per adapter object * @ handle : device handle * * During taskmangement request , we need to freeze the device queue . * / void mpt3sas_scsih_set_tm_flag ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsi_device * sdev ; u8 skip = 0 ; shost_for_each_device ( sdev , ioc - > shost ) { if ( skip ) continue ; sas_device_priv_data = sdev - > hostdata ; if ( ! sas_device_priv_data ) continue ; if ( sas_device_priv_data - > sas_target - > handle = = handle ) { sas_device_priv_data - > sas_target - > tm_busy = 1 ; skip = 1 ; ioc - > ignore_loginfos = 1 ; } } } / * * * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy * @ ioc : per adapter object * @ handle : device handle * * During taskmangement request , we need to freeze the device queue . * / void mpt3sas_scsih_clear_tm_flag ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsi_device * sdev ; u8 skip = 0 ; shost_for_each_device ( sdev , ioc - > shost ) { if ( skip ) continue ; sas_device_priv_data = sdev - > hostdata ; if ( ! sas_device_priv_data ) continue ; if ( sas_device_priv_data - > sas_target - > handle = = handle ) { sas_device_priv_data - > sas_target - > tm_busy = 0 ; skip = 1 ; ioc - > ignore_loginfos = 0 ; } } } / * * * scsih_tm_cmd_map_status - map the target reset & LUN reset TM status * @ ioc : per adapter object * @ channel : the channel assigned by the OS * @ id : the id assigned by the OS * @ lun : lun number * @ type : MPI2_SCSITASKMGMT_TASKTYPE__XXX ( defined in mpi2_init . h ) * @ smid_task : smid assigned to the task * * Look whether TM has aborted the timed out SCSI command , if * TM has aborted the IO then return SUCCESS else return FAILED . * / static int scsih_tm_cmd_map_status ( struct MPT3SAS_ADAPTER * ioc , uint channel , uint id , uint lun , u8 type , u16 smid_task ) { if ( smid_task < = ioc - > shost - > can_queue ) { switch ( type ) { case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET : if ( ! ( _ scsih_scsi_lookup_find_by_target ( ioc , id , channel ) ) ) return SUCCESS ; break ; case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET : case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET : if ( ! ( _ scsih_scsi_lookup_find_by_lun ( ioc , id , lun , channel ) ) ) return SUCCESS ; break ; default : return SUCCESS ; } } else if ( smid_task = = ioc - > scsih_cmds . smid ) { if ( ( ioc - > scsih_cmds . status & MPT3_CMD_COMPLETE ) | | ( ioc - > scsih_cmds . status & MPT3_CMD_NOT_USED ) ) return SUCCESS ; } else if ( smid_task = = ioc - > ctl_cmds . smid ) { if ( ( ioc - > ctl_cmds . status & MPT3_CMD_COMPLETE ) | | ( ioc - > ctl_cmds . status & MPT3_CMD_NOT_USED ) ) return SUCCESS ; } return FAILED ; } / * * * scsih_tm_post_processing - post processing of target & LUN reset * @ ioc : per adapter object * @ handle : device handle * @ channel : the channel assigned by the OS * @ id : the id assigned by the OS * @ lun : lun number * @ type : MPI2_SCSITASKMGMT_TASKTYPE__XXX ( defined in mpi2_init . h ) * @ smid_task : smid assigned to the task * * Post processing of target & LUN reset . Due to interrupt latency * issue it possible that interrupt for aborted IO might not be * received yet . So before returning failure status , poll the * reply descriptor pools for the reply of timed out SCSI command . * Return FAILED status if reply for timed out is not received * otherwise return SUCCESS . * / static int scsih_tm_post_processing ( struct MPT3SAS_ADAPTER * ioc , u16 handle , uint channel , uint id , uint lun , u8 type , u16 smid_task ) { int rc ; rc = scsih_tm_cmd_map_status ( ioc , channel , id , lun , type , smid_task ) ; if ( rc = = SUCCESS ) return rc ; ioc_info ( ioc , " Poll ReplyDescriptor queues for completion of " " smid ( % d ) , task_type ( 0 x % 02 x ) , handle ( 0 x % 04 x ) \ n " , smid_task , type , handle ) ; / * * Due to interrupt latency issues , driver may receive interrupt for * TM first and then for aborted SCSI IO command . So , poll all the * ReplyDescriptor pools before returning the FAILED status to SML . * / mpt3sas_base_mask_interrupts ( ioc ) ; mpt3sas_base_sync_reply_irqs ( ioc , 1 ) ; mpt3sas_base_unmask_interrupts ( ioc ) ; return scsih_tm_cmd_map_status ( ioc , channel , id , lun , type , smid_task ) ; } / * * * mpt3sas_scsih_issue_tm - main routine for sending tm requests * @ ioc : per adapter struct * @ handle : device handle * @ channel : the channel assigned by the OS * @ id : the id assigned by the OS * @ lun : lun number * @ type : MPI2_SCSITASKMGMT_TASKTYPE__XXX ( defined in mpi2_init . h ) * @ smid_task : smid assigned to the task * @ msix_task : MSIX table index supplied by the OS * @ timeout : timeout in seconds * @ tr_method : Target Reset Method * Context : user * * A generic API for sending task management requests to firmware . * * The callback index is set inside ` ioc - > tm_cb_idx ` . * The caller is responsible to check for outstanding commands . * * Return : SUCCESS or FAILED . * / int mpt3sas_scsih_issue_tm ( struct MPT3SAS_ADAPTER * ioc , u16 handle , uint channel , uint id , u64 lun , u8 type , u16 smid_task , u16 msix_task , u8 timeout , u8 tr_method ) { Mpi2SCSITaskManagementRequest_t * mpi_request ; Mpi2SCSITaskManagementReply_t * mpi_reply ; Mpi25SCSIIORequest_t * request ; u16 smid = 0 ; u32 ioc_state ; int rc ; u8 issue_reset = 0 ; lockdep_assert_held ( & ioc - > tm_cmds . mutex ) ; if ( ioc - > tm_cmds . status ! = MPT3_CMD_NOT_USED ) { ioc_info ( ioc , " % s : tm_cmd busy ! ! ! \ n " , _ _ func__ ) ; return FAILED ; } if ( ioc - > shost_recovery | | ioc - > remove_host | | ioc - > pci_error_recovery ) { ioc_info ( ioc , " % s : host reset in progress ! \ n " , _ _ func__ ) ; return FAILED ; } ioc_state = mpt3sas_base_get_iocstate ( ioc , 0 ) ; if ( ioc_state & MPI2_DOORBELL_USED ) { dhsprintk ( ioc , ioc_info ( ioc , " unexpected doorbell active ! \ n " ) ) ; rc = mpt3sas_base_hard_reset_handler ( ioc , FORCE_BIG_HAMMER ) ; return ( ! rc ) ? SUCCESS : FAILED ; } if ( ( ioc_state & MPI2_IOC_STATE_MASK ) = = MPI2_IOC_STATE_FAULT ) { mpt3sas_print_fault_code ( ioc , ioc_state & MPI2_DOORBELL_DATA_MASK ) ; rc = mpt3sas_base_hard_reset_handler ( ioc , FORCE_BIG_HAMMER ) ; return ( ! rc ) ? SUCCESS : FAILED ; } else if ( ( ioc_state & MPI2_IOC_STATE_MASK ) = = MPI2_IOC_STATE_COREDUMP ) { mpt3sas_print_coredump_info ( ioc , ioc_state & MPI2_DOORBELL_DATA_MASK ) ; rc = mpt3sas_base_hard_reset_handler ( ioc , FORCE_BIG_HAMMER ) ; return ( ! rc ) ? SUCCESS : FAILED ; } smid = mpt3sas_base_get_smid_hpr ( ioc , ioc - > tm_cb_idx ) ; if ( ! smid ) { ioc_err ( ioc , " % s : failed obtaining a smid \ n " , _ _ func__ ) ; return FAILED ; } dtmprintk ( ioc , ioc_info ( ioc , " sending tm : handle ( 0 x % 04 x ) , task_type ( 0 x % 02 x ) , smid ( % d ) , timeout ( % d ) , tr_method ( 0 x % x ) \ n " , handle , type , smid_task , timeout , tr_method ) ) ; ioc - > tm_cmds . status = MPT3_CMD_PENDING ; mpi_request = mpt3sas_base_get_msg_frame ( ioc , smid ) ; ioc - > tm_cmds . smid = smid ; memset ( mpi_request , 0 , sizeof ( Mpi2SCSITaskManagementRequest_t ) ) ; memset ( ioc - > tm_cmds . reply , 0 , sizeof ( Mpi2SCSITaskManagementReply_t ) ) ; mpi_request - > Function = MPI2_FUNCTION_SCSI_TASK_MGMT ; mpi_request - > DevHandle = cpu_to_le16 ( handle ) ; mpi_request - > TaskType = type ; if ( type = = MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK | | type = = MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK ) mpi_request - > MsgFlags = tr_method ; mpi_request - > TaskMID = cpu_to_le16 ( smid_task ) ; int_to_scsilun ( lun , ( struct scsi_lun * ) mpi_request - > LUN ) ; mpt3sas_scsih_set_tm_flag ( ioc , handle ) ; init_completion ( & ioc - > tm_cmds . done ) ; ioc - > put_smid_hi_priority ( ioc , smid , msix_task ) ; wait_for_completion_timeout ( & ioc - > tm_cmds . done , timeout * HZ ) ; if ( ! ( ioc - > tm_cmds . status & MPT3_CMD_COMPLETE ) ) { mpt3sas_check_cmd_timeout ( ioc , ioc - > tm_cmds . status , mpi_request , sizeof ( Mpi2SCSITaskManagementRequest_t ) / 4 , issue_reset ) ; if ( issue_reset ) { rc = mpt3sas_base_hard_reset_handler ( ioc , FORCE_BIG_HAMMER ) ; rc = ( ! rc ) ? SUCCESS : FAILED ; goto out ; } } / * sync IRQs in case those were busy during flush . * / mpt3sas_base_sync_reply_irqs ( ioc , 0 ) ; if ( ioc - > tm_cmds . status & MPT3_CMD_REPLY_VALID ) { mpt3sas_trigger_master ( ioc , MASTER_TRIGGER_TASK_MANAGMENT ) ; mpi_reply = ioc - > tm_cmds . reply ; dtmprintk ( ioc , ioc_info ( ioc , " complete tm : ioc_status ( 0 x % 04 x ) , loginfo ( 0 x % 08 x ) , term_count ( 0 x % 08 x ) \ n " , le16_to_cpu ( mpi_reply - > IOCStatus ) , le32_to_cpu ( mpi_reply - > IOCLogInfo ) , le32_to_cpu ( mpi_reply - > TerminationCount ) ) ) ; if ( ioc - > logging_level & MPT_DEBUG_TM ) { _ scsih_response_code ( ioc , mpi_reply - > ResponseCode ) ; if ( mpi_reply - > IOCStatus ) _ debug_dump_mf ( mpi_request , sizeof ( Mpi2SCSITaskManagementRequest_t ) / 4 ) ; } } switch ( type ) { case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK : rc = SUCCESS ; / * * If DevHandle filed in smid_task ' s entry of request pool * doesn ' t match with device handle on which this task abort * TM is received then it means that TM has successfully * aborted the timed out command . Since smid_task ' s entry in * request pool will be memset to zero once the timed out * command is returned to the SML . If the command is not * aborted then smid_task ’ s entry won ’ t be cleared and it * will have same DevHandle value on which this task abort TM * is received and driver will return the TM status as FAILED . * / request = mpt3sas_base_get_msg_frame ( ioc , smid_task ) ; if ( le16_to_cpu ( request - > DevHandle ) ! = handle ) break ; ioc_info ( ioc , " Task abort tm failed : handle ( 0 x % 04 x ) , " " timeout ( % d ) tr_method ( 0 x % x ) smid ( % d ) msix_index ( % d ) \ n " , handle , timeout , tr_method , smid_task , msix_task ) ; rc = FAILED ; break ; case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET : case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET : case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET : rc = scsih_tm_post_processing ( ioc , handle , channel , id , lun , type , smid_task ) ; break ; case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK : rc = SUCCESS ; break ; default : rc = FAILED ; break ; } out : mpt3sas_scsih_clear_tm_flag ( ioc , handle ) ; ioc - > tm_cmds . status = MPT3_CMD_NOT_USED ; return rc ; } int mpt3sas_scsih_issue_locked_tm ( struct MPT3SAS_ADAPTER * ioc , u16 handle , uint channel , uint id , u64 lun , u8 type , u16 smid_task , u16 msix_task , u8 timeout , u8 tr_method ) { int ret ; mutex_lock ( & ioc - > tm_cmds . mutex ) ; ret = mpt3sas_scsih_issue_tm ( ioc , handle , channel , id , lun , type , smid_task , msix_task , timeout , tr_method ) ; mutex_unlock ( & ioc - > tm_cmds . mutex ) ; return ret ; } / * * * _ scsih_tm_display_info - displays info about the device * @ ioc : per adapter struct * @ scmd : pointer to scsi command object * * Called by task management callback handlers . * / static void _ scsih_tm_display_info ( struct MPT3SAS_ADAPTER * ioc , struct scsi_cmnd * scmd ) { struct scsi_target * starget = scmd - > device - > sdev_target ; struct MPT3SAS_TARGET * priv_target = starget - > hostdata ; struct _ sas_device * sas_device = NULL ; struct _ pcie_device * pcie_device = NULL ; unsigned long flags ; char * device_str = NULL ; if ( ! priv_target ) return ; if ( ioc - > hide_ir_msg ) device_str = " WarpDrive " ; else device_str = " volume " ; scsi_print_command ( scmd ) ; if ( priv_target - > flags & MPT_TARGET_FLAGS_VOLUME ) { starget_printk ( KERN_INFO , starget , " % s handle ( 0 x % 04 x ) , % s wwid ( 0 x % 016 llx ) \ n " , device_str , priv_target - > handle , device_str , ( unsigned long long ) priv_target - > sas_address ) ; } else if ( priv_target - > flags & MPT_TARGET_FLAGS_PCIE_DEVICE ) { spin_lock_irqsave ( & ioc - > pcie_device_lock , flags ) ; pcie_device = _ _ mpt3sas_get_pdev_from_target ( ioc , priv_target ) ; if ( pcie_device ) { starget_printk ( KERN_INFO , starget , " handle ( 0 x % 04 x ) , wwid ( 0 x % 016 llx ) , port ( % d ) \ n " , pcie_device - > handle , ( unsigned long long ) pcie_device - > wwid , pcie_device - > port_num ) ; if ( pcie_device - > enclosure_handle ! = 0 ) starget_printk ( KERN_INFO , starget , " enclosure logical id ( 0 x % 016 llx ) , slot ( % d ) \ n " , ( unsigned long long ) pcie_device - > enclosure_logical_id , pcie_device - > slot ) ; if ( pcie_device - > connector_name [ 0 ] ! = ' \ 0 ' ) starget_printk ( KERN_INFO , starget , " enclosure level ( 0 x % 04 x ) , connector name ( % s ) \ n " , pcie_device - > enclosure_level , pcie_device - > connector_name ) ; pcie_device_put ( pcie_device ) ; } spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; } else { spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_from_target ( ioc , priv_target ) ; if ( sas_device ) { if ( priv_target - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT ) { starget_printk ( KERN_INFO , starget , " volume handle ( 0 x % 04 x ) , " " volume wwid ( 0 x % 016 llx ) \ n " , sas_device - > volume_handle , ( unsigned long long ) sas_device - > volume_wwid ) ; } starget_printk ( KERN_INFO , starget , " handle ( 0 x % 04 x ) , sas_address ( 0 x % 016 llx ) , phy ( % d ) \ n " , sas_device - > handle , ( unsigned long long ) sas_device - > sas_address , sas_device - > phy ) ; _ scsih_display_enclosure_chassis_info ( NULL , sas_device , NULL , starget ) ; sas_device_put ( sas_device ) ; } spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; } } / * * * scsih_abort - eh threads main abort routine * @ scmd : pointer to scsi command object * * Return : SUCCESS if command aborted else FAILED * / static int scsih_abort ( struct scsi_cmnd * scmd ) { struct MPT3SAS_ADAPTER * ioc = shost_priv ( scmd - > device - > host ) ; struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsiio_tracker * st = scsi_cmd_priv ( scmd ) ; u16 handle ; int r ; u8 timeout = 30 ; struct _ pcie_device * pcie_device = NULL ; sdev_printk ( KERN_INFO , scmd - > device , " attempting task abort ! " " scmd ( 0 x % p ) , outstanding for % u ms & timeout % u ms \ n " , scmd , jiffies_to_msecs ( jiffies - scmd - > jiffies_at_alloc ) , ( scsi_cmd_to_rq ( scmd ) - > timeout / HZ ) * 1000 ) ; _ scsih_tm_display_info ( ioc , scmd ) ; sas_device_priv_data = scmd - > device - > hostdata ; if ( ! sas_device_priv_data | | ! sas_device_priv_data - > sas_target | | ioc - > remove_host ) { sdev_printk ( KERN_INFO , scmd - > device , " device been deleted ! scmd ( 0 x % p ) \ n " , scmd ) ; scmd - > result = DID_NO_CONNECT < < 16 ; scsi_done ( scmd ) ; r = SUCCESS ; goto out ; } / * check for completed command * / if ( st = = NULL | | st - > cb_idx = = 0 xFF ) { sdev_printk ( KERN_INFO , scmd - > device , " No reference found at " " driver , assuming scmd ( 0 x % p ) might have completed \ n " , scmd ) ; scmd - > result = DID_RESET < < 16 ; r = SUCCESS ; goto out ; } / * for hidden raid components and volumes this is not supported * / if ( sas_device_priv_data - > sas_target - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT | | sas_device_priv_data - > sas_target - > flags & MPT_TARGET_FLAGS_VOLUME ) { scmd - > result = DID_RESET < < 16 ; r = FAILED ; goto out ; } mpt3sas_halt_firmware ( ioc ) ; handle = sas_device_priv_data - > sas_target - > handle ; pcie_device = mpt3sas_get_pdev_by_handle ( ioc , handle ) ; if ( pcie_device & & ( ! ioc - > tm_custom_handling ) & & ( ! ( mpt3sas_scsih_is_pcie_scsi_device ( pcie_device - > device_info ) ) ) ) timeout = ioc - > nvme_abort_timeout ; r = mpt3sas_scsih_issue_locked_tm ( ioc , handle , scmd - > device - > channel , scmd - > device - > id , scmd - > device - > lun , MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK , st - > smid , st - > msix_io , timeout , 0 ) ; / * Command must be cleared after abort * / if ( r = = SUCCESS & & st - > cb_idx ! = 0 xFF ) r = FAILED ; out : sdev_printk ( KERN_INFO , scmd - > device , " task abort : % s scmd ( 0 x % p ) \ n " , ( ( r = = SUCCESS ) ? " SUCCESS " : " FAILED " ) , scmd ) ; if ( pcie_device ) pcie_device_put ( pcie_device ) ; return r ; } / * * * scsih_dev_reset - eh threads main device reset routine * @ scmd : pointer to scsi command object * * Return : SUCCESS if command aborted else FAILED * / static int scsih_dev_reset ( struct scsi_cmnd * scmd ) { struct MPT3SAS_ADAPTER * ioc = shost_priv ( scmd - > device - > host ) ; struct MPT3SAS_DEVICE * sas_device_priv_data ; struct _ sas_device * sas_device = NULL ; struct _ pcie_device * pcie_device = NULL ; u16 handle ; u8 tr_method = 0 ; u8 tr_timeout = 30 ; int r ; struct scsi_target * starget = scmd - > device - > sdev_target ; struct MPT3SAS_TARGET * target_priv_data = starget - > hostdata ; sdev_printk ( KERN_INFO , scmd - > device , " attempting device reset ! scmd ( 0 x % p ) \ n " , scmd ) ; _ scsih_tm_display_info ( ioc , scmd ) ; sas_device_priv_data = scmd - > device - > hostdata ; if ( ! sas_device_priv_data | | ! sas_device_priv_data - > sas_target | | ioc - > remove_host ) { sdev_printk ( KERN_INFO , scmd - > device , " device been deleted ! scmd ( 0 x % p ) \ n " , scmd ) ; scmd - > result = DID_NO_CONNECT < < 16 ; scsi_done ( scmd ) ; r = SUCCESS ; goto out ; } / * for hidden raid components obtain the volume_handle * / handle = 0 ; if ( sas_device_priv_data - > sas_target - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT ) { sas_device = mpt3sas_get_sdev_from_target ( ioc , target_priv_data ) ; if ( sas_device ) handle = sas_device - > volume_handle ; } else handle = sas_device_priv_data - > sas_target - > handle ; if ( ! handle ) { scmd - > result = DID_RESET < < 16 ; r = FAILED ; goto out ; } pcie_device = mpt3sas_get_pdev_by_handle ( ioc , handle ) ; if ( pcie_device & & ( ! ioc - > tm_custom_handling ) & & ( ! ( mpt3sas_scsih_is_pcie_scsi_device ( pcie_device - > device_info ) ) ) ) { tr_timeout = pcie_device - > reset_timeout ; tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE ; } else tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET ; r = mpt3sas_scsih_issue_locked_tm ( ioc , handle , scmd - > device - > channel , scmd - > device - > id , scmd - > device - > lun , MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET , 0 , 0 , tr_timeout , tr_method ) ; / * Check for busy commands after reset * / if ( r = = SUCCESS & & scsi_device_busy ( scmd - > device ) ) r = FAILED ; out : sdev_printk ( KERN_INFO , scmd - > device , " device reset : % s scmd ( 0 x % p ) \ n " , ( ( r = = SUCCESS ) ? " SUCCESS " : " FAILED " ) , scmd ) ; if ( sas_device ) sas_device_put ( sas_device ) ; if ( pcie_device ) pcie_device_put ( pcie_device ) ; return r ; } / * * * scsih_target_reset - eh threads main target reset routine * @ scmd : pointer to scsi command object * * Return : SUCCESS if command aborted else FAILED * / static int scsih_target_reset ( struct scsi_cmnd * scmd ) { struct MPT3SAS_ADAPTER * ioc = shost_priv ( scmd - > device - > host ) ; struct MPT3SAS_DEVICE * sas_device_priv_data ; struct _ sas_device * sas_device = NULL ; struct _ pcie_device * pcie_device = NULL ; u16 handle ; u8 tr_method = 0 ; u8 tr_timeout = 30 ; int r ; struct scsi_target * starget = scmd - > device - > sdev_target ; struct MPT3SAS_TARGET * target_priv_data = starget - > hostdata ; starget_printk ( KERN_INFO , starget , " attempting target reset ! scmd ( 0 x % p ) \ n " , scmd ) ; _ scsih_tm_display_info ( ioc , scmd ) ; sas_device_priv_data = scmd - > device - > hostdata ; if ( ! sas_device_priv_data | | ! sas_device_priv_data - > sas_target | | ioc - > remove_host ) { starget_printk ( KERN_INFO , starget , " target been deleted ! scmd ( 0 x % p ) \ n " , scmd ) ; scmd - > result = DID_NO_CONNECT < < 16 ; scsi_done ( scmd ) ; r = SUCCESS ; goto out ; } / * for hidden raid components obtain the volume_handle * / handle = 0 ; if ( sas_device_priv_data - > sas_target - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT ) { sas_device = mpt3sas_get_sdev_from_target ( ioc , target_priv_data ) ; if ( sas_device ) handle = sas_device - > volume_handle ; } else handle = sas_device_priv_data - > sas_target - > handle ; if ( ! handle ) { scmd - > result = DID_RESET < < 16 ; r = FAILED ; goto out ; } pcie_device = mpt3sas_get_pdev_by_handle ( ioc , handle ) ; if ( pcie_device & & ( ! ioc - > tm_custom_handling ) & & ( ! ( mpt3sas_scsih_is_pcie_scsi_device ( pcie_device - > device_info ) ) ) ) { tr_timeout = pcie_device - > reset_timeout ; tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE ; } else tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET ; r = mpt3sas_scsih_issue_locked_tm ( ioc , handle , scmd - > device - > channel , scmd - > device - > id , 0 , MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET , 0 , 0 , tr_timeout , tr_method ) ; / * Check for busy commands after reset * / if ( r = = SUCCESS & & atomic_read ( & starget - > target_busy ) ) r = FAILED ; out : starget_printk ( KERN_INFO , starget , " target reset : % s scmd ( 0 x % p ) \ n " , ( ( r = = SUCCESS ) ? " SUCCESS " : " FAILED " ) , scmd ) ; if ( sas_device ) sas_device_put ( sas_device ) ; if ( pcie_device ) pcie_device_put ( pcie_device ) ; return r ; } / * * * scsih_host_reset - eh threads main host reset routine * @ scmd : pointer to scsi command object * * Return : SUCCESS if command aborted else FAILED * / static int scsih_host_reset ( struct scsi_cmnd * scmd ) { struct MPT3SAS_ADAPTER * ioc = shost_priv ( scmd - > device - > host ) ; int r , retval ; ioc_info ( ioc , " attempting host reset ! scmd ( 0 x % p ) \ n " , scmd ) ; scsi_print_command ( scmd ) ; if ( ioc - > is_driver_loading | | ioc - > remove_host ) { ioc_info ( ioc , " Blocking the host reset \ n " ) ; r = FAILED ; goto out ; } retval = mpt3sas_base_hard_reset_handler ( ioc , FORCE_BIG_HAMMER ) ; r = ( retval < 0 ) ? FAILED : SUCCESS ; out : ioc_info ( ioc , " host reset : % s scmd ( 0 x % p ) \ n " , r = = SUCCESS ? " SUCCESS " : " FAILED " , scmd ) ; return r ; } / * * * _ scsih_fw_event_add - insert and queue up fw_event * @ ioc : per adapter object * @ fw_event : object describing the event * Context : This function will acquire ioc - > fw_event_lock . * * This adds the firmware event object into link list , then queues it up to * be processed from user context . * / static void _ scsih_fw_event_add ( struct MPT3SAS_ADAPTER * ioc , struct fw_event_work * fw_event ) { unsigned long flags ; if ( ioc - > firmware_event_thread = = NULL ) return ; spin_lock_irqsave ( & ioc - > fw_event_lock , flags ) ; fw_event_work_get ( fw_event ) ; INIT_LIST_HEAD ( & fw_event - > list ) ; list_add_tail ( & fw_event - > list , & ioc - > fw_event_list ) ; INIT_WORK ( & fw_event - > work , _ firmware_event_work ) ; fw_event_work_get ( fw_event ) ; queue_work ( ioc - > firmware_event_thread , & fw_event - > work ) ; spin_unlock_irqrestore ( & ioc - > fw_event_lock , flags ) ; } / * * * _ scsih_fw_event_del_from_list - delete fw_event from the list * @ ioc : per adapter object * @ fw_event : object describing the event * Context : This function will acquire ioc - > fw_event_lock . * * If the fw_event is on the fw_event_list , remove it and do a put . * / static void _ scsih_fw_event_del_from_list ( struct MPT3SAS_ADAPTER * ioc , struct fw_event_work * fw_event ) { unsigned long flags ; spin_lock_irqsave ( & ioc - > fw_event_lock , flags ) ; if ( ! list_empty ( & fw_event - > list ) ) { list_del_init ( & fw_event - > list ) ; fw_event_work_put ( fw_event ) ; } spin_unlock_irqrestore ( & ioc - > fw_event_lock , flags ) ; } / * * * mpt3sas_send_trigger_data_event - send event for processing trigger data * @ ioc : per adapter object * @ event_data : trigger event data * / void mpt3sas_send_trigger_data_event ( struct MPT3SAS_ADAPTER * ioc , struct SL_WH_TRIGGERS_EVENT_DATA_T * event_data ) { struct fw_event_work * fw_event ; u16 sz ; if ( ioc - > is_driver_loading ) return ; sz = sizeof ( * event_data ) ; fw_event = alloc_fw_event_work ( sz ) ; if ( ! fw_event ) return ; fw_event - > event = MPT3SAS_PROCESS_TRIGGER_DIAG ; fw_event - > ioc = ioc ; memcpy ( fw_event - > event_data , event_data , sizeof ( * event_data ) ) ; _ scsih_fw_event_add ( ioc , fw_event ) ; fw_event_work_put ( fw_event ) ; } / * * * _ scsih_error_recovery_delete_devices - remove devices not responding * @ ioc : per adapter object * / static void _ scsih_error_recovery_delete_devices ( struct MPT3SAS_ADAPTER * ioc ) { struct fw_event_work * fw_event ; fw_event = alloc_fw_event_work ( 0 ) ; if ( ! fw_event ) return ; fw_event - > event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES ; fw_event - > ioc = ioc ; _ scsih_fw_event_add ( ioc , fw_event ) ; fw_event_work_put ( fw_event ) ; } / * * * mpt3sas_port_enable_complete - port enable completed ( fake event ) * @ ioc : per adapter object * / void mpt3sas_port_enable_complete ( struct MPT3SAS_ADAPTER * ioc ) { struct fw_event_work * fw_event ; fw_event = alloc_fw_event_work ( 0 ) ; if ( ! fw_event ) return ; fw_event - > event = MPT3SAS_PORT_ENABLE_COMPLETE ; fw_event - > ioc = ioc ; _ scsih_fw_event_add ( ioc , fw_event ) ; fw_event_work_put ( fw_event ) ; } static struct fw_event_work * dequeue_next_fw_event ( struct MPT3SAS_ADAPTER * ioc ) { unsigned long flags ; struct fw_event_work * fw_event = NULL ; spin_lock_irqsave ( & ioc - > fw_event_lock , flags ) ; if ( ! list_empty ( & ioc - > fw_event_list ) ) { fw_event = list_first_entry ( & ioc - > fw_event_list , struct fw_event_work , list ) ; list_del_init ( & fw_event - > list ) ; fw_event_work_put ( fw_event ) ; } spin_unlock_irqrestore ( & ioc - > fw_event_lock , flags ) ; return fw_event ; } / * * * _ scsih_fw_event_cleanup_queue - cleanup event queue * @ ioc : per adapter object * * Walk the firmware event queue , either killing timers , or waiting * for outstanding events to complete * * Context : task , can sleep * / static void _ scsih_fw_event_cleanup_queue ( struct MPT3SAS_ADAPTER * ioc ) { struct fw_event_work * fw_event ; if ( ( list_empty ( & ioc - > fw_event_list ) & & ! ioc - > current_event ) | | ! ioc - > firmware_event_thread ) return ; / * * Set current running event as ignore , so that * current running event will exit quickly . * As diag reset has occurred it is of no use * to process remaining stale event data entries . * / if ( ioc - > shost_recovery & & ioc - > current_event ) ioc - > current_event - > ignore = 1 ; ioc - > fw_events_cleanup = 1 ; while ( ( fw_event = dequeue_next_fw_event ( ioc ) ) | | ( fw_event = ioc - > current_event ) ) { / * * Don ' t call cancel_work_sync ( ) for current_event * other than MPT3SAS_REMOVE_UNRESPONDING_DEVICES ; * otherwise we may observe deadlock if current * hard reset issued as part of processing the current_event . * * Orginal logic of cleaning the current_event is added * for handling the back to back host reset issued by the user . * i . e . during back to back host reset , driver use to process * the two instances of MPT3SAS_REMOVE_UNRESPONDING_DEVICES * event back to back and this made the drives to unregister * the devices from SML . * / if ( fw_event = = ioc - > current_event & & ioc - > current_event - > event ! = MPT3SAS_REMOVE_UNRESPONDING_DEVICES ) { ioc - > current_event = NULL ; continue ; } / * * Driver has to clear ioc - > start_scan flag when * it is cleaning up MPT3SAS_PORT_ENABLE_COMPLETE , * otherwise scsi_scan_host ( ) API waits for the * 5 minute timer to expire . If we exit from * scsi_scan_host ( ) early then we can issue the * new port enable request as part of current diag reset . * / if ( fw_event - > event = = MPT3SAS_PORT_ENABLE_COMPLETE ) { ioc - > port_enable_cmds . status | = MPT3_CMD_RESET ; ioc - > start_scan = 0 ; } / * * Wait on the fw_event to complete . If this returns 1 , then * the event was never executed , and we need a put for the * reference the work had on the fw_event . * * If it did execute , we wait for it to finish , and the put will * happen from _ firmware_event_work ( ) * / if ( cancel_work_sync ( & fw_event - > work ) ) fw_event_work_put ( fw_event ) ; } ioc - > fw_events_cleanup = 0 ; } / * * * _ scsih_internal_device_block - block the sdev device * @ sdev : per device object * @ sas_device_priv_data : per device driver private data * * make sure device is blocked without error , if not * print an error * / static void _ scsih_internal_device_block ( struct scsi_device * sdev , struct MPT3SAS_DEVICE * sas_device_priv_data ) { int r = 0 ; sdev_printk ( KERN_INFO , sdev , " device_block , handle ( 0 x % 04 x ) \ n " , sas_device_priv_data - > sas_target - > handle ) ; sas_device_priv_data - > block = 1 ; r = scsi_internal_device_block_nowait ( sdev ) ; if ( r = = - EINVAL ) sdev_printk ( KERN_WARNING , sdev , " device_block failed with return ( % d ) for handle ( 0 x % 04 x ) \ n " , r , sas_device_priv_data - > sas_target - > handle ) ; } / * * * _ scsih_internal_device_unblock - unblock the sdev device * @ sdev : per device object * @ sas_device_priv_data : per device driver private data * make sure device is unblocked without error , if not retry * by blocking and then unblocking * / static void _ scsih_internal_device_unblock ( struct scsi_device * sdev , struct MPT3SAS_DEVICE * sas_device_priv_data ) { int r = 0 ; sdev_printk ( KERN_WARNING , sdev , " device_unblock and setting to running , " " handle ( 0 x % 04 x ) \ n " , sas_device_priv_data - > sas_target - > handle ) ; sas_device_priv_data - > block = 0 ; r = scsi_internal_device_unblock_nowait ( sdev , SDEV_RUNNING ) ; if ( r = = - EINVAL ) { / * The device has been set to SDEV_RUNNING by SD layer during * device addition but the request queue is still stopped by * our earlier block call . We need to perform a block again * to get the device to SDEV_BLOCK and then to SDEV_RUNNING * / sdev_printk ( KERN_WARNING , sdev , " device_unblock failed with return ( % d ) for handle ( 0 x % 04 x ) " " performing a block followed by an unblock \ n " , r , sas_device_priv_data - > sas_target - > handle ) ; sas_device_priv_data - > block = 1 ; r = scsi_internal_device_block_nowait ( sdev ) ; if ( r ) sdev_printk ( KERN_WARNING , sdev , " retried device_block " " failed with return ( % d ) for handle ( 0 x % 04 x ) \ n " , r , sas_device_priv_data - > sas_target - > handle ) ; sas_device_priv_data - > block = 0 ; r = scsi_internal_device_unblock_nowait ( sdev , SDEV_RUNNING ) ; if ( r ) sdev_printk ( KERN_WARNING , sdev , " retried device_unblock " " failed with return ( % d ) for handle ( 0 x % 04 x ) \ n " , r , sas_device_priv_data - > sas_target - > handle ) ; } } / * * * _ scsih_ublock_io_all_device - unblock every device * @ ioc : per adapter object * * change the device state from block to running * / static void _ scsih_ublock_io_all_device ( struct MPT3SAS_ADAPTER * ioc ) { struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsi_device * sdev ; shost_for_each_device ( sdev , ioc - > shost ) { sas_device_priv_data = sdev - > hostdata ; if ( ! sas_device_priv_data ) continue ; if ( ! sas_device_priv_data - > block ) continue ; dewtprintk ( ioc , sdev_printk ( KERN_INFO , sdev , " device_running , handle ( 0 x % 04 x ) \ n " , sas_device_priv_data - > sas_target - > handle ) ) ; _ scsih_internal_device_unblock ( sdev , sas_device_priv_data ) ; } } / * * * _ scsih_ublock_io_device - prepare device to be deleted * @ ioc : per adapter object * @ sas_address : sas address * @ port : hba port entry * * unblock then put device in offline state * / static void _ scsih_ublock_io_device ( struct MPT3SAS_ADAPTER * ioc , u64 sas_address , struct hba_port * port ) { struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsi_device * sdev ; shost_for_each_device ( sdev , ioc - > shost ) { sas_device_priv_data = sdev - > hostdata ; if ( ! sas_device_priv_data | | ! sas_device_priv_data - > sas_target ) continue ; if ( sas_device_priv_data - > sas_target - > sas_address ! = sas_address ) continue ; if ( sas_device_priv_data - > sas_target - > port ! = port ) continue ; if ( sas_device_priv_data - > block ) _ scsih_internal_device_unblock ( sdev , sas_device_priv_data ) ; } } / * * * _ scsih_block_io_all_device - set the device state to SDEV_BLOCK * @ ioc : per adapter object * * During device pull we need to appropriately set the sdev state . * / static void _ scsih_block_io_all_device ( struct MPT3SAS_ADAPTER * ioc ) { struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsi_device * sdev ; shost_for_each_device ( sdev , ioc - > shost ) { sas_device_priv_data = sdev - > hostdata ; if ( ! sas_device_priv_data ) continue ; if ( sas_device_priv_data - > block ) continue ; if ( sas_device_priv_data - > ignore_delay_remove ) { sdev_printk ( KERN_INFO , sdev , " % s skip device_block for SES handle ( 0 x % 04 x ) \ n " , _ _ func__ , sas_device_priv_data - > sas_target - > handle ) ; continue ; } _ scsih_internal_device_block ( sdev , sas_device_priv_data ) ; } } / * * * _ scsih_block_io_device - set the device state to SDEV_BLOCK * @ ioc : per adapter object * @ handle : device handle * * During device pull we need to appropriately set the sdev state . * / static void _ scsih_block_io_device ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { struct MPT3SAS_DEVICE * sas_device_priv_data ; struct scsi_device * sdev ; struct _ sas_device * sas_device ; sas_device = mpt3sas_get_sdev_by_handle ( ioc , handle ) ; shost_for_each_device ( sdev , ioc - > shost ) { sas_device_priv_data = sdev - > hostdata ; if ( ! sas_device_priv_data ) continue ; if ( sas_device_priv_data - > sas_target - > handle ! = handle ) continue ; if ( sas_device_priv_data - > block ) continue ; if ( sas_device & & sas_device - > pend_sas_rphy_add ) continue ; if ( sas_device_priv_data - > ignore_delay_remove ) { sdev_printk ( KERN_INFO , sdev , " % s skip device_block for SES handle ( 0 x % 04 x ) \ n " , _ _ func__ , sas_device_priv_data - > sas_target - > handle ) ; continue ; } _ scsih_internal_device_block ( sdev , sas_device_priv_data ) ; } if ( sas_device ) sas_device_put ( sas_device ) ; } / * * * _ scsih_block_io_to_children_attached_to_ex * @ ioc : per adapter object * @ sas_expander : the sas_device object * * This routine set sdev state to SDEV_BLOCK for all devices * attached to this expander . This function called when expander is * pulled . * / static void _ scsih_block_io_to_children_attached_to_ex ( struct MPT3SAS_ADAPTER * ioc , struct _ sas_node * sas_expander ) { struct _ sas_port * mpt3sas_port ; struct _ sas_device * sas_device ; struct _ sas_node * expander_sibling ; unsigned long flags ; if ( ! sas_expander ) return ; list_for_each_entry ( mpt3sas_port , & sas_expander - > sas_port_list , port_list ) { if ( mpt3sas_port - > remote_identify . device_type = = SAS_END_DEVICE ) { spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_by_addr ( ioc , mpt3sas_port - > remote_identify . sas_address , mpt3sas_port - > hba_port ) ; if ( sas_device ) { set_bit ( sas_device - > handle , ioc - > blocking_handles ) ; sas_device_put ( sas_device ) ; } spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; } } list_for_each_entry ( mpt3sas_port , & sas_expander - > sas_port_list , port_list ) { if ( mpt3sas_port - > remote_identify . device_type = = SAS_EDGE_EXPANDER_DEVICE | | mpt3sas_port - > remote_identify . device_type = = SAS_FANOUT_EXPANDER_DEVICE ) { expander_sibling = mpt3sas_scsih_expander_find_by_sas_address ( ioc , mpt3sas_port - > remote_identify . sas_address , mpt3sas_port - > hba_port ) ; _ scsih_block_io_to_children_attached_to_ex ( ioc , expander_sibling ) ; } } } / * * * _ scsih_block_io_to_children_attached_directly * @ ioc : per adapter object * @ event_data : topology change event data * * This routine set sdev state to SDEV_BLOCK for all devices * direct attached during device pull . * / static void _ scsih_block_io_to_children_attached_directly ( struct MPT3SAS_ADAPTER * ioc , Mpi2EventDataSasTopologyChangeList_t * event_data ) { int i ; u16 handle ; u16 reason_code ; for ( i = 0 ; i < event_data - > NumEntries ; i + + ) { handle = le16_to_cpu ( event_data - > PHY [ i ] . AttachedDevHandle ) ; if ( ! handle ) continue ; reason_code = event_data - > PHY [ i ] . PhyStatus & MPI2_EVENT_SAS_TOPO_RC_MASK ; if ( reason_code = = MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING ) _ scsih_block_io_device ( ioc , handle ) ; } } / * * * _ scsih_block_io_to_pcie_children_attached_directly * @ ioc : per adapter object * @ event_data : topology change event data * * This routine set sdev state to SDEV_BLOCK for all devices * direct attached during device pull / reconnect . * / static void _ scsih_block_io_to_pcie_children_attached_directly ( struct MPT3SAS_ADAPTER * ioc , Mpi26EventDataPCIeTopologyChangeList_t * event_data ) { int i ; u16 handle ; u16 reason_code ; for ( i = 0 ; i < event_data - > NumEntries ; i + + ) { handle = le16_to_cpu ( event_data - > PortEntry [ i ] . AttachedDevHandle ) ; if ( ! handle ) continue ; reason_code = event_data - > PortEntry [ i ] . PortStatus ; if ( reason_code = = MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING ) _ scsih_block_io_device ( ioc , handle ) ; } } / * * * _ scsih_tm_tr_send - send task management request * @ ioc : per adapter object * @ handle : device handle * Context : interrupt time . * * This code is to initiate the device removal handshake protocol * with controller firmware . This function will issue target reset * using high priority request queue . It will send a sas iounit * control request ( MPI2_SAS_OP_REMOVE_DEVICE ) from this completion . * * This is designed to send muliple task management request at the same * time to the fifo . If the fifo is full , we will append the request , * and process it in a future completion . * / static void _ scsih_tm_tr_send ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { Mpi2SCSITaskManagementRequest_t * mpi_request ; u16 smid ; struct _ sas_device * sas_device = NULL ; struct _ pcie_device * pcie_device = NULL ; struct MPT3SAS_TARGET * sas_target_priv_data = NULL ; u64 sas_address = 0 ; unsigned long flags ; struct _ tr_list * delayed_tr ; u32 ioc_state ; u8 tr_method = 0 ; struct hba_port * port = NULL ; if ( ioc - > pci_error_recovery ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host in pci error recovery : handle ( 0 x % 04 x ) \ n " , _ _ func__ , handle ) ) ; return ; } ioc_state = mpt3sas_base_get_iocstate ( ioc , 1 ) ; if ( ioc_state ! = MPI2_IOC_STATE_OPERATIONAL ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host is not operational : handle ( 0 x % 04 x ) \ n " , _ _ func__ , handle ) ) ; return ; } / * if PD , then return * / if ( test_bit ( handle , ioc - > pd_handles ) ) return ; clear_bit ( handle , ioc - > pend_os_device_add ) ; spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_by_handle ( ioc , handle ) ; if ( sas_device & & sas_device - > starget & & sas_device - > starget - > hostdata ) { sas_target_priv_data = sas_device - > starget - > hostdata ; sas_target_priv_data - > deleted = 1 ; sas_address = sas_device - > sas_address ; port = sas_device - > port ; } spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; if ( ! sas_device ) { spin_lock_irqsave ( & ioc - > pcie_device_lock , flags ) ; pcie_device = _ _ mpt3sas_get_pdev_by_handle ( ioc , handle ) ; if ( pcie_device & & pcie_device - > starget & & pcie_device - > starget - > hostdata ) { sas_target_priv_data = pcie_device - > starget - > hostdata ; sas_target_priv_data - > deleted = 1 ; sas_address = pcie_device - > wwid ; } spin_unlock_irqrestore ( & ioc - > pcie_device_lock , flags ) ; if ( pcie_device & & ( ! ioc - > tm_custom_handling ) & & ( ! ( mpt3sas_scsih_is_pcie_scsi_device ( pcie_device - > device_info ) ) ) ) tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE ; else tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET ; } if ( sas_target_priv_data ) { dewtprintk ( ioc , ioc_info ( ioc , " setting delete flag : handle ( 0 x % 04 x ) , sas_addr ( 0 x % 016 llx ) \ n " , handle , ( u64 ) sas_address ) ) ; if ( sas_device ) { if ( sas_device - > enclosure_handle ! = 0 ) dewtprintk ( ioc , ioc_info ( ioc , " setting delete flag : enclosure logical id ( 0 x % 016 llx ) , slot ( % d ) \ n " , ( u64 ) sas_device - > enclosure_logical_id , sas_device - > slot ) ) ; if ( sas_device - > connector_name [ 0 ] ! = ' \ 0 ' ) dewtprintk ( ioc , ioc_info ( ioc , " setting delete flag : enclosure level ( 0 x % 04 x ) , connector name ( % s ) \ n " , sas_device - > enclosure_level , sas_device - > connector_name ) ) ; } else if ( pcie_device ) { if ( pcie_device - > enclosure_handle ! = 0 ) dewtprintk ( ioc , ioc_info ( ioc , " setting delete flag : logical id ( 0 x % 016 llx ) , slot ( % d ) \ n " , ( u64 ) pcie_device - > enclosure_logical_id , pcie_device - > slot ) ) ; if ( pcie_device - > connector_name [ 0 ] ! = ' \ 0 ' ) dewtprintk ( ioc , ioc_info ( ioc , " setting delete flag : , enclosure level ( 0 x % 04 x ) , connector name ( % s ) \ n " , pcie_device - > enclosure_level , pcie_device - > connector_name ) ) ; } _ scsih_ublock_io_device ( ioc , sas_address , port ) ; sas_target_priv_data - > handle = MPT3SAS_INVALID_DEVICE_HANDLE ; } smid = mpt3sas_base_get_smid_hpr ( ioc , ioc - > tm_tr_cb_idx ) ; if ( ! smid ) { delayed_tr = kzalloc ( sizeof ( * delayed_tr ) , GFP_ATOMIC ) ; if ( ! delayed_tr ) goto out ; INIT_LIST_HEAD ( & delayed_tr - > list ) ; delayed_tr - > handle = handle ; list_add_tail ( & delayed_tr - > list , & ioc - > delayed_tr_list ) ; dewtprintk ( ioc , ioc_info ( ioc , " DELAYED : tr : handle ( 0 x % 04 x ) , ( open ) \ n " , handle ) ) ; goto out ; } dewtprintk ( ioc , ioc_info ( ioc , " tr_send : handle ( 0 x % 04 x ) , ( open ) , smid ( % d ) , cb ( % d ) \ n " , handle , smid , ioc - > tm_tr_cb_idx ) ) ; mpi_request = mpt3sas_base_get_msg_frame ( ioc , smid ) ; memset ( mpi_request , 0 , sizeof ( Mpi2SCSITaskManagementRequest_t ) ) ; mpi_request - > Function = MPI2_FUNCTION_SCSI_TASK_MGMT ; mpi_request - > DevHandle = cpu_to_le16 ( handle ) ; mpi_request - > TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET ; mpi_request - > MsgFlags = tr_method ; set_bit ( handle , ioc - > device_remove_in_progress ) ; ioc - > put_smid_hi_priority ( ioc , smid , 0 ) ; mpt3sas_trigger_master ( ioc , MASTER_TRIGGER_DEVICE_REMOVAL ) ; out : if ( sas_device ) sas_device_put ( sas_device ) ; if ( pcie_device ) pcie_device_put ( pcie_device ) ; } / * * * _ scsih_tm_tr_complete - * @ ioc : per adapter object * @ smid : system request message index * @ msix_index : MSIX table index supplied by the OS * @ reply : reply message frame ( lower 32 bit addr ) * Context : interrupt time . * * This is the target reset completion routine . * This code is part of the code to initiate the device removal * handshake protocol with controller firmware . * It will send a sas iounit control request ( MPI2_SAS_OP_REMOVE_DEVICE ) * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / static u8 _ scsih_tm_tr_complete ( struct MPT3SAS_ADAPTER * ioc , u16 smid , u8 msix_index , u32 reply ) { u16 handle ; Mpi2SCSITaskManagementRequest_t * mpi_request_tm ; Mpi2SCSITaskManagementReply_t * mpi_reply = mpt3sas_base_get_reply_virt_addr ( ioc , reply ) ; Mpi2SasIoUnitControlRequest_t * mpi_request ; u16 smid_sas_ctrl ; u32 ioc_state ; struct _ sc_list * delayed_sc ; if ( ioc - > pci_error_recovery ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host in pci error recovery \ n " , _ _ func__ ) ) ; return 1 ; } ioc_state = mpt3sas_base_get_iocstate ( ioc , 1 ) ; if ( ioc_state ! = MPI2_IOC_STATE_OPERATIONAL ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host is not operational \ n " , _ _ func__ ) ) ; return 1 ; } if ( unlikely ( ! mpi_reply ) ) { ioc_err ( ioc , " mpi_reply not valid at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return 1 ; } mpi_request_tm = mpt3sas_base_get_msg_frame ( ioc , smid ) ; handle = le16_to_cpu ( mpi_request_tm - > DevHandle ) ; if ( handle ! = le16_to_cpu ( mpi_reply - > DevHandle ) ) { dewtprintk ( ioc , ioc_err ( ioc , " spurious interrupt : handle ( 0 x % 04 x : 0 x % 04 x ) , smid ( % d ) ! ! ! \ n " , handle , le16_to_cpu ( mpi_reply - > DevHandle ) , smid ) ) ; return 0 ; } mpt3sas_trigger_master ( ioc , MASTER_TRIGGER_TASK_MANAGMENT ) ; dewtprintk ( ioc , ioc_info ( ioc , " tr_complete : handle ( 0 x % 04 x ) , ( open ) smid ( % d ) , ioc_status ( 0 x % 04 x ) , loginfo ( 0 x % 08 x ) , completed ( % d ) \ n " , handle , smid , le16_to_cpu ( mpi_reply - > IOCStatus ) , le32_to_cpu ( mpi_reply - > IOCLogInfo ) , le32_to_cpu ( mpi_reply - > TerminationCount ) ) ) ; smid_sas_ctrl = mpt3sas_base_get_smid ( ioc , ioc - > tm_sas_control_cb_idx ) ; if ( ! smid_sas_ctrl ) { delayed_sc = kzalloc ( sizeof ( * delayed_sc ) , GFP_ATOMIC ) ; if ( ! delayed_sc ) return _ scsih_check_for_pending_tm ( ioc , smid ) ; INIT_LIST_HEAD ( & delayed_sc - > list ) ; delayed_sc - > handle = le16_to_cpu ( mpi_request_tm - > DevHandle ) ; list_add_tail ( & delayed_sc - > list , & ioc - > delayed_sc_list ) ; dewtprintk ( ioc , ioc_info ( ioc , " DELAYED : sc : handle ( 0 x % 04 x ) , ( open ) \ n " , handle ) ) ; return _ scsih_check_for_pending_tm ( ioc , smid ) ; } dewtprintk ( ioc , ioc_info ( ioc , " sc_send : handle ( 0 x % 04 x ) , ( open ) , smid ( % d ) , cb ( % d ) \ n " , handle , smid_sas_ctrl , ioc - > tm_sas_control_cb_idx ) ) ; mpi_request = mpt3sas_base_get_msg_frame ( ioc , smid_sas_ctrl ) ; memset ( mpi_request , 0 , sizeof ( Mpi2SasIoUnitControlRequest_t ) ) ; mpi_request - > Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL ; mpi_request - > Operation = MPI2_SAS_OP_REMOVE_DEVICE ; mpi_request - > DevHandle = mpi_request_tm - > DevHandle ; ioc - > put_smid_default ( ioc , smid_sas_ctrl ) ; return _ scsih_check_for_pending_tm ( ioc , smid ) ; } / * * _ scsih_allow_scmd_to_device - check whether scmd needs to * issue to IOC or not . * @ ioc : per adapter object * @ scmd : pointer to scsi command object * * Returns true if scmd can be issued to IOC otherwise returns false . * / inline bool _ scsih_allow_scmd_to_device ( struct MPT3SAS_ADAPTER * ioc , struct scsi_cmnd * scmd ) { if ( ioc - > pci_error_recovery ) return false ; if ( ioc - > hba_mpi_version_belonged = = MPI2_VERSION ) { if ( ioc - > remove_host ) return false ; return true ; } if ( ioc - > remove_host ) { switch ( scmd - > cmnd [ 0 ] ) { case SYNCHRONIZE_CACHE : case START_STOP : return true ; default : return false ; } } return true ; } / * * * _ scsih_sas_control_complete - completion routine * @ ioc : per adapter object * @ smid : system request message index * @ msix_index : MSIX table index supplied by the OS * @ reply : reply message frame ( lower 32 bit addr ) * Context : interrupt time . * * This is the sas iounit control completion routine . * This code is part of the code to initiate the device removal * handshake protocol with controller firmware . * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / static u8 _ scsih_sas_control_complete ( struct MPT3SAS_ADAPTER * ioc , u16 smid , u8 msix_index , u32 reply ) { Mpi2SasIoUnitControlReply_t * mpi_reply = mpt3sas_base_get_reply_virt_addr ( ioc , reply ) ; if ( likely ( mpi_reply ) ) { dewtprintk ( ioc , ioc_info ( ioc , " sc_complete : handle ( 0 x % 04 x ) , ( open ) smid ( % d ) , ioc_status ( 0 x % 04 x ) , loginfo ( 0 x % 08 x ) \ n " , le16_to_cpu ( mpi_reply - > DevHandle ) , smid , le16_to_cpu ( mpi_reply - > IOCStatus ) , le32_to_cpu ( mpi_reply - > IOCLogInfo ) ) ) ; if ( le16_to_cpu ( mpi_reply - > IOCStatus ) = = MPI2_IOCSTATUS_SUCCESS ) { clear_bit ( le16_to_cpu ( mpi_reply - > DevHandle ) , ioc - > device_remove_in_progress ) ; } } else { ioc_err ( ioc , " mpi_reply not valid at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; } return mpt3sas_check_for_pending_internal_cmds ( ioc , smid ) ; } / * * * _ scsih_tm_tr_volume_send - send target reset request for volumes * @ ioc : per adapter object * @ handle : device handle * Context : interrupt time . * * This is designed to send muliple task management request at the same * time to the fifo . If the fifo is full , we will append the request , * and process it in a future completion . * / static void _ scsih_tm_tr_volume_send ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { Mpi2SCSITaskManagementRequest_t * mpi_request ; u16 smid ; struct _ tr_list * delayed_tr ; if ( ioc - > pci_error_recovery ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host reset in progress ! \ n " , _ _ func__ ) ) ; return ; } smid = mpt3sas_base_get_smid_hpr ( ioc , ioc - > tm_tr_volume_cb_idx ) ; if ( ! smid ) { delayed_tr = kzalloc ( sizeof ( * delayed_tr ) , GFP_ATOMIC ) ; if ( ! delayed_tr ) return ; INIT_LIST_HEAD ( & delayed_tr - > list ) ; delayed_tr - > handle = handle ; list_add_tail ( & delayed_tr - > list , & ioc - > delayed_tr_volume_list ) ; dewtprintk ( ioc , ioc_info ( ioc , " DELAYED : tr : handle ( 0 x % 04 x ) , ( open ) \ n " , handle ) ) ; return ; } dewtprintk ( ioc , ioc_info ( ioc , " tr_send : handle ( 0 x % 04 x ) , ( open ) , smid ( % d ) , cb ( % d ) \ n " , handle , smid , ioc - > tm_tr_volume_cb_idx ) ) ; mpi_request = mpt3sas_base_get_msg_frame ( ioc , smid ) ; memset ( mpi_request , 0 , sizeof ( Mpi2SCSITaskManagementRequest_t ) ) ; mpi_request - > Function = MPI2_FUNCTION_SCSI_TASK_MGMT ; mpi_request - > DevHandle = cpu_to_le16 ( handle ) ; mpi_request - > TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET ; ioc - > put_smid_hi_priority ( ioc , smid , 0 ) ; } / * * * _ scsih_tm_volume_tr_complete - target reset completion * @ ioc : per adapter object * @ smid : system request message index * @ msix_index : MSIX table index supplied by the OS * @ reply : reply message frame ( lower 32 bit addr ) * Context : interrupt time . * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / static u8 _ scsih_tm_volume_tr_complete ( struct MPT3SAS_ADAPTER * ioc , u16 smid , u8 msix_index , u32 reply ) { u16 handle ; Mpi2SCSITaskManagementRequest_t * mpi_request_tm ; Mpi2SCSITaskManagementReply_t * mpi_reply = mpt3sas_base_get_reply_virt_addr ( ioc , reply ) ; if ( ioc - > shost_recovery | | ioc - > pci_error_recovery ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host reset in progress ! \ n " , _ _ func__ ) ) ; return 1 ; } if ( unlikely ( ! mpi_reply ) ) { ioc_err ( ioc , " mpi_reply not valid at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return 1 ; } mpi_request_tm = mpt3sas_base_get_msg_frame ( ioc , smid ) ; handle = le16_to_cpu ( mpi_request_tm - > DevHandle ) ; if ( handle ! = le16_to_cpu ( mpi_reply - > DevHandle ) ) { dewtprintk ( ioc , ioc_err ( ioc , " spurious interrupt : handle ( 0 x % 04 x : 0 x % 04 x ) , smid ( % d ) ! ! ! \ n " , handle , le16_to_cpu ( mpi_reply - > DevHandle ) , smid ) ) ; return 0 ; } dewtprintk ( ioc , ioc_info ( ioc , " tr_complete : handle ( 0 x % 04 x ) , ( open ) smid ( % d ) , ioc_status ( 0 x % 04 x ) , loginfo ( 0 x % 08 x ) , completed ( % d ) \ n " , handle , smid , le16_to_cpu ( mpi_reply - > IOCStatus ) , le32_to_cpu ( mpi_reply - > IOCLogInfo ) , le32_to_cpu ( mpi_reply - > TerminationCount ) ) ) ; return _ scsih_check_for_pending_tm ( ioc , smid ) ; } / * * * _ scsih_issue_delayed_event_ack - issue delayed Event ACK messages * @ ioc : per adapter object * @ smid : system request message index * @ event : Event ID * @ event_context : used to track events uniquely * * Context - processed in interrupt context . * / static void _ scsih_issue_delayed_event_ack ( struct MPT3SAS_ADAPTER * ioc , u16 smid , U16 event , U32 event_context ) { Mpi2EventAckRequest_t * ack_request ; int i = smid - ioc - > internal_smid ; unsigned long flags ; / * Without releasing the smid just update the * call back index and reuse the same smid for * processing this delayed request * / spin_lock_irqsave ( & ioc - > scsi_lookup_lock , flags ) ; ioc - > internal_lookup [ i ] . cb_idx = ioc - > base_cb_idx ; spin_unlock_irqrestore ( & ioc - > scsi_lookup_lock , flags ) ; dewtprintk ( ioc , ioc_info ( ioc , " EVENT ACK : event ( 0 x % 04 x ) , smid ( % d ) , cb ( % d ) \ n " , le16_to_cpu ( event ) , smid , ioc - > base_cb_idx ) ) ; ack_request = mpt3sas_base_get_msg_frame ( ioc , smid ) ; memset ( ack_request , 0 , sizeof ( Mpi2EventAckRequest_t ) ) ; ack_request - > Function = MPI2_FUNCTION_EVENT_ACK ; ack_request - > Event = event ; ack_request - > EventContext = event_context ; ack_request - > VF_ID = 0 ; / * TODO * / ack_request - > VP_ID = 0 ; ioc - > put_smid_default ( ioc , smid ) ; } / * * * _ scsih_issue_delayed_sas_io_unit_ctrl - issue delayed * sas_io_unit_ctrl messages * @ ioc : per adapter object * @ smid : system request message index * @ handle : device handle * * Context - processed in interrupt context . * / static void _ scsih_issue_delayed_sas_io_unit_ctrl ( struct MPT3SAS_ADAPTER * ioc , u16 smid , u16 handle ) { Mpi2SasIoUnitControlRequest_t * mpi_request ; u32 ioc_state ; int i = smid - ioc - > internal_smid ; unsigned long flags ; if ( ioc - > remove_host ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host has been removed \ n " , _ _ func__ ) ) ; return ; } else if ( ioc - > pci_error_recovery ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host in pci error recovery \ n " , _ _ func__ ) ) ; return ; } ioc_state = mpt3sas_base_get_iocstate ( ioc , 1 ) ; if ( ioc_state ! = MPI2_IOC_STATE_OPERATIONAL ) { dewtprintk ( ioc , ioc_info ( ioc , " % s : host is not operational \ n " , _ _ func__ ) ) ; return ; } / * Without releasing the smid just update the * call back index and reuse the same smid for * processing this delayed request * / spin_lock_irqsave ( & ioc - > scsi_lookup_lock , flags ) ; ioc - > internal_lookup [ i ] . cb_idx = ioc - > tm_sas_control_cb_idx ; spin_unlock_irqrestore ( & ioc - > scsi_lookup_lock , flags ) ; dewtprintk ( ioc , ioc_info ( ioc , " sc_send : handle ( 0 x % 04 x ) , ( open ) , smid ( % d ) , cb ( % d ) \ n " , handle , smid , ioc - > tm_sas_control_cb_idx ) ) ; mpi_request = mpt3sas_base_get_msg_frame ( ioc , smid ) ; memset ( mpi_request , 0 , sizeof ( Mpi2SasIoUnitControlRequest_t ) ) ; mpi_request - > Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL ; mpi_request - > Operation = MPI2_SAS_OP_REMOVE_DEVICE ; mpi_request - > DevHandle = cpu_to_le16 ( handle ) ; ioc - > put_smid_default ( ioc , smid ) ; } / * * * mpt3sas_check_for_pending_internal_cmds - check for pending internal messages * @ ioc : per adapter object * @ smid : system request message index * * Context : Executed in interrupt context * * This will check delayed internal messages list , and process the * next request . * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / u8 mpt3sas_check_for_pending_internal_cmds ( struct MPT3SAS_ADAPTER * ioc , u16 smid ) { struct _ sc_list * delayed_sc ; struct _ event_ack_list * delayed_event_ack ; if ( ! list_empty ( & ioc - > delayed_event_ack_list ) ) { delayed_event_ack = list_entry ( ioc - > delayed_event_ack_list . next , struct _ event_ack_list , list ) ; _ scsih_issue_delayed_event_ack ( ioc , smid , delayed_event_ack - > Event , delayed_event_ack - > EventContext ) ; list_del ( & delayed_event_ack - > list ) ; kfree ( delayed_event_ack ) ; return 0 ; } if ( ! list_empty ( & ioc - > delayed_sc_list ) ) { delayed_sc = list_entry ( ioc - > delayed_sc_list . next , struct _ sc_list , list ) ; _ scsih_issue_delayed_sas_io_unit_ctrl ( ioc , smid , delayed_sc - > handle ) ; list_del ( & delayed_sc - > list ) ; kfree ( delayed_sc ) ; return 0 ; } return 1 ; } / * * * _ scsih_check_for_pending_tm - check for pending task management * @ ioc : per adapter object * @ smid : system request message index * * This will check delayed target reset list , and feed the * next reqeust . * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / static u8 _ scsih_check_for_pending_tm ( struct MPT3SAS_ADAPTER * ioc , u16 smid ) { struct _ tr_list * delayed_tr ; if ( ! list_empty ( & ioc - > delayed_tr_volume_list ) ) { delayed_tr = list_entry ( ioc - > delayed_tr_volume_list . next , struct _ tr_list , list ) ; mpt3sas_base_free_smid ( ioc , smid ) ; _ scsih_tm_tr_volume_send ( ioc , delayed_tr - > handle ) ; list_del ( & delayed_tr - > list ) ; kfree ( delayed_tr ) ; return 0 ; } if ( ! list_empty ( & ioc - > delayed_tr_list ) ) { delayed_tr = list_entry ( ioc - > delayed_tr_list . next , struct _ tr_list , list ) ; mpt3sas_base_free_smid ( ioc , smid ) ; _ scsih_tm_tr_send ( ioc , delayed_tr - > handle ) ; list_del ( & delayed_tr - > list ) ; kfree ( delayed_tr ) ; return 0 ; } return 1 ; } / * * * _ scsih_check_topo_delete_events - sanity check on topo events * @ ioc : per adapter object * @ event_data : the event data payload * * This routine added to better handle cable breaker . * * This handles the case where driver receives multiple expander * add and delete events in a single shot . When there is a delete event * the routine will void any pending add events waiting in the event queue . * / static void _ scsih_check_topo_delete_events ( struct MPT3SAS_ADAPTER * ioc , Mpi2EventDataSasTopologyChangeList_t * event_data ) { struct fw_event_work * fw_event ; Mpi2EventDataSasTopologyChangeList_t * local_event_data ; u16 expander_handle ; struct _ sas_node * sas_expander ; unsigned long flags ; int i , reason_code ; u16 handle ; for ( i = 0 ; i < event_data - > NumEntries ; i + + ) { handle = le16_to_cpu ( event_data - > PHY [ i ] . AttachedDevHandle ) ; if ( ! handle ) continue ; reason_code = event_data - > PHY [ i ] . PhyStatus & MPI2_EVENT_SAS_TOPO_RC_MASK ; if ( reason_code = = MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING ) _ scsih_tm_tr_send ( ioc , handle ) ; } expander_handle = le16_to_cpu ( event_data - > ExpanderDevHandle ) ; if ( expander_handle < ioc - > sas_hba . num_phys ) { _ scsih_block_io_to_children_attached_directly ( ioc , event_data ) ; return ; } if ( event_data - > ExpStatus = = MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING ) { / * put expander attached devices into blocking state * / spin_lock_irqsave ( & ioc - > sas_node_lock , flags ) ; sas_expander = mpt3sas_scsih_expander_find_by_handle ( ioc , expander_handle ) ; _ scsih_block_io_to_children_attached_to_ex ( ioc , sas_expander ) ; spin_unlock_irqrestore ( & ioc - > sas_node_lock , flags ) ; do { handle = find_first_bit ( ioc - > blocking_handles , ioc - > facts . MaxDevHandle ) ; if ( handle < ioc - > facts . MaxDevHandle ) _ scsih_block_io_device ( ioc , handle ) ; } while ( test_and_clear_bit ( handle , ioc - > blocking_handles ) ) ; } else if ( event_data - > ExpStatus = = MPI2_EVENT_SAS_TOPO_ES_RESPONDING ) _ scsih_block_io_to_children_attached_directly ( ioc , event_data ) ; if ( event_data - > ExpStatus ! = MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING ) return ; / * mark ignore flag for pending events * / spin_lock_irqsave ( & ioc - > fw_event_lock , flags ) ; list_for_each_entry ( fw_event , & ioc - > fw_event_list , list ) { if ( fw_event - > event ! = MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST | | fw_event - > ignore ) continue ; local_event_data = ( Mpi2EventDataSasTopologyChangeList_t * ) fw_event - > event_data ; if ( local_event_data - > ExpStatus = = MPI2_EVENT_SAS_TOPO_ES_ADDED | | local_event_data - > ExpStatus = = MPI2_EVENT_SAS_TOPO_ES_RESPONDING ) { if ( le16_to_cpu ( local_event_data - > ExpanderDevHandle ) = = expander_handle ) { dewtprintk ( ioc , ioc_info ( ioc , " setting ignoring flag \ n " ) ) ; fw_event - > ignore = 1 ; } } } spin_unlock_irqrestore ( & ioc - > fw_event_lock , flags ) ; } / * * * _ scsih_check_pcie_topo_remove_events - sanity check on topo * events * @ ioc : per adapter object * @ event_data : the event data payload * * This handles the case where driver receives multiple switch * or device add and delete events in a single shot . When there * is a delete event the routine will void any pending add * events waiting in the event queue . * / static void _ scsih_check_pcie_topo_remove_events ( struct MPT3SAS_ADAPTER * ioc , Mpi26EventDataPCIeTopologyChangeList_t * event_data ) { struct fw_event_work * fw_event ; Mpi26EventDataPCIeTopologyChangeList_t * local_event_data ; unsigned long flags ; int i , reason_code ; u16 handle , switch_handle ; for ( i = 0 ; i < event_data - > NumEntries ; i + + ) { handle = le16_to_cpu ( event_data - > PortEntry [ i ] . AttachedDevHandle ) ; if ( ! handle ) continue ; reason_code = event_data - > PortEntry [ i ] . PortStatus ; if ( reason_code = = MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING ) _ scsih_tm_tr_send ( ioc , handle ) ; } switch_handle = le16_to_cpu ( event_data - > SwitchDevHandle ) ; if ( ! switch_handle ) { _ scsih_block_io_to_pcie_children_attached_directly ( ioc , event_data ) ; return ; } / * TODO We are not supporting cascaded PCIe Switch removal yet * / if ( ( event_data - > SwitchStatus = = MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING ) | | ( event_data - > SwitchStatus = = MPI26_EVENT_PCIE_TOPO_SS_RESPONDING ) ) _ scsih_block_io_to_pcie_children_attached_directly ( ioc , event_data ) ; if ( event_data - > SwitchStatus ! = MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING ) return ; / * mark ignore flag for pending events * / spin_lock_irqsave ( & ioc - > fw_event_lock , flags ) ; list_for_each_entry ( fw_event , & ioc - > fw_event_list , list ) { if ( fw_event - > event ! = MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST | | fw_event - > ignore ) continue ; local_event_data = ( Mpi26EventDataPCIeTopologyChangeList_t * ) fw_event - > event_data ; if ( local_event_data - > SwitchStatus = = MPI2_EVENT_SAS_TOPO_ES_ADDED | | local_event_data - > SwitchStatus = = MPI2_EVENT_SAS_TOPO_ES_RESPONDING ) { if ( le16_to_cpu ( local_event_data - > SwitchDevHandle ) = = switch_handle ) { dewtprintk ( ioc , ioc_info ( ioc , " setting ignoring flag for switch event \ n " ) ) ; fw_event - > ignore = 1 ; } } } spin_unlock_irqrestore ( & ioc - > fw_event_lock , flags ) ; } / * * * _ scsih_set_volume_delete_flag - setting volume delete flag * @ ioc : per adapter object * @ handle : device handle * * This returns nothing . * / static void _ scsih_set_volume_delete_flag ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { struct _ raid_device * raid_device ; struct MPT3SAS_TARGET * sas_target_priv_data ; unsigned long flags ; spin_lock_irqsave ( & ioc - > raid_device_lock , flags ) ; raid_device = mpt3sas_raid_device_find_by_handle ( ioc , handle ) ; if ( raid_device & & raid_device - > starget & & raid_device - > starget - > hostdata ) { sas_target_priv_data = raid_device - > starget - > hostdata ; sas_target_priv_data - > deleted = 1 ; dewtprintk ( ioc , ioc_info ( ioc , " setting delete flag : handle ( 0 x % 04 x ) , wwid ( 0 x % 016 llx ) \ n " , handle , ( u64 ) raid_device - > wwid ) ) ; } spin_unlock_irqrestore ( & ioc - > raid_device_lock , flags ) ; } / * * * _ scsih_set_volume_handle_for_tr - set handle for target reset to volume * @ handle : input handle * @ a : handle for volume a * @ b : handle for volume b * * IR firmware only supports two raid volumes . The purpose of this * routine is to set the volume handle in either a or b . When the given * input handle is non - zero , or when a and b have not been set before . * / static void _ scsih_set_volume_handle_for_tr ( u16 handle , u16 * a , u16 * b ) { if ( ! handle | | handle = = * a | | handle = = * b ) return ; if ( ! * a ) * a = handle ; else if ( ! * b ) * b = handle ; } / * * * _ scsih_check_ir_config_unhide_events - check for UNHIDE events * @ ioc : per adapter object * @ event_data : the event data payload * Context : interrupt time . * * This routine will send target reset to volume , followed by target * resets to the PDs . This is called when a PD has been removed , or * volume has been deleted or removed . When the target reset is sent * to volume , the PD target resets need to be queued to start upon * completion of the volume target reset . * / static void _ scsih_check_ir_config_unhide_events ( struct MPT3SAS_ADAPTER * ioc , Mpi2EventDataIrConfigChangeList_t * event_data ) { Mpi2EventIrConfigElement_t * element ; int i ; u16 handle , volume_handle , a , b ; struct _ tr_list * delayed_tr ; a = 0 ; b = 0 ; if ( ioc - > is_warpdrive ) return ; / * Volume Resets for Deleted or Removed * / element = ( Mpi2EventIrConfigElement_t * ) & event_data - > ConfigElement [ 0 ] ; for ( i = 0 ; i < event_data - > NumElements ; i + + , element + + ) { if ( le32_to_cpu ( event_data - > Flags ) & MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG ) continue ; if ( element - > ReasonCode = = MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED | | element - > ReasonCode = = MPI2_EVENT_IR_CHANGE_RC_REMOVED ) { volume_handle = le16_to_cpu ( element - > VolDevHandle ) ; _ scsih_set_volume_delete_flag ( ioc , volume_handle ) ; _ scsih_set_volume_handle_for_tr ( volume_handle , & a , & b ) ; } } / * Volume Resets for UNHIDE events * / element = ( Mpi2EventIrConfigElement_t * ) & event_data - > ConfigElement [ 0 ] ; for ( i = 0 ; i < event_data - > NumElements ; i + + , element + + ) { if ( le32_to_cpu ( event_data - > Flags ) & MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG ) continue ; if ( element - > ReasonCode = = MPI2_EVENT_IR_CHANGE_RC_UNHIDE ) { volume_handle = le16_to_cpu ( element - > VolDevHandle ) ; _ scsih_set_volume_handle_for_tr ( volume_handle , & a , & b ) ; } } if ( a ) _ scsih_tm_tr_volume_send ( ioc , a ) ; if ( b ) _ scsih_tm_tr_volume_send ( ioc , b ) ; / * PD target resets * / element = ( Mpi2EventIrConfigElement_t * ) & event_data - > ConfigElement [ 0 ] ; for ( i = 0 ; i < event_data - > NumElements ; i + + , element + + ) { if ( element - > ReasonCode ! = MPI2_EVENT_IR_CHANGE_RC_UNHIDE ) continue ; handle = le16_to_cpu ( element - > PhysDiskDevHandle ) ; volume_handle = le16_to_cpu ( element - > VolDevHandle ) ; clear_bit ( handle , ioc - > pd_handles ) ; if ( ! volume_handle ) _ scsih_tm_tr_send ( ioc , handle ) ; else if ( volume_handle = = a | | volume_handle = = b ) { delayed_tr = kzalloc ( sizeof ( * delayed_tr ) , GFP_ATOMIC ) ; BUG_ON ( ! delayed_tr ) ; INIT_LIST_HEAD ( & delayed_tr - > list ) ; delayed_tr - > handle = handle ; list_add_tail ( & delayed_tr - > list , & ioc - > delayed_tr_list ) ; dewtprintk ( ioc , ioc_info ( ioc , " DELAYED : tr : handle ( 0 x % 04 x ) , ( open ) \ n " , handle ) ) ; } else _ scsih_tm_tr_send ( ioc , handle ) ; } } / * * * _ scsih_check_volume_delete_events - set delete flag for volumes * @ ioc : per adapter object * @ event_data : the event data payload * Context : interrupt time . * * This will handle the case when the cable connected to entire volume is * pulled . We will take care of setting the deleted flag so normal IO will * not be sent . * / static void _ scsih_check_volume_delete_events ( struct MPT3SAS_ADAPTER * ioc , Mpi2EventDataIrVolume_t * event_data ) { u32 state ; if ( event_data - > ReasonCode ! = MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED ) return ; state = le32_to_cpu ( event_data - > NewValue ) ; if ( state = = MPI2_RAID_VOL_STATE_MISSING | | state = = MPI2_RAID_VOL_STATE_FAILED ) _ scsih_set_volume_delete_flag ( ioc , le16_to_cpu ( event_data - > VolDevHandle ) ) ; } / * * * _ scsih_temp_threshold_events - display temperature threshold exceeded events * @ ioc : per adapter object * @ event_data : the temp threshold event data * Context : interrupt time . * / static void _ scsih_temp_threshold_events ( struct MPT3SAS_ADAPTER * ioc , Mpi2EventDataTemperature_t * event_data ) { u32 doorbell ; if ( ioc - > temp_sensors_count > = event_data - > SensorNum ) { ioc_err ( ioc , " Temperature Threshold flags % s % s % s % s exceeded for Sensor : % d ! ! ! \ n " , le16_to_cpu ( event_data - > Status ) & 0 x1 ? " 0 " : " " , le16_to_cpu ( event_data - > Status ) & 0 x2 ? " 1 " : " " , le16_to_cpu ( event_data - > Status ) & 0 x4 ? " 2 " : " " , le16_to_cpu ( event_data - > Status ) & 0 x8 ? " 3 " : " " , event_data - > SensorNum ) ; ioc_err ( ioc , " Current Temp In Celsius : % d \ n " , event_data - > CurrentTemperature ) ; if ( ioc - > hba_mpi_version_belonged ! = MPI2_VERSION ) { doorbell = mpt3sas_base_get_iocstate ( ioc , 0 ) ; if ( ( doorbell & MPI2_IOC_STATE_MASK ) = = MPI2_IOC_STATE_FAULT ) { mpt3sas_print_fault_code ( ioc , doorbell & MPI2_DOORBELL_DATA_MASK ) ; } else if ( ( doorbell & MPI2_IOC_STATE_MASK ) = = MPI2_IOC_STATE_COREDUMP ) { mpt3sas_print_coredump_info ( ioc , doorbell & MPI2_DOORBELL_DATA_MASK ) ; } } } } static int _ scsih_set_satl_pending ( struct scsi_cmnd * scmd , bool pending ) { struct MPT3SAS_DEVICE * priv = scmd - > device - > hostdata ; if ( scmd - > cmnd [ 0 ] ! = ATA_12 & & scmd - > cmnd [ 0 ] ! = ATA_16 ) return 0 ; if ( pending ) return test_and_set_bit ( 0 , & priv - > ata_command_pending ) ; clear_bit ( 0 , & priv - > ata_command_pending ) ; return 0 ; } / * * * _ scsih_flush_running_cmds - completing outstanding commands . * @ ioc : per adapter object * * The flushing out of all pending scmd commands following host reset , * where all IO is dropped to the floor . * / static void _ scsih_flush_running_cmds ( struct MPT3SAS_ADAPTER * ioc ) { struct scsi_cmnd * scmd ; struct scsiio_tracker * st ; u16 smid ; int count = 0 ; for ( smid = 1 ; smid < = ioc - > scsiio_depth ; smid + + ) { scmd = mpt3sas_scsih_scsi_lookup_get ( ioc , smid ) ; if ( ! scmd ) continue ; count + + ; _ scsih_set_satl_pending ( scmd , false ) ; st = scsi_cmd_priv ( scmd ) ; mpt3sas_base_clear_st ( ioc , st ) ; scsi_dma_unmap ( scmd ) ; if ( ioc - > pci_error_recovery | | ioc - > remove_host ) scmd - > result = DID_NO_CONNECT < < 16 ; else scmd - > result = DID_RESET < < 16 ; scsi_done ( scmd ) ; } dtmprintk ( ioc , ioc_info ( ioc , " completing % d cmds \ n " , count ) ) ; } / * * * _ scsih_setup_eedp - setup MPI request for EEDP transfer * @ ioc : per adapter object * @ scmd : pointer to scsi command object * @ mpi_request : pointer to the SCSI_IO request message frame * * Supporting protection 1 and 3 . * / static void _ scsih_setup_eedp ( struct MPT3SAS_ADAPTER * ioc , struct scsi_cmnd * scmd , Mpi25SCSIIORequest_t * mpi_request ) { u16 eedp_flags ; Mpi25SCSIIORequest_t * mpi_request_3v = ( Mpi25SCSIIORequest_t * ) mpi_request ; switch ( scsi_get_prot_op ( scmd ) ) { case SCSI_PROT_READ_STRIP : eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP ; break ; case SCSI_PROT_WRITE_INSERT : eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP ; break ; default : return ; } if ( scmd - > prot_flags & SCSI_PROT_GUARD_CHECK ) eedp_flags | = MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD ; if ( scmd - > prot_flags & SCSI_PROT_REF_CHECK ) eedp_flags | = MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG ; if ( scmd - > prot_flags & SCSI_PROT_REF_INCREMENT ) { eedp_flags | = MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG ; mpi_request - > CDB . EEDP32 . PrimaryReferenceTag = cpu_to_be32 ( scsi_prot_ref_tag ( scmd ) ) ; } mpi_request_3v - > EEDPBlockSize = cpu_to_le16 ( scsi_prot_interval ( scmd ) ) ; if ( ioc - > is_gen35_ioc ) eedp_flags | = MPI25_SCSIIO_EEDPFLAGS_APPTAG_DISABLE_MODE ; mpi_request - > EEDPFlags = cpu_to_le16 ( eedp_flags ) ; } / * * * _ scsih_eedp_error_handling - return sense code for EEDP errors * @ scmd : pointer to scsi command object * @ ioc_status : ioc status * / static void _ scsih_eedp_error_handling ( struct scsi_cmnd * scmd , u16 ioc_status ) { u8 ascq ; switch ( ioc_status ) { case MPI2_IOCSTATUS_EEDP_GUARD_ERROR : ascq = 0 x01 ; break ; case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR : ascq = 0 x02 ; break ; case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR : ascq = 0 x03 ; break ; default : ascq = 0 x00 ; break ; } scsi_build_sense ( scmd , 0 , ILLEGAL_REQUEST , 0 x10 , ascq ) ; set_host_byte ( scmd , DID_ABORT ) ; } / * * * scsih_qcmd - main scsi request entry point * @ shost : SCSI host pointer * @ scmd : pointer to scsi command object * * The callback index is set inside ` ioc - > scsi_io_cb_idx ` . * * Return : 0 on success . If there ' s a failure , return either : * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full , or * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full * / static int scsih_qcmd ( struct Scsi_Host * shost , struct scsi_cmnd * scmd ) { struct MPT3SAS_ADAPTER * ioc = shost_priv ( shost ) ; struct MPT3SAS_DEVICE * sas_device_priv_data ; struct MPT3SAS_TARGET * sas_target_priv_data ; struct _ raid_device * raid_device ; struct request * rq = scsi_cmd_to_rq ( scmd ) ; int class ; Mpi25SCSIIORequest_t * mpi_request ; struct _ pcie_device * pcie_device = NULL ; u32 mpi_control ; u16 smid ; u16 handle ; if ( ioc - > logging_level & MPT_DEBUG_SCSI ) scsi_print_command ( scmd ) ; sas_device_priv_data = scmd - > device - > hostdata ; if ( ! sas_device_priv_data | | ! sas_device_priv_data - > sas_target ) { scmd - > result = DID_NO_CONNECT < < 16 ; scsi_done ( scmd ) ; return 0 ; } if ( ! ( _ scsih_allow_scmd_to_device ( ioc , scmd ) ) ) { scmd - > result = DID_NO_CONNECT < < 16 ; scsi_done ( scmd ) ; return 0 ; } sas_target_priv_data = sas_device_priv_data - > sas_target ; / * invalid device handle * / handle = sas_target_priv_data - > handle ; / * * Avoid error handling escallation when device is disconnected * / if ( handle = = MPT3SAS_INVALID_DEVICE_HANDLE | | sas_device_priv_data - > block ) { if ( scmd - > device - > host - > shost_state = = SHOST_RECOVERY & & scmd - > cmnd [ 0 ] = = TEST_UNIT_READY ) { scsi_build_sense ( scmd , 0 , UNIT_ATTENTION , 0 x29 , 0 x07 ) ; scsi_done ( scmd ) ; return 0 ; } } if ( handle = = MPT3SAS_INVALID_DEVICE_HANDLE ) { scmd - > result = DID_NO_CONNECT < < 16 ; scsi_done ( scmd ) ; return 0 ; } if ( ioc - > shost_recovery | | ioc - > ioc_link_reset_in_progress ) { / * host recovery or link resets sent via IOCTLs * / return SCSI_MLQUEUE_HOST_BUSY ; } else if ( sas_target_priv_data - > deleted ) { / * device has been deleted * / scmd - > result = DID_NO_CONNECT < < 16 ; scsi_done ( scmd ) ; return 0 ; } else if ( sas_target_priv_data - > tm_busy | | sas_device_priv_data - > block ) { / * device busy with task management * / return SCSI_MLQUEUE_DEVICE_BUSY ; } / * * Bug work around for firmware SATL handling . The loop * is based on atomic operations and ensures consistency * since we ' re lockless at this point * / do { if ( test_bit ( 0 , & sas_device_priv_data - > ata_command_pending ) ) return SCSI_MLQUEUE_DEVICE_BUSY ; } while ( _ scsih_set_satl_pending ( scmd , true ) ) ; if ( scmd - > sc_data_direction = = DMA_FROM_DEVICE ) mpi_control = MPI2_SCSIIO_CONTROL_READ ; else if ( scmd - > sc_data_direction = = DMA_TO_DEVICE ) mpi_control = MPI2_SCSIIO_CONTROL_WRITE ; else mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER ; / * set tags * / mpi_control | = MPI2_SCSIIO_CONTROL_SIMPLEQ ; / * NCQ Prio supported , make sure control indicated high priority * / if ( sas_device_priv_data - > ncq_prio_enable ) { class = IOPRIO_PRIO_CLASS ( req_get_ioprio ( rq ) ) ; if ( class = = IOPRIO_CLASS_RT ) mpi_control | = 1 < < MPI2_SCSIIO_CONTROL_CMDPRI_SHIFT ; } / * Make sure Device is not raid volume . * We do not expose raid functionality to upper layer for warpdrive . * / if ( ( ( ! ioc - > is_warpdrive & & ! scsih_is_raid ( & scmd - > device - > sdev_gendev ) ) & & ! scsih_is_nvme ( & scmd - > device - > sdev_gendev ) ) & & sas_is_tlr_enabled ( scmd - > device ) & & scmd - > cmd_len ! = 32 ) mpi_control | = MPI2_SCSIIO_CONTROL_TLR_ON ; smid = mpt3sas_base_get_smid_scsiio ( ioc , ioc - > scsi_io_cb_idx , scmd ) ; if ( ! smid ) { ioc_err ( ioc , " % s : failed obtaining a smid \ n " , _ _ func__ ) ; _ scsih_set_satl_pending ( scmd , false ) ; goto out ; } mpi_request = mpt3sas_base_get_msg_frame ( ioc , smid ) ; memset ( mpi_request , 0 , ioc - > request_sz ) ; _ scsih_setup_eedp ( ioc , scmd , mpi_request ) ; if ( scmd - > cmd_len = = 32 ) mpi_control | = 4 < < MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT ; mpi_request - > Function = MPI2_FUNCTION_SCSI_IO_REQUEST ; if ( sas_device_priv_data - > sas_target - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT ) mpi_request - > Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ; else mpi_request - > Function = MPI2_FUNCTION_SCSI_IO_REQUEST ; mpi_request - > DevHandle = cpu_to_le16 ( handle ) ; mpi_request - > DataLength = cpu_to_le32 ( scsi_bufflen ( scmd ) ) ; mpi_request - > Control = cpu_to_le32 ( mpi_control ) ; mpi_request - > IoFlags = cpu_to_le16 ( scmd - > cmd_len ) ; mpi_request - > MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR ; mpi_request - > SenseBufferLength = SCSI_SENSE_BUFFERSIZE ; mpi_request - > SenseBufferLowAddress = mpt3sas_base_get_sense_buffer_dma ( ioc , smid ) ; mpi_request - > SGLOffset0 = offsetof ( Mpi25SCSIIORequest_t , SGL ) / 4 ; int_to_scsilun ( sas_device_priv_data - > lun , ( struct scsi_lun * ) mpi_request - > LUN ) ; memcpy ( mpi_request - > CDB . CDB32 , scmd - > cmnd , scmd - > cmd_len ) ; if ( mpi_request - > DataLength ) { pcie_device = sas_target_priv_data - > pcie_dev ; if ( ioc - > build_sg_scmd ( ioc , scmd , smid , pcie_device ) ) { mpt3sas_base_free_smid ( ioc , smid ) ; _ scsih_set_satl_pending ( scmd , false ) ; goto out ; } } else ioc - > build_zero_len_sge ( ioc , & mpi_request - > SGL ) ; raid_device = sas_target_priv_data - > raid_device ; if ( raid_device & & raid_device - > direct_io_enabled ) mpt3sas_setup_direct_io ( ioc , scmd , raid_device , mpi_request ) ; if ( likely ( mpi_request - > Function = = MPI2_FUNCTION_SCSI_IO_REQUEST ) ) { if ( sas_target_priv_data - > flags & MPT_TARGET_FASTPATH_IO ) { mpi_request - > IoFlags = cpu_to_le16 ( scmd - > cmd_len | MPI25_SCSIIO_IOFLAGS_FAST_PATH ) ; ioc - > put_smid_fast_path ( ioc , smid , handle ) ; } else ioc - > put_smid_scsi_io ( ioc , smid , le16_to_cpu ( mpi_request - > DevHandle ) ) ; } else ioc - > put_smid_default ( ioc , smid ) ; return 0 ; out : return SCSI_MLQUEUE_HOST_BUSY ; } / * * * _ scsih_normalize_sense - normalize descriptor and fixed format sense data * @ sense_buffer : sense data returned by target * @ data : normalized skey / asc / ascq * / static void _ scsih_normalize_sense ( char * sense_buffer , struct sense_info * data ) { if ( ( sense_buffer [ 0 ] & 0 x7F ) > = 0 x72 ) { / * descriptor format * / data - > skey = sense_buffer [ 1 ] & 0 x0F ; data - > asc = sense_buffer [ 2 ] ; data - > ascq = sense_buffer [ 3 ] ; } else { / * fixed format * / data - > skey = sense_buffer [ 2 ] & 0 x0F ; data - > asc = sense_buffer [ 12 ] ; data - > ascq = sense_buffer [ 13 ] ; } } / * * * _ scsih_scsi_ioc_info - translated non - successful SCSI_IO request * @ ioc : per adapter object * @ scmd : pointer to scsi command object * @ mpi_reply : reply mf payload returned from firmware * @ smid : ? * * scsi_status - SCSI Status code returned from target device * scsi_state - state info associated with SCSI_IO determined by ioc * ioc_status - ioc supplied status info * / static void _ scsih_scsi_ioc_info ( struct MPT3SAS_ADAPTER * ioc , struct scsi_cmnd * scmd , Mpi2SCSIIOReply_t * mpi_reply , u16 smid ) { u32 response_info ; u8 * response_bytes ; u16 ioc_status = le16_to_cpu ( mpi_reply - > IOCStatus ) & MPI2_IOCSTATUS_MASK ; u8 scsi_state = mpi_reply - > SCSIState ; u8 scsi_status = mpi_reply - > SCSIStatus ; char * desc_ioc_state = NULL ; char * desc_scsi_status = NULL ; char * desc_scsi_state = ioc - > tmp_string ; u32 log_info = le32_to_cpu ( mpi_reply - > IOCLogInfo ) ; struct _ sas_device * sas_device = NULL ; struct _ pcie_device * pcie_device = NULL ; struct scsi_target * starget = scmd - > device - > sdev_target ; struct MPT3SAS_TARGET * priv_target = starget - > hostdata ; char * device_str = NULL ; if ( ! priv_target ) return ; if ( ioc - > hide_ir_msg ) device_str = " WarpDrive " ; else device_str = " volume " ; if ( log_info = = 0 x31170000 ) return ; switch ( ioc_status ) { case MPI2_IOCSTATUS_SUCCESS : desc_ioc_state = " success " ; break ; case MPI2_IOCSTATUS_INVALID_FUNCTION : desc_ioc_state = " invalid function " ; break ; case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR : desc_ioc_state = " scsi recovered error " ; break ; case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE : desc_ioc_state = " scsi invalid dev handle " ; break ; case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE : desc_ioc_state = " scsi device not there " ; break ; case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN : desc_ioc_state = " scsi data overrun " ; break ; case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN : desc_ioc_state = " scsi data underrun " ; break ; case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR : desc_ioc_state = " scsi io data error " ; break ; case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR : desc_ioc_state = " scsi protocol error " ; break ; case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED : desc_ioc_state = " scsi task terminated " ; break ; case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH : desc_ioc_state = " scsi residual mismatch " ; break ; case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED : desc_ioc_state = " scsi task mgmt failed " ; break ; case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED : desc_ioc_state = " scsi ioc terminated " ; break ; case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED : desc_ioc_state = " scsi ext terminated " ; break ; case MPI2_IOCSTATUS_EEDP_GUARD_ERROR : desc_ioc_state = " eedp guard error " ; break ; case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR : desc_ioc_state = " eedp ref tag error " ; break ; case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR : desc_ioc_state = " eedp app tag error " ; break ; case MPI2_IOCSTATUS_INSUFFICIENT_POWER : desc_ioc_state = " insufficient power " ; break ; default : desc_ioc_state = " unknown " ; break ; } switch ( scsi_status ) { case MPI2_SCSI_STATUS_GOOD : desc_scsi_status = " good " ; break ; case MPI2_SCSI_STATUS_CHECK_CONDITION : desc_scsi_status = " check condition " ; break ; case MPI2_SCSI_STATUS_CONDITION_MET : desc_scsi_status = " condition met " ; break ; case MPI2_SCSI_STATUS_BUSY : desc_scsi_status = " busy " ; break ; case MPI2_SCSI_STATUS_INTERMEDIATE : desc_scsi_status = " intermediate " ; break ; case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET : desc_scsi_status = " intermediate condmet " ; break ; case MPI2_SCSI_STATUS_RESERVATION_CONFLICT : desc_scsi_status = " reservation conflict " ; break ; case MPI2_SCSI_STATUS_COMMAND_TERMINATED : desc_scsi_status = " command terminated " ; break ; case MPI2_SCSI_STATUS_TASK_SET_FULL : desc_scsi_status = " task set full " ; break ; case MPI2_SCSI_STATUS_ACA_ACTIVE : desc_scsi_status = " aca active " ; break ; case MPI2_SCSI_STATUS_TASK_ABORTED : desc_scsi_status = " task aborted " ; break ; default : desc_scsi_status = " unknown " ; break ; } desc_scsi_state [ 0 ] = ' \ 0 ' ; if ( ! scsi_state ) desc_scsi_state = " " ; if ( scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID ) strcat ( desc_scsi_state , " response info " ) ; if ( scsi_state & MPI2_SCSI_STATE_TERMINATED ) strcat ( desc_scsi_state , " state terminated " ) ; if ( scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS ) strcat ( desc_scsi_state , " no status " ) ; if ( scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED ) strcat ( desc_scsi_state , " autosense failed " ) ; if ( scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID ) strcat ( desc_scsi_state , " autosense valid " ) ; scsi_print_command ( scmd ) ; if ( priv_target - > flags & MPT_TARGET_FLAGS_VOLUME ) { ioc_warn ( ioc , " \ t % s wwid ( 0 x % 016 llx ) \ n " , device_str , ( u64 ) priv_target - > sas_address ) ; } else if ( priv_target - > flags & MPT_TARGET_FLAGS_PCIE_DEVICE ) { pcie_device = mpt3sas_get_pdev_from_target ( ioc , priv_target ) ; if ( pcie_device ) { ioc_info ( ioc , " \ twwid ( 0 x % 016 llx ) , port ( % d ) \ n " , ( u64 ) pcie_device - > wwid , pcie_device - > port_num ) ; if ( pcie_device - > enclosure_handle ! = 0 ) ioc_info ( ioc , " \ tenclosure logical id ( 0 x % 016 llx ) , slot ( % d ) \ n " , ( u64 ) pcie_device - > enclosure_logical_id , pcie_device - > slot ) ; if ( pcie_device - > connector_name [ 0 ] ) ioc_info ( ioc , " \ tenclosure level ( 0 x % 04 x ) , connector name ( % s ) \ n " , pcie_device - > enclosure_level , pcie_device - > connector_name ) ; pcie_device_put ( pcie_device ) ; } } else { sas_device = mpt3sas_get_sdev_from_target ( ioc , priv_target ) ; if ( sas_device ) { ioc_warn ( ioc , " \ tsas_address ( 0 x % 016 llx ) , phy ( % d ) \ n " , ( u64 ) sas_device - > sas_address , sas_device - > phy ) ; _ scsih_display_enclosure_chassis_info ( ioc , sas_device , NULL , NULL ) ; sas_device_put ( sas_device ) ; } } ioc_warn ( ioc , " \ thandle ( 0 x % 04 x ) , ioc_status ( % s ) ( 0 x % 04 x ) , smid ( % d ) \ n " , le16_to_cpu ( mpi_reply - > DevHandle ) , desc_ioc_state , ioc_status , smid ) ; ioc_warn ( ioc , " \ trequest_len ( % d ) , underflow ( % d ) , resid ( % d ) \ n " , scsi_bufflen ( scmd ) , scmd - > underflow , scsi_get_resid ( scmd ) ) ; ioc_warn ( ioc , " \ ttag ( % d ) , transfer_count ( % d ) , sc - > result ( 0 x % 08 x ) \ n " , le16_to_cpu ( mpi_reply - > TaskTag ) , le32_to_cpu ( mpi_reply - > TransferCount ) , scmd - > result ) ; ioc_warn ( ioc , " \ tscsi_status ( % s ) ( 0 x % 02 x ) , scsi_state ( % s ) ( 0 x % 02 x ) \ n " , desc_scsi_status , scsi_status , desc_scsi_state , scsi_state ) ; if ( scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID ) { struct sense_info data ; _ scsih_normalize_sense ( scmd - > sense_buffer , & data ) ; ioc_warn ( ioc , " \ t [ sense_key , asc , ascq ] : [ 0 x % 02 x , 0 x % 02 x , 0 x % 02 x ] , count ( % d ) \ n " , data . skey , data . asc , data . ascq , le32_to_cpu ( mpi_reply - > SenseCount ) ) ; } if ( scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID ) { response_info = le32_to_cpu ( mpi_reply - > ResponseInfo ) ; response_bytes = ( u8 * ) & response_info ; _ scsih_response_code ( ioc , response_bytes [ 0 ] ) ; } } / * * * _ scsih_turn_on_pfa_led - illuminate PFA LED * @ ioc : per adapter object * @ handle : device handle * Context : process * / static void _ scsih_turn_on_pfa_led ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { Mpi2SepReply_t mpi_reply ; Mpi2SepRequest_t mpi_request ; struct _ sas_device * sas_device ; sas_device = mpt3sas_get_sdev_by_handle ( ioc , handle ) ; if ( ! sas_device ) return ; memset ( & mpi_request , 0 , sizeof ( Mpi2SepRequest_t ) ) ; mpi_request . Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR ; mpi_request . Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS ; mpi_request . SlotStatus = cpu_to_le32 ( MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT ) ; mpi_request . DevHandle = cpu_to_le16 ( handle ) ; mpi_request . Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS ; if ( ( mpt3sas_base_scsi_enclosure_processor ( ioc , & mpi_reply , & mpi_request ) ) ! = 0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } sas_device - > pfa_led_on = 1 ; if ( mpi_reply . IOCStatus | | mpi_reply . IOCLogInfo ) { dewtprintk ( ioc , ioc_info ( ioc , " enclosure_processor : ioc_status ( 0 x % 04 x ) , loginfo ( 0 x % 08 x ) \ n " , le16_to_cpu ( mpi_reply . IOCStatus ) , le32_to_cpu ( mpi_reply . IOCLogInfo ) ) ) ; goto out ; } out : sas_device_put ( sas_device ) ; } / * * * _ scsih_turn_off_pfa_led - turn off Fault LED * @ ioc : per adapter object * @ sas_device : sas device whose PFA LED has to turned off * Context : process * / static void _ scsih_turn_off_pfa_led ( struct MPT3SAS_ADAPTER * ioc , struct _ sas_device * sas_device ) { Mpi2SepReply_t mpi_reply ; Mpi2SepRequest_t mpi_request ; memset ( & mpi_request , 0 , sizeof ( Mpi2SepRequest_t ) ) ; mpi_request . Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR ; mpi_request . Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS ; mpi_request . SlotStatus = 0 ; mpi_request . Slot = cpu_to_le16 ( sas_device - > slot ) ; mpi_request . DevHandle = 0 ; mpi_request . EnclosureHandle = cpu_to_le16 ( sas_device - > enclosure_handle ) ; mpi_request . Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS ; if ( ( mpt3sas_base_scsi_enclosure_processor ( ioc , & mpi_reply , & mpi_request ) ) ! = 0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } if ( mpi_reply . IOCStatus | | mpi_reply . IOCLogInfo ) { dewtprintk ( ioc , ioc_info ( ioc , " enclosure_processor : ioc_status ( 0 x % 04 x ) , loginfo ( 0 x % 08 x ) \ n " , le16_to_cpu ( mpi_reply . IOCStatus ) , le32_to_cpu ( mpi_reply . IOCLogInfo ) ) ) ; return ; } } / * * * _ scsih_send_event_to_turn_on_pfa_led - fire delayed event * @ ioc : per adapter object * @ handle : device handle * Context : interrupt . * / static void _ scsih_send_event_to_turn_on_pfa_led ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { struct fw_event_work * fw_event ; fw_event = alloc_fw_event_work ( 0 ) ; if ( ! fw_event ) return ; fw_event - > event = MPT3SAS_TURN_ON_PFA_LED ; fw_event - > device_handle = handle ; fw_event - > ioc = ioc ; _ scsih_fw_event_add ( ioc , fw_event ) ; fw_event_work_put ( fw_event ) ; } / * * * _ scsih_smart_predicted_fault - process smart errors * @ ioc : per adapter object * @ handle : device handle * Context : interrupt . * / static void _ scsih_smart_predicted_fault ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { struct scsi_target * starget ; struct MPT3SAS_TARGET * sas_target_priv_data ; Mpi2EventNotificationReply_t * event_reply ; Mpi2EventDataSasDeviceStatusChange_t * event_data ; struct _ sas_device * sas_device ; ssize_t sz ; unsigned long flags ; / * only handle non - raid devices * / spin_lock_irqsave ( & ioc - > sas_device_lock , flags ) ; sas_device = _ _ mpt3sas_get_sdev_by_handle ( ioc , handle ) ; if ( ! sas_device ) goto out_unlock ; starget = sas_device - > starget ; sas_target_priv_data = starget - > hostdata ; if ( ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_RAID_COMPONENT ) | | ( ( sas_target_priv_data - > flags & MPT_TARGET_FLAGS_VOLUME ) ) ) goto out_unlock ; _ scsih_display_enclosure_chassis_info ( NULL , sas_device , NULL , starget ) ; spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; if ( ioc - > pdev - > subsystem_vendor = = PCI_VENDOR_ID_IBM ) _ scsih_send_event_to_turn_on_pfa_led ( ioc , handle ) ; / * insert into event log * / sz = offsetof ( Mpi2EventNotificationReply_t , EventData ) + sizeof ( Mpi2EventDataSasDeviceStatusChange_t ) ; event_reply = kzalloc ( sz , GFP_ATOMIC ) ; if ( ! event_reply ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } event_reply - > Function = MPI2_FUNCTION_EVENT_NOTIFICATION ; event_reply - > Event = cpu_to_le16 ( MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE ) ; event_reply - > MsgLength = sz / 4 ; event_reply - > EventDataLength = cpu_to_le16 ( sizeof ( Mpi2EventDataSasDeviceStatusChange_t ) / 4 ) ; event_data = ( Mpi2EventDataSasDeviceStatusChange_t * ) event_reply - > EventData ; event_data - > ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA ; event_data - > ASC = 0 x5D ; event_data - > DevHandle = cpu_to_le16 ( handle ) ; event_data - > SASAddress = cpu_to_le64 ( sas_target_priv_data - > sas_address ) ; mpt3sas_ctl_add_to_event_log ( ioc , event_reply ) ; kfree ( event_reply ) ; out : if ( sas_device ) sas_device_put ( sas_device ) ; return ; out_unlock : spin_unlock_irqrestore ( & ioc - > sas_device_lock , flags ) ; goto out ; } / * * * _ scsih_io_done - scsi request callback * @ ioc : per adapter object * @ smid : system request message index * @ msix_index : MSIX table index supplied by the OS * @ reply : reply message frame ( lower 32 bit addr ) * * Callback handler when using _ scsih_qcmd . * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / static u8 _ scsih_io_done ( struct MPT3SAS_ADAPTER * ioc , u16 smid , u8 msix_index , u32 reply ) { Mpi25SCSIIORequest_t * mpi_request ; Mpi2SCSIIOReply_t * mpi_reply ; struct scsi_cmnd * scmd ; struct scsiio_tracker * st ; u16 ioc_status ; u32 xfer_cnt ; u8 scsi_state ; u8 scsi_status ; u32 log_info ; struct MPT3SAS_DEVICE * sas_device_priv_data ; u32 response_code = 0 ; mpi_reply = mpt3sas_base_get_reply_virt_addr ( ioc , reply ) ; scmd = mpt3sas_scsih_scsi_lookup_get ( ioc , smid ) ; if ( scmd = = NULL ) return 1 ; _ scsih_set_satl_pending ( scmd , false ) ; mpi_request = mpt3sas_base_get_msg_frame ( ioc , smid ) ; if ( mpi_reply = = NULL ) { scmd - > result = DID_OK < < 16 ; goto out ; } sas_device_priv_data = scmd - > device - > hostdata ; if ( ! sas_device_priv_data | | ! sas_device_priv_data - > sas_target | | sas_device_priv_data - > sas_target - > deleted ) { scmd - > result = DID_NO_CONNECT < < 16 ; goto out ; } ioc_status = le16_to_cpu ( mpi_reply - > IOCStatus ) ; / * * WARPDRIVE : If direct_io is set then it is directIO , * the failed direct I / O should be redirected to volume * / st = scsi_cmd_priv ( scmd ) ; if ( st - > direct_io & & ( ( ioc_status & MPI2_IOCSTATUS_MASK ) ! = MPI2_IOCSTATUS_SCSI_TASK_TERMINATED ) ) { st - > direct_io = 0 ; st - > scmd = scmd ; memcpy ( mpi_request - > CDB . CDB32 , scmd - > cmnd , scmd - > cmd_len ) ; mpi_request - > DevHandle = cpu_to_le16 ( sas_device_priv_data - > sas_target - > handle ) ; ioc - > put_smid_scsi_io ( ioc , smid , sas_device_priv_data - > sas_target - > handle ) ; return 0 ; } / * turning off TLR * / scsi_state = mpi_reply - > SCSIState ; if ( scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID ) response_code = le32_to_cpu ( mpi_reply - > ResponseInfo ) & 0 xFF ; if ( ! sas_device_priv_data - > tlr_snoop_check ) { sas_device_priv_data - > tlr_snoop_check + + ; if ( ( ! ioc - > is_warpdrive & & ! scsih_is_raid ( & scmd - > device - > sdev_gendev ) & & ! scsih_is_nvme ( & scmd - > device - > sdev_gendev ) ) & & sas_is_tlr_enabled ( scmd - > device ) & & response_code = = MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ) { sas_disable_tlr ( scmd - > device ) ; sdev_printk ( KERN_INFO , scmd - > device , " TLR disabled \ n " ) ; } } xfer_cnt = le32_to_cpu ( mpi_reply - > TransferCount ) ; scsi_set_resid ( scmd , scsi_bufflen ( scmd ) - xfer_cnt ) ; if ( ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE ) log_info = le32_to_cpu ( mpi_reply - > IOCLogInfo ) ; else log_info = 0 ; ioc_status & = MPI2_IOCSTATUS_MASK ; scsi_status = mpi_reply - > SCSIStatus ; if ( ioc_status = = MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN & & xfer_cnt = = 0 & &an> ( scsi_status = = MPI2_SCSI_STATUS_BUSY | | scsi_status = = MPI2_SCSI_STATUS_RESERVATION_CONFLICT | | scsi_status = = MPI2_SCSI_STATUS_TASK_SET_FULL ) ) { ioc_status = MPI2_IOCSTATUS_SUCCESS ; } if ( scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID ) { struct sense_info data ; const void * sense_data = mpt3sas_base_get_sense_buffer ( ioc , smid ) ; u32 sz = min_t ( u32 , SCSI_SENSE_BUFFERSIZE , le32_to_cpu ( mpi_reply - > SenseCount ) ) ; memcpy ( scmd - > sense_buffer , sense_data , sz ) ; _ scsih_normalize_sense ( scmd - > sense_buffer , & data ) ; / * failure prediction threshold exceeded * / if ( data . asc = = 0 x5D ) _ scsih_smart_predicted_fault ( ioc , le16_to_cpu ( mpi_reply - > DevHandle ) ) ; mpt3sas_trigger_scsi ( ioc , data . skey , data . asc , data . ascq ) ; if ( ( ioc - > logging_level & MPT_DEBUG_REPLY ) & & ( ( scmd - > sense_buffer [ 2 ] = = UNIT_ATTENTION ) | | ( scmd - > sense_buffer [ 2 ] = = MEDIUM_ERROR ) | | ( scmd - > sense_buffer [ 2 ] = = HARDWARE_ERROR ) ) ) _ scsih_scsi_ioc_info ( ioc , scmd , mpi_reply , smid ) ; } switch ( ioc_status ) { case MPI2_IOCSTATUS_BUSY : case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES : scmd - > result = SAM_STAT_BUSY ; break ; case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE : scmd - > result = DID_NO_CONNECT < < 16 ; break ; case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED : if ( sas_device_priv_data - > block ) { scmd - > result = DID_TRANSPORT_DISRUPTED < < 16 ; goto out ; } if ( log_info = = IOC_LOGINFO_SATA_NCQ_FAIL_AFTER_ERR ) { / * * This is a ATA NCQ command aborted due to another NCQ * command failure . We must retry this command * immediately but without incrementing its retry * counter . * / WARN_ON_ONCE ( xfer_cnt ! = 0 ) ; scmd - > result = DID_IMM_RETRY < < 16 ; break ; } if ( log_info = = 0 x31110630 ) { if ( scmd - > retries > 2 ) { scmd - > result = DID_NO_CONNECT < < 16 ; scsi_device_set_state ( scmd - > device , SDEV_OFFLINE ) ; } else { scmd - > result = DID_SOFT_ERROR < < 16 ; scmd - > device - > expecting_cc_ua = 1 ; } break ; } else if ( log_info = = VIRTUAL_IO_FAILED_RETRY ) { scmd - > result = DID_RESET < < 16 ; break ; } else if ( ( scmd - > device - > channel = = RAID_CHANNEL ) & & ( scsi_state = = ( MPI2_SCSI_STATE_TERMINATED | MPI2_SCSI_STATE_NO_SCSI_STATUS ) ) ) { scmd - > result = DID_RESET < < 16 ; break ; } scmd - > result = DID_SOFT_ERROR < < 16 ; break ; case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED : case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED : scmd - > result = DID_RESET < < 16 ; break ; case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH : if ( ( xfer_cnt = = 0 ) | | ( scmd - > underflow > xfer_cnt ) ) scmd - > result = DID_SOFT_ERROR < < 16 ; else scmd - > result = ( DID_OK < < 16 ) | scsi_status ; break ; case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN : scmd - > result = ( DID_OK < < 16 ) | scsi_status ; if ( ( scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID ) ) break ; if ( xfer_cnt < scmd - > underflow ) { if ( scsi_status = = SAM_STAT_BUSY ) scmd - > result = SAM_STAT_BUSY ; else scmd - > result = DID_SOFT_ERROR < < 16 ; } else if ( scsi_state & ( MPI2_SCSI_STATE_AUTOSENSE_FAILED | MPI2_SCSI_STATE_NO_SCSI_STATUS ) ) scmd - > result = DID_SOFT_ERROR < < 16 ; else if ( scsi_state & MPI2_SCSI_STATE_TERMINATED ) scmd - > result = DID_RESET < < 16 ; else if ( ! xfer_cnt & & scmd - > cmnd [ 0 ] = = REPORT_LUNS ) { mpi_reply - > SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID ; mpi_reply - > SCSIStatus = SAM_STAT_CHECK_CONDITION ; scsi_build_sense ( scmd , 0 , ILLEGAL_REQUEST , 0 x20 , 0 ) ; } break ; case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN : scsi_set_resid ( scmd , 0 ) ; fallthrough ; case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR : case MPI2_IOCSTATUS_SUCCESS : scmd - > result = ( DID_OK < < 16 ) | scsi_status ; if ( response_code = = MPI2_SCSITASKMGMT_RSP_INVALID_FRAME | | ( scsi_state & ( MPI2_SCSI_STATE_AUTOSENSE_FAILED | MPI2_SCSI_STATE_NO_SCSI_STATUS ) ) ) scmd - > result = DID_SOFT_ERROR < < 16 ; else if ( scsi_state & MPI2_SCSI_STATE_TERMINATED ) scmd - > result = DID_RESET < < 16 ; break ; case MPI2_IOCSTATUS_EEDP_GUARD_ERROR : case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR : case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR : _ scsih_eedp_error_handling ( scmd , ioc_status ) ; break ; case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR : case MPI2_IOCSTATUS_INVALID_FUNCTION : case MPI2_IOCSTATUS_INVALID_SGL : case MPI2_IOCSTATUS_INTERNAL_ERROR : case MPI2_IOCSTATUS_INVALID_FIELD : case MPI2_IOCSTATUS_INVALID_STATE : case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR : case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED : case MPI2_IOCSTATUS_INSUFFICIENT_POWER : default : scmd - > result = DID_SOFT_ERROR < < 16 ; break ; } if ( scmd - > result & & ( ioc - > logging_level & MPT_DEBUG_REPLY ) ) _ scsih_scsi_ioc_info ( ioc , scmd , mpi_reply , smid ) ; out : scsi_dma_unmap ( scmd ) ; mpt3sas_base_free_smid ( ioc , smid ) ; scsi_done ( scmd ) ; return 0 ; } / * * * _ scsih_update_vphys_after_reset - update the Port ' s * vphys_list after reset * @ ioc : per adapter object * * Returns nothing . * / static void _ scsih_update_vphys_after_reset ( struct MPT3SAS_ADAPTER * ioc ) { u16 sz , ioc_status ; int i ; Mpi2ConfigReply_t mpi_reply ; Mpi2SasIOUnitPage0_t * sas_iounit_pg0 = NULL ; u16 attached_handle ; u64 attached_sas_addr ; u8 found = 0 , port_id ; Mpi2SasPhyPage0_t phy_pg0 ; struct hba_port * port , * port_next , * mport ; struct virtual_phy * vphy , * vphy_next ; struct _ sas_device * sas_device ; / * * Mark all the vphys objects as dirty . * / list_for_each_entry_safe ( port , port_next , & ioc - > port_table_list , list ) { if ( ! port - > vphys_mask ) continue ; list_for_each_entry_safe ( vphy , vphy_next , & port - > vphys_list , list ) { vphy - > flags | = MPT_VPHY_FLAG_DIRTY_PHY ; } } / * * Read SASIOUnitPage0 to get each HBA Phy ' s data . * / sz = struct_size ( sas_iounit_pg0 , PhyData , ioc - > sas_hba . num_phys ) ; sas_iounit_pg0 = kzalloc ( sz , GFP_KERNEL ) ; if ( ! sas_iounit_pg0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } if ( ( mpt3sas_config_get_sas_iounit_pg0 ( ioc , & mpi_reply , sas_iounit_pg0 , sz ) ) ! = 0 ) goto out ; ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) goto out ; / * * Loop over each HBA Phy . * / for ( i = 0 ; i < ioc - > sas_hba . num_phys ; i + + ) { / * * Check whether Phy ' s Negotiation Link Rate is > 1 . 5 G or not . * / if ( ( sas_iounit_pg0 - > PhyData [ i ] . NegotiatedLinkRate > > 4 ) < MPI2_SAS_NEG_LINK_RATE_1_5 ) continue ; / * * Check whether Phy is connected to SEP device or not , * if it is SEP device then read the Phy ' s SASPHYPage0 data to * determine whether Phy is a virtual Phy or not . if it is * virtual phy then it is conformed that the attached remote * device is a HBA ' s vSES device . * / if ( ! ( le32_to_cpu ( sas_iounit_pg0 - > PhyData [ i ] . ControllerPhyDeviceInfo ) & MPI2_SAS_DEVICE_INFO_SEP ) ) continue ; if ( ( mpt3sas_config_get_phy_pg0 ( ioc , & mpi_reply , & phy_pg0 , i ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; continue ; } if ( ! ( le32_to_cpu ( phy_pg0 . PhyInfo ) & MPI2_SAS_PHYINFO_VIRTUAL_PHY ) ) continue ; / * * Get the vSES device ' s SAS Address . * / attached_handle = le16_to_cpu ( sas_iounit_pg0 - > PhyData [ i ] . AttachedDevHandle ) ; if ( _ scsih_get_sas_address ( ioc , attached_handle , & attached_sas_addr ) ! = 0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; continue ; } found = 0 ; port = port_next = NULL ; / * * Loop over each virtual_phy object from * each port ' s vphys_list . * / list_for_each_entry_safe ( port , port_next , & ioc - > port_table_list , list ) { if ( ! port - > vphys_mask ) continue ; list_for_each_entry_safe ( vphy , vphy_next , & port - > vphys_list , list ) { / * * Continue with next virtual_phy object * if the object is not marked as dirty . * / if ( ! ( vphy - > flags & MPT_VPHY_FLAG_DIRTY_PHY ) ) continue ; / * * Continue with next virtual_phy object * if the object ' s SAS Address is not equals * to current Phy ' s vSES device SAS Address . * / if ( vphy - > sas_address ! = attached_sas_addr ) continue ; / * * Enable current Phy number bit in object ' s * phy_mask field . * / if ( ! ( vphy - > phy_mask & ( 1 < < i ) ) ) vphy - > phy_mask = ( 1 < < i ) ; / * * Get hba_port object from hba_port table * corresponding to current phy ' s Port ID . * if there is no hba_port object corresponding * to Phy ' s Port ID then create a new hba_port * object & add to hba_port table . * / port_id = sas_iounit_pg0 - > PhyData [ i ] . Port ; mport = mpt3sas_get_port_by_id ( ioc , port_id , 1 ) ; if ( ! mport ) { mport = kzalloc ( sizeof ( struct hba_port ) , GFP_KERNEL ) ; if ( ! mport ) break ; mport - > port_id = port_id ; ioc_info ( ioc , " % s : hba_port entry : % p , port : % d is added to hba_port list \ n " , _ _ func__ , mport , mport - > port_id ) ; list_add_tail ( & mport - > list , & ioc - > port_table_list ) ; } / * * If mport & port pointers are not pointing to * same hba_port object then it means that vSES * device ' s Port ID got changed after reset and * hence move current virtual_phy object from * port ' s vphys_list to mport ' s vphys_list . * / if ( port ! = mport ) { if ( ! mport - > vphys_mask ) INIT_LIST_HEAD ( & mport - > vphys_list ) ; mport - > vphys_mask | = ( 1 < < i ) ; port - > vphys_mask & = ~ ( 1 < < i ) ; list_move ( & vphy - > list , & mport - > vphys_list ) ; sas_device = mpt3sas_get_sdev_by_addr ( ioc , attached_sas_addr , port ) ; if ( sas_device ) sas_device - > port = mport ; } / * * Earlier while updating the hba_port table , * it is determined that there is no other * direct attached device with mport ' s Port ID , * Hence mport was marked as dirty . Only vSES * device has this Port ID , so unmark the mport * as dirt . * / if ( mport - > flags & HBA_PORT_FLAG_DIRTY_PORT ) { mport - > sas_address = 0 ; mport - > phy_mask = 0 ; mport - > flags & = ~ HBA_PORT_FLAG_DIRTY_PORT ; } / * * Unmark current virtual_phy object as dirty . * / vphy - > flags & = ~ MPT_VPHY_FLAG_DIRTY_PHY ; found = 1 ; break ; } if ( found ) break ; } } out : kfree ( sas_iounit_pg0 ) ; } / * * * _ scsih_get_port_table_after_reset - Construct temporary port table * @ ioc : per adapter object * @ port_table : address where port table needs to be constructed * * return number of HBA port entries available after reset . * / static int _ scsih_get_port_table_after_reset ( struct MPT3SAS_ADAPTER * ioc , struct hba_port * port_table ) { u16 sz , ioc_status ; int i , j ; Mpi2ConfigReply_t mpi_reply ; Mpi2SasIOUnitPage0_t * sas_iounit_pg0 = NULL ; u16 attached_handle ; u64 attached_sas_addr ; u8 found = 0 , port_count = 0 , port_id ; sz = struct_size ( sas_iounit_pg0 , PhyData , ioc - > sas_hba . num_phys ) ; sas_iounit_pg0 = kzalloc ( sz , GFP_KERNEL ) ; if ( ! sas_iounit_pg0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return port_count ; } if ( ( mpt3sas_config_get_sas_iounit_pg0 ( ioc , & mpi_reply , sas_iounit_pg0 , sz ) ) ! = 0 ) goto out ; ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) goto out ; for ( i = 0 ; i < ioc - > sas_hba . num_phys ; i + + ) { found = 0 ; if ( ( sas_iounit_pg0 - > PhyData [ i ] . NegotiatedLinkRate > > 4 ) < MPI2_SAS_NEG_LINK_RATE_1_5 ) continue ; attached_handle = le16_to_cpu ( sas_iounit_pg0 - > PhyData [ i ] . AttachedDevHandle ) ; if ( _ scsih_get_sas_address ( ioc , attached_handle , & attached_sas_addr ) ! = 0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; continue ; } for ( j = 0 ; j < port_count ; j + + ) { port_id = sas_iounit_pg0 - > PhyData [ i ] . Port ; if ( port_table [ j ] . port_id = = port_id & & port_table [ j ] . sas_address = = attached_sas_addr ) { port_table [ j ] . phy_mask | = ( 1 < < i ) ; found = 1 ; break ; } } if ( found ) continue ; port_id = sas_iounit_pg0 - > PhyData [ i ] . Port ; port_table [ port_count ] . port_id = port_id ; port_table [ port_count ] . phy_mask = ( 1 < < i ) ; port_table [ port_count ] . sas_address = attached_sas_addr ; port_count + + ; } out : kfree ( sas_iounit_pg0 ) ; return port_count ; } enum hba_port_matched_codes { NOT_MATCHED = 0 , MATCHED_WITH_ADDR_AND_PHYMASK , MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT , MATCHED_WITH_ADDR_AND_SUBPHYMASK , MATCHED_WITH_ADDR , } ; / * * * _ scsih_look_and_get_matched_port_entry - Get matched hba port entry * from HBA port table * @ ioc : per adapter object * @ port_entry : hba port entry from temporary port table which needs to be * searched for matched entry in the HBA port table * @ matched_port_entry : save matched hba port entry here * @ count : count of matched entries * * return type of matched entry found . * / static enum hba_port_matched_codes _ scsih_look_and_get_matched_port_entry ( struct MPT3SAS_ADAPTER * ioc , struct hba_port * port_entry , struct hba_port * * matched_port_entry , int * count ) { struct hba_port * port_table_entry , * matched_port = NULL ; enum hba_port_matched_codes matched_code = NOT_MATCHED ; int lcount = 0 ; * matched_port_entry = NULL ; list_for_each_entry ( port_table_entry , & ioc - > port_table_list , list ) { if ( ! ( port_table_entry - > flags & HBA_PORT_FLAG_DIRTY_PORT ) ) continue ; if ( ( port_table_entry - > sas_address = = port_entry - > sas_address ) & & ( port_table_entry - > phy_mask = = port_entry - > phy_mask ) ) { matched_code = MATCHED_WITH_ADDR_AND_PHYMASK ; matched_port = port_table_entry ; break ; } if ( ( port_table_entry - > sas_address = = port_entry - > sas_address ) & & ( port_table_entry - > phy_mask & port_entry - > phy_mask ) & & ( port_table_entry - > port_id = = port_entry - > port_id ) ) { matched_code = MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT ; matched_port = port_table_entry ; continue ; } if ( ( port_table_entry - > sas_address = = port_entry - > sas_address ) & & ( port_table_entry - > phy_mask & port_entry - > phy_mask ) ) { if ( matched_code = = MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT ) continue ; matched_code = MATCHED_WITH_ADDR_AND_SUBPHYMASK ; matched_port = port_table_entry ; continue ; } if ( port_table_entry - > sas_address = = port_entry - > sas_address ) { if ( matched_code = = MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT ) continue ; if ( matched_code = = MATCHED_WITH_ADDR_AND_SUBPHYMASK ) continue ; matched_code = MATCHED_WITH_ADDR ; matched_port = port_table_entry ; lcount + + ; } } * matched_port_entry = matched_port ; if ( matched_code = = MATCHED_WITH_ADDR ) * count = lcount ; return matched_code ; } / * * * _ scsih_del_phy_part_of_anther_port - remove phy if it * is a part of anther port * @ ioc : per adapter object * @ port_table : port table after reset * @ index : hba port entry index * @ port_count : number of ports available after host reset * @ offset : HBA phy bit offset * * / static void _ scsih_del_phy_part_of_anther_port ( struct MPT3SAS_ADAPTER * ioc , struct hba_port * port_table , int index , u8 port_count , int offset ) { struct _ sas_node * sas_node = & ioc - > sas_hba ; u32 i , found = 0 ; for ( i = 0 ; i < port_count ; i + + ) { if ( i = = index ) continue ; if ( port_table [ i ] . phy_mask & ( 1 < < offset ) ) { mpt3sas_transport_del_phy_from_an_existing_port ( ioc , sas_node , & sas_node - > phy [ offset ] ) ; found = 1 ; break ; } } if ( ! found ) port_table [ index ] . phy_mask | = ( 1 < < offset ) ; } / * * * _ scsih_add_or_del_phys_from_existing_port - add / remove phy to / from * right port * @ ioc : per adapter object * @ hba_port_entry : hba port table entry * @ port_table : temporary port table * @ index : hba port entry index * @ port_count : number of ports available after host reset * * / static void _ scsih_add_or_del_phys_from_existing_port ( struct MPT3SAS_ADAPTER * ioc , struct hba_port * hba_port_entry , struct hba_port * port_table , int index , int port_count ) { u32 phy_mask , offset = 0 ; struct _ sas_node * sas_node = & ioc - > sas_hba ; phy_mask = hba_port_entry - > phy_mask ^ port_table [ index ] . phy_mask ; for ( offset = 0 ; offset < ioc - > sas_hba . num_phys ; offset + + ) { if ( phy_mask & ( 1 < < offset ) ) { if ( ! ( port_table [ index ] . phy_mask & ( 1 < < offset ) ) ) { _ scsih_del_phy_part_of_anther_port ( ioc , port_table , index , port_count , offset ) ; continue ; } if ( sas_node - > phy [ offset ] . phy_belongs_to_port ) mpt3sas_transport_del_phy_from_an_existing_port ( ioc , sas_node , & sas_node - > phy [ offset ] ) ; mpt3sas_transport_add_phy_to_an_existing_port ( ioc , sas_node , & sas_node - > phy [ offset ] , hba_port_entry - > sas_address , hba_port_entry ) ; } } } / * * * _ scsih_del_dirty_vphy - delete virtual_phy objects marked as dirty . * @ ioc : per adapter object * * Returns nothing . * / static void _ scsih_del_dirty_vphy ( struct MPT3SAS_ADAPTER * ioc ) { struct hba_port * port , * port_next ; struct virtual_phy * vphy , * vphy_next ; list_for_each_entry_safe ( port , port_next , & ioc - > port_table_list , list ) { if ( ! port - > vphys_mask ) continue ; list_for_each_entry_safe ( vphy , vphy_next , & port - > vphys_list , list ) { if ( vphy - > flags & MPT_VPHY_FLAG_DIRTY_PHY ) { drsprintk ( ioc , ioc_info ( ioc , " Deleting vphy % p entry from port id : % d \ t , Phy_mask 0 x % 08 x \ n " , vphy , port - > port_id , vphy - > phy_mask ) ) ; port - > vphys_mask & = ~ vphy - > phy_mask ; list_del ( & vphy - > list ) ; kfree ( vphy ) ; } } if ( ! port - > vphys_mask & & ! port - > sas_address ) port - > flags | = HBA_PORT_FLAG_DIRTY_PORT ; } } / * * * _ scsih_del_dirty_port_entries - delete dirty port entries from port list * after host reset * @ ioc : per adapter object * * / static void _ scsih_del_dirty_port_entries ( struct MPT3SAS_ADAPTER * ioc ) { struct hba_port * port , * port_next ; list_for_each_entry_safe ( port , port_next , & ioc - > port_table_list , list ) { if ( ! ( port - > flags & HBA_PORT_FLAG_DIRTY_PORT ) | | port - > flags & HBA_PORT_FLAG_NEW_PORT ) continue ; drsprintk ( ioc , ioc_info ( ioc , " Deleting port table entry % p having Port : % d \ t Phy_mask 0 x % 08 x \ n " , port , port - > port_id , port - > phy_mask ) ) ; list_del ( & port - > list ) ; kfree ( port ) ; } } / * * * _ scsih_sas_port_refresh - Update HBA port table after host reset * @ ioc : per adapter object * / static void _ scsih_sas_port_refresh ( struct MPT3SAS_ADAPTER * ioc ) { u32 port_count = 0 ; struct hba_port * port_table ; struct hba_port * port_table_entry ; struct hba_port * port_entry = NULL ; int i , j , count = 0 , lcount = 0 ; int ret ; u64 sas_addr ; u8 num_phys ; drsprintk ( ioc , ioc_info ( ioc , " updating ports for sas_host ( 0 x % 016 llx ) \ n " , ( unsigned long long ) ioc - > sas_hba . sas_address ) ) ; mpt3sas_config_get_number_hba_phys ( ioc , & num_phys ) ; if ( ! num_phys ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } if ( num_phys > ioc - > sas_hba . nr_phys_allocated ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } ioc - > sas_hba . num_phys = num_phys ; port_table = kcalloc ( ioc - > sas_hba . num_phys , sizeof ( struct hba_port ) , GFP_KERNEL ) ; if ( ! port_table ) return ; port_count = _ scsih_get_port_table_after_reset ( ioc , port_table ) ; if ( ! port_count ) return ; drsprintk ( ioc , ioc_info ( ioc , " New Port table \ n " ) ) ; for ( j = 0 ; j < port_count ; j + + ) drsprintk ( ioc , ioc_info ( ioc , " Port : % d \ t Phy_mask 0 x % 08 x \ t sas_addr ( 0 x % 016 llx ) \ n " , port_table [ j ] . port_id , port_table [ j ] . phy_mask , port_table [ j ] . sas_address ) ) ; list_for_each_entry ( port_table_entry , & ioc - > port_table_list , list ) port_table_entry - > flags | = HBA_PORT_FLAG_DIRTY_PORT ; drsprintk ( ioc , ioc_info ( ioc , " Old Port table \ n " ) ) ; port_table_entry = NULL ; list_for_each_entry ( port_table_entry , & ioc - > port_table_list , list ) { drsprintk ( ioc , ioc_info ( ioc , " Port : % d \ t Phy_mask 0 x % 08 x \ t sas_addr ( 0 x % 016 llx ) \ n " , port_table_entry - > port_id , port_table_entry - > phy_mask , port_table_entry - > sas_address ) ) ; } for ( j = 0 ; j < port_count ; j + + ) { ret = _ scsih_look_and_get_matched_port_entry ( ioc , & port_table [ j ] , & port_entry , & count ) ; if ( ! port_entry ) { drsprintk ( ioc , ioc_info ( ioc , " No Matched entry for sas_addr ( 0 x % 16 llx ) , Port : % d \ n " , port_table [ j ] . sas_address , port_table [ j ] . port_id ) ) ; continue ; } switch ( ret ) { case MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT : case MATCHED_WITH_ADDR_AND_SUBPHYMASK : _ scsih_add_or_del_phys_from_existing_port ( ioc , port_entry , port_table , j , port_count ) ; break ; case MATCHED_WITH_ADDR : sas_addr = port_table [ j ] . sas_address ; for ( i = 0 ; i < port_count ; i + + ) { if ( port_table [ i ] . sas_address = = sas_addr ) lcount + + ; } if ( count > 1 | | lcount > 1 ) port_entry = NULL ; else _ scsih_add_or_del_phys_from_existing_port ( ioc , port_entry , port_table , j , port_count ) ; } if ( ! port_entry ) continue ; if ( port_entry - > port_id ! = port_table [ j ] . port_id ) port_entry - > port_id = port_table [ j ] . port_id ; port_entry - > flags & = ~ HBA_PORT_FLAG_DIRTY_PORT ; port_entry - > phy_mask = port_table [ j ] . phy_mask ; } port_table_entry = NULL ; } / * * * _ scsih_alloc_vphy - allocate virtual_phy object * @ ioc : per adapter object * @ port_id : Port ID number * @ phy_num : HBA Phy number * * Returns allocated virtual_phy object . * / static struct virtual_phy * _ scsih_alloc_vphy ( struct MPT3SAS_ADAPTER * ioc , u8 port_id , u8 phy_num ) { struct virtual_phy * vphy ; struct hba_port * port ; port = mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ; if ( ! port ) return NULL ; vphy = mpt3sas_get_vphy_by_phy ( ioc , port , phy_num ) ; if ( ! vphy ) { vphy = kzalloc ( sizeof ( struct virtual_phy ) , GFP_KERNEL ) ; if ( ! vphy ) return NULL ; if ( ! port - > vphys_mask ) INIT_LIST_HEAD ( & port - > vphys_list ) ; / * * Enable bit corresponding to HBA phy number on its * parent hba_port object ' s vphys_mask field . * / port - > vphys_mask | = ( 1 < < phy_num ) ; vphy - > phy_mask | = ( 1 < < phy_num ) ; list_add_tail ( & vphy - > list , & port - > vphys_list ) ; ioc_info ( ioc , " vphy entry : % p , port id : % d , phy : % d is added to port ' s vphys_list \ n " , vphy , port - > port_id , phy_num ) ; } return vphy ; } / * * * _ scsih_sas_host_refresh - refreshing sas host object contents * @ ioc : per adapter object * Context : user * * During port enable , fw will send topology events for every device . Its * possible that the handles may change from the previous setting , so this * code keeping handles updating if changed . * / static void _ scsih_sas_host_refresh ( struct MPT3SAS_ADAPTER * ioc ) { u16 sz ; u16 ioc_status ; int i ; Mpi2ConfigReply_t mpi_reply ; Mpi2SasIOUnitPage0_t * sas_iounit_pg0 = NULL ; u16 attached_handle ; u8 link_rate , port_id ; struct hba_port * port ; Mpi2SasPhyPage0_t phy_pg0 ; dtmprintk ( ioc , ioc_info ( ioc , " updating handles for sas_host ( 0 x % 016 llx ) \ n " , ( u64 ) ioc - > sas_hba . sas_address ) ) ; sz = struct_size ( sas_iounit_pg0 , PhyData , ioc - > sas_hba . num_phys ) ; sas_iounit_pg0 = kzalloc ( sz , GFP_KERNEL ) ; if ( ! sas_iounit_pg0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } if ( ( mpt3sas_config_get_sas_iounit_pg0 ( ioc , & mpi_reply , sas_iounit_pg0 , sz ) ) ! = 0 ) goto out ; ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) goto out ; for ( i = 0 ; i < ioc - > sas_hba . num_phys ; i + + ) { link_rate = sas_iounit_pg0 - > PhyData [ i ] . NegotiatedLinkRate > > 4 ; if ( i = = 0 ) ioc - > sas_hba . handle = le16_to_cpu ( sas_iounit_pg0 - > PhyData [ 0 ] . ControllerDevHandle ) ; port_id = sas_iounit_pg0 - > PhyData [ i ] . Port ; if ( ! ( mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ) ) { port = kzalloc ( sizeof ( struct hba_port ) , GFP_KERNEL ) ; if ( ! port ) goto out ; port - > port_id = port_id ; ioc_info ( ioc , " hba_port entry : % p , port : % d is added to hba_port list \ n " , port , port - > port_id ) ; if ( ioc - > shost_recovery ) port - > flags = HBA_PORT_FLAG_NEW_PORT ; list_add_tail ( & port - > list , & ioc - > port_table_list ) ; } / * * Check whether current Phy belongs to HBA vSES device or not . * / if ( le32_to_cpu ( sas_iounit_pg0 - > PhyData [ i ] . ControllerPhyDeviceInfo ) & MPI2_SAS_DEVICE_INFO_SEP & & ( link_rate > = MPI2_SAS_NEG_LINK_RATE_1_5 ) ) { if ( ( mpt3sas_config_get_phy_pg0 ( ioc , & mpi_reply , & phy_pg0 , i ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } if ( ! ( le32_to_cpu ( phy_pg0 . PhyInfo ) & MPI2_SAS_PHYINFO_VIRTUAL_PHY ) ) continue ; / * * Allocate a virtual_phy object for vSES device , if * this vSES device is hot added . * / if ( ! _ scsih_alloc_vphy ( ioc , port_id , i ) ) goto out ; ioc - > sas_hba . phy [ i ] . hba_vphy = 1 ; } / * * Add new HBA phys to STL if these new phys got added as part * of HBA Firmware upgrade / downgrade operation . * / if ( ! ioc - > sas_hba . phy [ i ] . phy ) { if ( ( mpt3sas_config_get_phy_pg0 ( ioc , & mpi_reply , & phy_pg0 , i ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; continue ; } ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; continue ; } ioc - > sas_hba . phy [ i ] . phy_id = i ; mpt3sas_transport_add_host_phy ( ioc , & ioc - > sas_hba . phy [ i ] , phy_pg0 , ioc - > sas_hba . parent_dev ) ; continue ; } ioc - > sas_hba . phy [ i ] . handle = ioc - > sas_hba . handle ; attached_handle = le16_to_cpu ( sas_iounit_pg0 - > PhyData [ i ] . AttachedDevHandle ) ; if ( attached_handle & & link_rate < MPI2_SAS_NEG_LINK_RATE_1_5 ) link_rate = MPI2_SAS_NEG_LINK_RATE_1_5 ; ioc - > sas_hba . phy [ i ] . port = mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ; mpt3sas_transport_update_links ( ioc , ioc - > sas_hba . sas_address , attached_handle , i , link_rate , ioc - > sas_hba . phy [ i ] . port ) ; } / * * Clear the phy details if this phy got disabled as part of * HBA Firmware upgrade / downgrade operation . * / for ( i = ioc - > sas_hba . num_phys ; i < ioc - > sas_hba . nr_phys_allocated ; i + + ) { if ( ioc - > sas_hba . phy [ i ] . phy & & ioc - > sas_hba . phy [ i ] . phy - > negotiated_linkrate > = SAS_LINK_RATE_1_5_GBPS ) mpt3sas_transport_update_links ( ioc , ioc - > sas_hba . sas_address , 0 , i , MPI2_SAS_NEG_LINK_RATE_PHY_DISABLED , NULL ) ; } out : kfree ( sas_iounit_pg0 ) ; } / * * * _ scsih_sas_host_add - create sas host object * @ ioc : per adapter object * * Creating host side data object , stored in ioc - > sas_hba * / static void _ scsih_sas_host_add ( struct MPT3SAS_ADAPTER * ioc ) { int i ; Mpi2ConfigReply_t mpi_reply ; Mpi2SasIOUnitPage0_t * sas_iounit_pg0 = NULL ; Mpi2SasIOUnitPage1_t * sas_iounit_pg1 = NULL ; Mpi2SasPhyPage0_t phy_pg0 ; Mpi2SasDevicePage0_t sas_device_pg0 ; Mpi2SasEnclosurePage0_t enclosure_pg0 ; u16 ioc_status ; u16 sz ; u8 device_missing_delay ; u8 num_phys , port_id ; struct hba_port * port ; mpt3sas_config_get_number_hba_phys ( ioc , & num_phys ) ; if ( ! num_phys ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } ioc - > sas_hba . nr_phys_allocated = max_t ( u8 , MPT_MAX_HBA_NUM_PHYS , num_phys ) ; ioc - > sas_hba . phy = kcalloc ( ioc - > sas_hba . nr_phys_allocated , sizeof ( struct _ sas_phy ) , GFP_KERNEL ) ; if ( ! ioc - > sas_hba . phy ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } ioc - > sas_hba . num_phys = num_phys ; / * sas_iounit page 0 * / sz = struct_size ( sas_iounit_pg0 , PhyData , ioc - > sas_hba . num_phys ) ; sas_iounit_pg0 = kzalloc ( sz , GFP_KERNEL ) ; if ( ! sas_iounit_pg0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return ; } if ( ( mpt3sas_config_get_sas_iounit_pg0 ( ioc , & mpi_reply , sas_iounit_pg0 , sz ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } / * sas_iounit page 1 * / sz = struct_size ( sas_iounit_pg1 , PhyData , ioc - > sas_hba . num_phys ) ; sas_iounit_pg1 = kzalloc ( sz , GFP_KERNEL ) ; if ( ! sas_iounit_pg1 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } if ( ( mpt3sas_config_get_sas_iounit_pg1 ( ioc , & mpi_reply , sas_iounit_pg1 , sz ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } ioc - > io_missing_delay = sas_iounit_pg1 - > IODeviceMissingDelay ; device_missing_delay = sas_iounit_pg1 - > ReportDeviceMissingDelay ; if ( device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16 ) ioc - > device_missing_delay = ( device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK ) * 16 ; else ioc - > device_missing_delay = device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK ; ioc - > sas_hba . parent_dev = & ioc - > shost - > shost_gendev ; for ( i = 0 ; i < ioc - > sas_hba . num_phys ; i + + ) { if ( ( mpt3sas_config_get_phy_pg0 ( ioc , & mpi_reply , & phy_pg0 , i ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } if ( i = = 0 ) ioc - > sas_hba . handle = le16_to_cpu ( sas_iounit_pg0 - > PhyData [ 0 ] . ControllerDevHandle ) ; port_id = sas_iounit_pg0 - > PhyData [ i ] . Port ; if ( ! ( mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ) ) { port = kzalloc ( sizeof ( struct hba_port ) , GFP_KERNEL ) ; if ( ! port ) goto out ; port - > port_id = port_id ; ioc_info ( ioc , " hba_port entry : % p , port : % d is added to hba_port list \ n " , port , port - > port_id ) ; list_add_tail ( & port - > list , & ioc - > port_table_list ) ; } / * * Check whether current Phy belongs to HBA vSES device or not . * / if ( ( le32_to_cpu ( phy_pg0 . PhyInfo ) & MPI2_SAS_PHYINFO_VIRTUAL_PHY ) & & ( phy_pg0 . NegotiatedLinkRate > > 4 ) > = MPI2_SAS_NEG_LINK_RATE_1_5 ) { / * * Allocate a virtual_phy object for vSES device . * / if ( ! _ scsih_alloc_vphy ( ioc , port_id , i ) ) goto out ; ioc - > sas_hba . phy [ i ] . hba_vphy = 1 ; } ioc - > sas_hba . phy [ i ] . handle = ioc - > sas_hba . handle ; ioc - > sas_hba . phy [ i ] . phy_id = i ; ioc - > sas_hba . phy [ i ] . port = mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ; mpt3sas_transport_add_host_phy ( ioc , & ioc - > sas_hba . phy [ i ] , phy_pg0 , ioc - > sas_hba . parent_dev ) ; } if ( ( mpt3sas_config_get_sas_device_pg0 ( ioc , & mpi_reply , & sas_device_pg0 , MPI2_SAS_DEVICE_PGAD_FORM_HANDLE , ioc - > sas_hba . handle ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; goto out ; } ioc - > sas_hba . enclosure_handle = le16_to_cpu ( sas_device_pg0 . EnclosureHandle ) ; ioc - > sas_hba . sas_address = le64_to_cpu ( sas_device_pg0 . SASAddress ) ; ioc_info ( ioc , " host_add : handle ( 0 x % 04 x ) , sas_addr ( 0 x % 016 llx ) , phys ( % d ) \ n " , ioc - > sas_hba . handle , ( u64 ) ioc - > sas_hba . sas_address , ioc - > sas_hba . num_phys ) ; if ( ioc - > sas_hba . enclosure_handle ) { if ( ! ( mpt3sas_config_get_enclosure_pg0 ( ioc , & mpi_reply , & enclosure_pg0 , MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE , ioc - > sas_hba . enclosure_handle ) ) ) ioc - > sas_hba . enclosure_logical_id = le64_to_cpu ( enclosure_pg0 . EnclosureLogicalID ) ; } out : kfree ( sas_iounit_pg1 ) ; kfree ( sas_iounit_pg0 ) ; } / * * * _ scsih_expander_add - creating expander object * @ ioc : per adapter object * @ handle : expander handle * * Creating expander object , stored in ioc - > sas_expander_list . * * Return : 0 for success , else error . * / static int _ scsih_expander_add ( struct MPT3SAS_ADAPTER * ioc , u16 handle ) { struct _ sas_node * sas_expander ; struct _ enclosure_node * enclosure_dev ; Mpi2ConfigReply_t mpi_reply ; Mpi2ExpanderPage0_t expander_pg0 ; Mpi2ExpanderPage1_t expander_pg1 ; u32 ioc_status ; u16 parent_handle ; u64 sas_address , sas_address_parent = 0 ; int i ; unsigned long flags ; struct _ sas_port * mpt3sas_port = NULL ; u8 port_id ; int rc = 0 ; if ( ! handle ) return - 1 ; if ( ioc - > shost_recovery | | ioc - > pci_error_recovery ) return - 1 ; if ( ( mpt3sas_config_get_expander_pg0 ( ioc , & mpi_reply , & expander_pg0 , MPI2_SAS_EXPAND_PGAD_FORM_HNDL , handle ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return - 1 ; } ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return - 1 ; } / * handle out of order topology events * / parent_handle = le16_to_cpu ( expander_pg0 . ParentDevHandle ) ; if ( _ scsih_get_sas_address ( ioc , parent_handle , & sas_address_parent ) ! = 0 ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return - 1 ; } port_id = expander_pg0 . PhysicalPort ; if ( sas_address_parent ! = ioc - > sas_hba . sas_address ) { spin_lock_irqsave ( & ioc - > sas_node_lock , flags ) ; sas_expander = mpt3sas_scsih_expander_find_by_sas_address ( ioc , sas_address_parent , mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ) ; spin_unlock_irqrestore ( & ioc - > sas_node_lock , flags ) ; if ( ! sas_expander ) { rc = _ scsih_expander_add ( ioc , parent_handle ) ; if ( rc ! = 0 ) return rc ; } } spin_lock_irqsave ( & ioc - > sas_node_lock , flags ) ; sas_address = le64_to_cpu ( expander_pg0 . SASAddress ) ; sas_expander = mpt3sas_scsih_expander_find_by_sas_address ( ioc , sas_address , mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ) ; spin_unlock_irqrestore ( & ioc - > sas_node_lock , flags ) ; if ( sas_expander ) return 0 ; sas_expander = kzalloc ( sizeof ( struct _ sas_node ) , GFP_KERNEL ) ; if ( ! sas_expander ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; return - 1 ; } sas_expander - > handle = handle ; sas_expander - > num_phys = expander_pg0 . NumPhys ; sas_expander - > sas_address_parent = sas_address_parent ; sas_expander - > sas_address = sas_address ; sas_expander - > port = mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ; if ( ! sas_expander - > port ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; rc = - 1 ; goto out_fail ; } ioc_info ( ioc , " expander_add : handle ( 0 x % 04 x ) , parent ( 0 x % 04 x ) , sas_addr ( 0 x % 016 llx ) , phys ( % d ) \ n " , handle , parent_handle , ( u64 ) sas_expander - > sas_address , sas_expander - > num_phys ) ; if ( ! sas_expander - > num_phys ) { rc = - 1 ; goto out_fail ; } sas_expander - > phy = kcalloc ( sas_expander - > num_phys , sizeof ( struct _ sas_phy ) , GFP_KERNEL ) ; if ( ! sas_expander - > phy ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; rc = - 1 ; goto out_fail ; } INIT_LIST_HEAD ( & sas_expander - > sas_port_list ) ; mpt3sas_port = mpt3sas_transport_port_add ( ioc , handle , sas_address_parent , sas_expander - > port ) ; if ( ! mpt3sas_port ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; rc = - 1 ; goto out_fail ; } sas_expander - > parent_dev = & mpt3sas_port - > rphy - > dev ; sas_expander - > rphy = mpt3sas_port - > rphy ; for ( i = 0 ; i < sas_expander - > num_phys ; i + + ) { if ( ( mpt3sas_config_get_expander_pg1 ( ioc , & mpi_reply , & expander_pg1 , i , handle ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; rc = - 1 ; goto out_fail ; } sas_expander - > phy [ i ] . handle = handle ; sas_expander - > phy [ i ] . phy_id = i ; sas_expander - > phy [ i ] . port = mpt3sas_get_port_by_id ( ioc , port_id , 0 ) ; if ( ( mpt3sas_transport_add_expander_phy ( ioc , & sas_expander - > phy [ i ] , expander_pg1 , sas_expander - > parent_dev ) ) ) { ioc_err ( ioc , " failure at % s : % d / % s ( ) ! \ n " , _ _ FILE__ , _ _ LINE__ , _ _ func__ ) ; rc = - 1 ; goto out_fail ; } } if ( sas_expander - > enclosure_handle ) { enclosure_dev = mpt3sas_scsih_enclosure_find_by_handle ( ioc , sas_expander - > enclosure_handle ) ; if ( enclosure_dev ) sas_expander - > enclosure_logical_id = le64_to_cpu ( enclosure_dev - > pg0 . EnclosureLogicalID ) ; } _ scsih_expander_node_add ( ioc , sas_expander ) ; return 0 ; out_fail : if ( mpt3sas_port ) mpt3sas_transport_port_remove ( ioc , sas_expander - > sas_address , sas_address_parent , sas_expander - > port ) ; kfree ( sas_expander ) ; return rc ; } / * * * mpt3sas_expander_remove - removing expander object * @ ioc : per adapter object * @ sas_address : expander sas_address * @ port : hba port entry * / void mpt3sas_expander_remove ( struct MPT3SAS_ADAPTER * ioc , u64 sas_address , struct hba_port * port ) { struct _ sas_node * sas_expander ; unsigned long flags ; if ( ioc - > shost_recovery ) return ; if ( ! port ) return ; spin_lock_irqsave ( & ioc - > sas_node_lock , flags ) ; sas_expander = mpt3sas_scsih_expander_find_by_sas_address ( ioc , sas_address , port ) ; spin_unlock_irqrestore ( & ioc - > sas_node_lock , flags ) ; if ( sas_expander ) _ scsih_expander_node_remove ( ioc , sas_expander ) ; } / * * * _ scsih_done - internal SCSI_IO callback handler . * @ ioc : per adapter object * @ smid : system request message index * @ msix_index : MSIX table index supplied by the OS * @ reply : reply message frame ( lower 32 bit addr ) * * Callback handler when sending internal generated SCSI_IO . * The callback index passed is ` ioc - > scsih_cb_idx ` * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . * / static u8 _ scsih_done ( struct MPT3SAS_ADAPTER * ioc , u16 smid , u8 msix_index , u32 reply ) { MPI2DefaultReply_t * mpi_reply ; mpi_reply = mpt3sas_base_get_reply_virt_addr ( ioc , reply ) ; if ( ioc - > scsih_cmds . status = = MPT3_CMD_NOT_USED ) return 1 ; if ( ioc - > scsih_cmds . smid ! = smid ) return 1 ; ioc - > scsih_cmds . status | = MPT3_CMD_COMPLETE ; if ( mpi_reply ) { memcpy ( ioc - > scsih_cmds . reply , mpi_reply , mpi_reply - > MsgLength * 4 ) ; ioc - > scsih_cmds . status | = MPT3_CMD_REPLY_VALID ; } ioc - > scsih_cmds . status & = ~ MPT3_CMD_PENDING ; complete ( & ioc - > scsih_cmds . done ) ; return 1 ; } # define MPT3_MAX_LUNS ( 255 ) / * * * _ scsih_check_access_status - check access flags * @ ioc : per adapter object * @ sas_address : sas address * @ handle : sas device handle * @ access_status : errors returned during discovery of the device * * Return : 0 for success , else failure * / static u8 _ scsih_check_access_status ( struct MPT3SAS_ADAPTER * ioc , u64 sas_address , u16 handle , u8 access_status ) { u8 rc = 1 ; char * desc = NULL ; switch ( access_status ) { case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS : case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION : rc = 0 ; break ; case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED : desc = " sata capability failed " ; break ; case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT : desc = " sata affiliation conflict " ; break ; case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE : desc = " route not addressable " ; break ; case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE : desc = " smp error not addressable " ; break ; case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED : desc = " device blocked " ; break ; case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED : case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN : case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT : case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG : case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION : case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER : case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN : case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN : case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN : case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION : case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE : case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX : desc = " sata initialization failed " ; break ; default : desc = " unknown " ; break ; } if ( ! rc ) return 0 ; ioc_err ( ioc , " discovery errors ( % s ) : sas_address ( 0 x % 016 llx ) , handle ( 0 x % 04 x ) \ n " , desc , ( u64 ) sas_address , handle ) ; return rc ; } / * * * _ scsih_check_device - checking device responsiveness * @ ioc : per adapter object * @ parent_sas_address : sas address of parent expander or sas host * @ handle : attached device handle * @ phy_number : phy number * @ link_rate : new link rate * / static void _ scsih_check_device ( struct MPT3SAS_ADAPTER * ioc , u64 parent_sas_address , u16 handle , u8 phy_number , u8 link_rate ) { Mpi2ConfigReply_t mpi_reply ; Mpi2SasDevicePage0_t sas_device_pg0 ; struct _ sas_device * sas_device = NULL ; struct _ enclosure_node * enclosure_dev = NULL ; u32 ioc_status ; unsigned long flags ; u64 sas_address ; struct scsi_target * starget ; struct MPT3SAS_TARGET * sas_target_priv_data ; u32 device_info ; struct hba_port * port ; if ( ( mpt3sas_config_get_sas_device_pg0 ( ioc , & mpi_reply , & sas_device_pg0 , MPI2_SAS_DEVICE_PGAD_FORM_HANDLE , handle ) ) ) return ; ioc_status = le16_to_cpu ( mpi_reply . IOCStatus ) & MPI2_IOCSTATUS_MASK ; if ( ioc_status ! = MPI2_IOCSTATUS_SUCCESS ) return ; /* wide port handling ~ we need only handle device once for the phy that * is matched in sas device page zero if (phy_number != sas_device_pg0.PhyNum)return ;/* check if this is end device */ if (!(_scsih_is_end_device(device_info)))return ;0 );if (!port)goto out_unlock;if (!sas_device)goto out_unlock;if (unlikely(sas_device->handle != handle)) {"handle changed from(0x%04x) to (0x%04x)!!!\n" ,if (le16_to_cpu(sas_device_pg0.Flags) &4 );4 ] = '\0' ;else {0 ;0 ] = '\0' ;0 ;if (enclosure_dev) {if (le16_to_cpu(enclosure_dev->pg0.Flags) &1 ;/* check if device is present */ if (!(le16_to_cpu(sas_device_pg0.Flags) &"device is not present handle(0x%04x), flags!!!\n" ,goto out_unlock;/* check if there were any issues with discovery */ if (_scsih_check_access_status(ioc, sas_address, handle,goto out_unlock;if (sas_device)return ;if (sas_device)/** * _ scsih_add_device - creating sas device object * @ ioc : per adapter object * @ handle : sas device handle * @ phy_num : phy number end device attached to * @ is_pd : is this hidden raid component * * Creating end device object , stored in ioc - > sas_device_list . * * Return : 0 for success , non - zero for failure . static int struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num,struct _sas_device *sas_device;struct _enclosure_node *enclosure_dev = NULL;if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,"failure at %s:%d/%s()!\n" ,return -1 ;if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {"failure at %s:%d/%s()!\n" ,return -1 ;/* check if this is end device */ if (!(_scsih_is_end_device(device_info)))return -1 ;/* check if device is present */ if (!(le16_to_cpu(sas_device_pg0.Flags) &"device is not present handle(0x04%x)!!!\n" ,return -1 ;/* check if there were any issues with discovery */ if (_scsih_check_access_status(ioc, sas_address, handle,return -1 ;0 ));if (sas_device) {return -1 ;if (sas_device_pg0.EnclosureHandle) {if (enclosure_dev == NULL)"Enclosure handle(0x%04x) doesn't match with enclosure device!\n" ,sizeof (struct _sas_device),if (!sas_device) {"failure at %s:%d/%s()!\n" ,return 0 ;if (_scsih_get_sas_address(ioc,0 )"failure at %s:%d/%s()!\n" ,if (sas_device->enclosure_handle != 0 )1 : 0 ;0 );if (!sas_device->port) {"failure at %s:%d/%s()!\n" ,goto out;if (le16_to_cpu(sas_device_pg0.Flags)4 );4 ] = '\0' ;else {0 ;0 ] = '\0' ;/* get enclosure_logical_id & chassis_slot*/ 0 ;1 ;0 x%0 x) sas_address(0 x%016 llx) port_type(0 x%0 x)\n",0 ;0 ;0 x%04 x), sas_addr(0 x%016 llx)\n",1 ;0 x%04 x), sas_addr(0 x%016 llx)\n",0 x%04 x), sas_addr(0 x%016 llx)\n",0 :0 x%04 x), enclosure_handle(0 x%04 x) " \02 d), count(%d)\n",0 ; i < event_data->NumEntries; i++) {4 ;0 xF;02 d), attached_handle(0 x%04 x): %s:" \0 x%02 x), old(0 x%02 x)\n", phy_number,0 ;0 ;0 );0 )0 ;0 ;0 ; i < event_data->NumEntries; i++) {0 ;0 ;4 ;0 xF;0 );0 ;0 x%04 x), sas address(0 x%016 llx), tag(%d)",0 x%x), ASCQ(0 x%x)\n",0 xC), the internal device reset complete was8 ) < 0 xC)0 ));1 ;0 ;0 x%04 x)\n",1 ) ? "Enable" : "Disable",0 for success, else failure1 ;0 ;0 x%016 llx), "0 x%04 x)\n ll only be added to the internal list",0 ;0 x%02 x): wwid(0 x%016 llx), handle(0 x%04 x)\n",0 x%016 llx), handle(0 x%04 x)\n",0 x%04 x), wwid(0 x%016 llx)\n",0 )0 x%016 llx), slot(%d)\n",0 ] != '\0 ')0 x%04 x), connector name(%s)\n",1 ;0 x%04 x), wwid(0 x%016 llx)\n",0 )0 x%016 llx), slot(%d)\n",0 ] != '\0 ')0 x%04 x), connector name( %s)\n",0 x%04 x), wwid(0 x%016 llx)\n",0 )0 x%016 llx), slot(%d)\n",0 ] != '\0 ')0 x%04 x), connector name( %s)\n",0 x%04 x) to (0 x%04 x)!!!\n",0 ],0 ], 4 );0 ;0 ] = '\0 ';0 x%04 x), flags!!!\n",1 means queue the event later, 0 means complete the event0 ;0 ;0 x04%x)!!!\n",0 ;0 ;0 ;0 ;2 contains read-only information about a0 ;0 ;0 ;1 : 0 ;0 )0 ],0 ], 4 );0 ;0 ] = '\0 ';30 ;30 ;0 ;0 :0 x%04 x), enclosure_handle(0 x%04 x)"02 d), count(%d)\n",0 ; i < event_data->NumEntries; i++) {02 d), attached_handle(0 x%04 x): %s:"0 x%02 x), old(0 x%02 x)\n", port_number,0 ; i < event_data->NumEntries; i++) {0 x%04 x) device not found: convert event to a device add\n",0 xF0;0 x%04 x), WWID(0 x%016 llx), tag(%d)",0 x%x), ASCQ(0 x%x)\n",1 ;0 ;0 x%04 x), enclosure logical id(0 x%016 llx) number slots(%d)\n",0 ;5 ) {1 )1 ));0 ;0 ;1 ; smid <= ioc->scsiio_depth; smid++) {0 , 0 , lun,30 , 0 );0 x%04 x), scmd(%p)\n",0 ;60 ) {30 , 0 );0 xFF) {1 )1 , scmd);0 ;0 ;0 x%08 x)",0 && ioc->shost_recovery) {1 );0 x%04 x, sas_address:0 x%016 llx, physical_port:0 x%02 x) has failed\n",0 x%04 x, sas_address:0 x%016 llx, physical_port:0 x%02 x) has timed out\n",0 x%02 x",0 x%08 x)",0 for success, else failure.0 ;0 ;0 , sizeof(Mpi2RaidActionRequest_t));0 x%04 x), phys_disk_num (0 x%02 10 *HZ);4 , issue_reset);0 ;if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {"IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n" ,else "IR RAID_ACTION: completed successfully\n" ));if (issue_reset)return rc;/** * _ scsih_reprobe_lun - reprobing lun * @ sdev : scsi device struct * @ no_uld_attach : sdev - > no_uld_attach flag setting * static void struct scsi_device *sdev, void *no_uld_attach)1 : 0 ;"%s raid component\n" ,"hiding" : "exposing" );/** * _ scsih_sas_volume_add - add new volume * @ ioc : per adapter object * @ element : IR config element data * Context : user . static void struct MPT3SAS_ADAPTER *ioc,struct _raid_device *raid_device;unsigned long flags;int rc;if (!wwid) {"failure at %s:%d/%s()!\n" ,return ;if (raid_device)return ;sizeof (struct _raid_device), GFP_KERNEL);if (!raid_device) {"failure at %s:%d/%s()!\n" ,return ;if (!ioc->wait_for_discovery_to_complete) {0 );if (rc)else {1 );/** * _ scsih_sas_volume_delete - delete volume * @ ioc : per adapter object * @ handle : volume device handle * Context : user . static void struct MPT3SAS_ADAPTER *ioc, u16 handle)struct _raid_device *raid_device;unsigned long flags;struct MPT3SAS_TARGET *sas_target_priv_data;struct scsi_target *starget = NULL;if (raid_device) {if (raid_device->starget) {1 ;"removing handle(0x%04x), wwid(0x%016llx)\n" ,if (starget)/**. java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 35 * _ * @ ha : Pointer to host adapter structure . * @ ioc : per adapter object t java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35 * Context : user . static void struct MPT3SAS_ADAPTER *ioc,struct _sess =cls_sessiondd_datastruct scsi_target*starget = NULLunsigned long flags ()if (sas_device) {0 ;0 ;if (sas_device->starget && sas_device->starget->hostdata) {if (!sas_device)return ;/* exposing raid component */ if (starget)/** * _ scsih_sas_pd_hide - hide pd component from / dev / sdX * @ ioc : per adapter object * @ element : IR config element data * Context : user . static void struct MPT3SAS_ADAPTER *ioc,struct _sas_device *sas_device;struct scsi_target *starget = NULL;struct MPT3SAS_TARGET *sas_target_priv_data;unsigned long flags;0 ;0 ;if (volume_handle)if (sas_device) {if (sas_device->starget && sas_device->starget->hostdata) {if (!sas_device)return ;/* hiding raid component */ if (starget)void *)1 , _scsih_reprobe_lun);/** * _ scsih_sas_pd_delete - delete pd component * @ ioc : per adapter object * @ element : IR config element data * Context : user . static void struct MPT3SAS_ADAPTER *ioc,/** * _ scsih_sas_pd_add - remove pd component * @ ioc : per adapter object * @ element : IR config element data * Context : user . static void struct MPT3SAS_ADAPTER *ioc,struct _sas_device *sas_device;if (sas_device) {return ;if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,"failure at %s:%d/%s()!\n" ,return ;if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {"failure at %s:%d/%s()!\n" ,return ;if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))0 ));0 , 1 );/** * _ scsih_sas_ir_config_change_event_debug - debug for IR Config Change events * @ ioc : per adapter object * @ event_data : event data payload * Context : user . static void struct MPT3SAS_ADAPTER *ioc,int i;char *reason_str = NULL, *element_str = NULL;0 ];"raid config change: (%s), elements(%d)\n" ,"foreign" : "native" ,for (i = 0 ; i < event_data->NumElements; i++, element++) {switch (element->ReasonCode) {case MPI2_EVENT_IR_CHANGE_RC_ADDED:"add" ;break ;case MPI2_EVENT_IR_CHANGE_RC_REMOVED:"remove" ;break ;case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE:"no change" ;break ;case MPI2_EVENT_IR_CHANGE_RC_HIDE:"hide" ;break ;case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:"unhide" ;break ;case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:"volume_created" ;break ;case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:"volume_deleted" ;break ;case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:"pd_created" ;break ;case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:"pd_deleted" ;break ;default :"unknown reason" ;break ;switch (element_type) {case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT:"volume" ;break ;case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT:"phys disk" ;break ;case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT:"hot spare" ;break ;default :"unknown element" ;break ;"\t(%s:%s), vol handle(0x%04x), " \"pd handle(0x%04x), pd num(0x%02x)\n" , element_str,/** * _ scsih_sas_ir_config_change_event - handle ir configuration change events * @ ioc : per adapter object * @ fw_event : The fw_event_work object * Context : user . static void struct MPT3SAS_ADAPTER *ioc,struct fw_event_work *fw_event)int i;if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) &&1 : 0 ;0 ];if (ioc->shost_recovery &&for (i = 0 ; i < event_data->NumElements; i++, element++) {if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE)return ;for (i = 0 ; i < event_data->NumElements; i++, element++) {switch (element->ReasonCode) {case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED:case MPI2_EVENT_IR_CHANGE_RC_ADDED:if (!foreign_config)break ;case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED:case MPI2_EVENT_IR_CHANGE_RC_REMOVED:if (!foreign_config)break ;case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:if (!ioc->is_warpdrive)break ;case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:if (!ioc->is_warpdrive)break ;case MPI2_EVENT_IR_CHANGE_RC_HIDE:if (!ioc->is_warpdrive)break ;case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:if (!ioc->is_warpdrive)break ;/** * _ scsih_sas_ir_volume_event - IR volume event * @ ioc : per adapter object * @ fw_event : The fw_event_work object * Context : user . static void struct MPT3SAS_ADAPTER *ioc,struct fw_event_work *fw_event)unsigned long flags;struct _raid_device *raid_device;int rc;if (ioc->shost_recovery)return ;if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED)return ;if (!ioc->hide_ir_msg)"%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n" ,switch (state) {case MPI2_RAID_VOL_STATE_MISSING:case MPI2_RAID_VOL_STATE_FAILED:break ;case MPI2_RAID_VOL_STATE_ONLINE:case MPI2_RAID_VOL_STATE_DEGRADED:case MPI2_RAID_VOL_STATE_OPTIMAL:if (raid_device)break ;if (!wwid) {"failure at %s:%d/%s()!\n" ,break ;sizeof (struct _raid_device), GFP_KERNEL);if (!raid_device) {"failure at %s:%d/%s()!\n" ,break ;0 );if (rc)break ;case MPI2_RAID_VOL_STATE_INITIALIZING:default :break ;/** * _ scsih_sas_ir_physical_disk_event - PD event * @ ioc : per adapter object * @ fw_event : The fw_event_work object * Context : user . static void struct MPT3SAS_ADAPTER *ioc,struct fw_event_work *fw_event)struct _sas_device *sas_device;if (ioc->shost_recovery)return ;if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)return ;if (!ioc->hide_ir_msg)"%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n" ,switch (state) {case MPI2_RAID_PD_STATE_ONLINE:case MPI2_RAID_PD_STATE_DEGRADED:case MPI2_RAID_PD_STATE_REBUILDING:case MPI2_RAID_PD_STATE_OPTIMAL:case MPI2_RAID_PD_STATE_HOT_SPARE:if (!ioc->is_warpdrive)if (sas_device) {return ;if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply,"failure at %s:%d/%s()!\n" ,return ;if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {"failure at %s:%d/%s()!\n" ,return ;if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))0 ));0 , 1 );break ;case MPI2_RAID_PD_STATE_OFFLINE:case MPI2_RAID_PD_STATE_NOT_CONFIGURED:case MPI2_RAID_PD_STATE_NOT_COMPATIBLE:default :break ;/** * _ scsih_sas_ir_operation_status_event_debug - debug for IR op event * @ ioc : per adapter object * @ event_data : event data payload * Context : user . static void struct MPT3SAS_ADAPTER *ioc,char *reason_str = NULL;switch (event_data->RAIDOperation) {case MPI2_EVENT_IR_RAIDOP_RESYNC:"resync" ;break ;case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION:"online capacity expansion" ;break ;case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:"consistency check" ;break ;case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:"background init" ;break ;case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:"make data consistent" ;break ;0 x%04 x), percent complete(%d)\n",1 ;1 ) ?0 0 );0 x%04 x) doesn't match with enclosure device!\n",1 ;0 ;0 ;0 x%04 x), sas_addr(0 x%016 llx)\n",0 )0 x%016 llx), slot(%d)\n",0 ],0 ], 4 );0 ;0 ] = '\0 ';0 ;1 ;0 x%04 x)!!!\n",0 )s0 xFFFF;1 );0 xFFFF;0 1 ;0 ;0 ;0 x%04 x), wwid(0 x%016 llx) ",0 )0 x%016 llx), "0 ],0 ], 4 );0 ;0 ] = '\0 ';0 x%04 x)!!!\n",0 xFFFF;0 x%04 x), loginfo(0 x%08 x)\n",if (!(_scsih_is_nvme_pciescsi_device(device_info)))continue ;"search for PCIe end-devices: complete\n" );/** * _ scsih_mark_responding_raid_device - mark a raid_device as responding * @ ioc : per adapter object * @ wwid : world wide identifier for raid volume * @ handle : device handle * * After host reset , find out whether devices are still responding . * Used in _ scsih_remove_unresponsive_raid_devices . static void struct MPT3SAS_ADAPTER *ioc, u64 wwid,struct MPT3SAS_TARGET *sas_target_priv_data = NULL;struct scsi_target *starget;struct _raid_device *raid_device;unsigned long flags;if (raid_device->wwid == wwid && raid_device->starget) {if (starget && starget->hostdata) {0 ;else 1 ;"handle(0x%04x), wwid(0x%016llx)\n" , handle,unsigned long long )raid_device->wwid);/* * WARPDRIVE : The handles of the PDs might have changed * across the host reset so re - initialize the * required data for Direct IO if (raid_device->handle == handle) {return ;"\thandle changed from(0x%04x)!!!\n" ,if (sas_target_priv_data)return ;/** * _ scsih_search_responding_raid_devices - * @ ioc : per adapter object * * After host reset , find out whether devices are still responding . * If not remove . static void struct MPT3SAS_ADAPTER *ioc)if (!ioc->ir_firmware)return ;"search for raid volumes: start\n" );if (list_empty(&ioc->raid_device_list))goto out;0 xFFFF;while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,if (ioc_status != MPI2_IOCSTATUS_SUCCESS)break ;if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply,sizeof (Mpi2RaidVolPage0_t)))continue ;if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL ||/* refresh the pd_handles */ if (!ioc->is_warpdrive) {0 xFF;0 , ioc->pd_handles_sz);while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,if (ioc_status != MPI2_IOCSTATUS_SUCCESS)break ;"search for responding raid volumes: complete\n" );/** * _ scsih_mark_responding_expander - mark a expander as responding * @ ioc : per adapter object * @ expander_pg0 : SAS Expander Config Page0 * * After host reset , find out whether devices are still responding . * Used in _ scsih_remove_unresponsive_expanders . static void struct MPT3SAS_ADAPTER *ioc,struct _sas_node *sas_expander = NULL;unsigned long flags;int i;struct _enclosure_node *enclosure_dev = NULL;struct hba_port *port = mpt3sas_get_port_by_id(0 );if (enclosure_handle)if (sas_expander->sas_address != sas_address)continue ;if (sas_expander->port != port)continue ;1 ;if (enclosure_dev) {if (sas_expander->handle == handle)goto out;"\texpander(0x%016llx): handle changed" \" from(0x%04x) to (0x%04x)!!!\n" ,unsigned long long )sas_expander->sas_address,for (i = 0 ; i < sas_expander->num_phys ; i++)goto out;/** * _ scsih_search_responding_expanders - * @ ioc : per adapter object * * After host reset , find out whether devices are still responding . * If not remove . static void struct MPT3SAS_ADAPTER *ioc)"search for expanders: start\n" );if (list_empty(&ioc->sas_expander_list))goto out;0 xFFFF;while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,if (ioc_status != MPI2_IOCSTATUS_SUCCESS)break ;"\texpander present: handle(0x%04x), sas_addr(0x%016llx), port:%d\n" ,unsigned long long )sas_address,"search for expanders: complete\n" );/** * _ scsih_remove_unresponding_devices - removing unresponding devices * @ ioc : per adapter object static void struct MPT3SAS_ADAPTER *ioc)struct _sas_device *sas_device, *sas_device_next;struct _sas_node *sas_expander, *sas_expander_next;struct _raid_device *raid_device, *raid_device_next;struct _pcie_device *pcie_device, *pcie_device_next;struct list_head tmp_list;unsigned long flags;"removing unresponding devices: start\n" );/* removing unresponding end devices */ "removing unresponding devices: end-devices\n" );/* * Iterate , pulling off devices marked as non - responding . We become the * owner for the reference the list had on any object we prune . /* * Clean up the sas_device_init_list list as * driver goes for fresh scan as part of diag reset . if (!sas_device->responding)else 0 ;/* * Now , uninitialize and remove the unresponding devices we pruned . "Removing unresponding devices: pcie end-devices\n" );/* * Clean up the pcie_device_init_list list as * driver goes for fresh scan as part of diag reset . if (!pcie_device->responding)else 0 ;/* packet processing complete */ 20/* removing unresponding volumes */ gth 24"removing unresponding devices: java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 4 unds for length 21if > clk_get_rate(>ase_clkjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50else 0 ;/* removing unresponding expanders */ "removing unresponding devices: expanders\n" );if (!sas_expander->responding)else 0 ;"removing unresponding devices: complete\n" );/* unblock devices */ static void struct MPT3SAS_ADAPTER *ioc,struct _sas_node *sas_expander, u16 handle)int i;for (i = 0 ; i < sas_expander->num_phys ; i++) {if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply,"failure at %s:%d/%s()!\n" ,return ;for nds for length 38/** * _ scsih_scan_for_devices_after_reset - scan for devices after host reset * @ ioc : per adapter object static void struct MPT3SAS_ADAPTER *ioc)struct _sas_device *sas_device;struct _pcie_device *pcie_device;struct _sas_node *expander_device;static struct _raid_device *raid_device;unsigned long flags;"scan devices: start\n" );"\tscan devices: expanders start\n" );/* expanders */ 0 xFFFF;while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0,if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {"\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n" ,break ;0 ));if (expander_device)else {"\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n" ,"\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n" ,"\tscan devices: expanders complete\n" );if (!ioc->ir_firmware)goto skip_to_sas;"\tscan devices: phys disk start\n" );/* phys disk */ 0 xFF;while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply,if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {"\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n" ,0 )0 x%04 x), loginfo(0 x%08 x)\n",0 x%04 x), sas_addr(0 x%016 llx)\n",0 ));0 ;1 " when it should be retried1 )) {1 );0 x%04 x), sas_addr(0 x%016 llx)\n",0 xFFFF;0 x%04 x), loginfo(0 x%08 x)\n",0 x%04 x), loginfo(0 x%08 x)\n",0 , sizeof(Mpi2EventIrConfigElement_t));0 x%04 x)\n",0 x%04 x)\n",0 xFFFF;0 x%04 x), loginfo(0 x%08 x)\n",0 ));0 x%04 x), sas_addr(0 x%016 llx)\n",0 ));0 ;1 " when it should be retried0 )) {1 );0 x%04 x), sas_addr(0 x%016 llx)\n",0 xFFFF;0 x%04 x), loginfo(0 x%08 x)\n",0 ;0 x%04 x), wwid(0 x%016 llx)\n",0 , ioc->pend_os_device_add_sz);0 ,0 && !ioc->sas_hba.num_phys)) {1 );if (ioc->is_gen35_ioc)/* * If diag reset has occurred during the driver load * then driver has to complete the driver load operation * by executing the following items : * - Register the devices from sas_device_init_list to SML * - clear is_driver_loading flag , * - start the watchdog thread . * In happy driver load path , above things are taken care of when * driver executes scsih_scan_finished ( ) . if (ioc->is_driver_loading)break ;case MPT3SAS_PORT_ENABLE_COMPLETE:0 ;if (missing_delay[0 ] != -1 && missing_delay[1 ] != -1 )0 ],1 ]);"port enable: complete from worker thread\n" ));break ;case MPT3SAS_TURN_ON_PFA_LED:break ;case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:break ;case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)break ;case MPI2_EVENT_SAS_DISCOVERY:break ;case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR:break ;case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:break ;case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:break ;case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:break ;case MPI2_EVENT_IR_VOLUME:break ;case MPI2_EVENT_IR_PHYSICAL_DISK:break ;case MPI2_EVENT_IR_OPERATION_STATUS:break ;case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE:break ;case MPI2_EVENT_PCIE_ENUMERATION:break ;case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST:break ;/** * _ firmware_event_work * @ work : The fw_event_work object * Context : user . * * wrappers for the work thread handling firmware events static void struct work_struct *work)struct fw_event_work *fw_event = container_of(work,struct fw_event_work, work);/** * mpt3sas_scsih_event_callback - firmware event handler ( called at ISR time ) * @ ioc : per adapter object * @ msix_index : MSIX table index supplied by the OS * @ reply : reply message frame ( lower 32 bit addr ) * Context : interrupt . * * This function merely adds a new work task into ioc - > firmware_event_thread . * The tasks are worked from _ firmware_event_work in user context . * * Return : 1 meaning mf should be freed from _ base_interrupt * 0 means the mf is freed from this function . struct MPT3SAS_ADAPTER *ioc, u8 msix_index,struct fw_event_work *fw_event;/* events turned off due to host reset */ if (ioc->pci_error_recovery)return 1 ;if (unlikely(!mpi_reply)) {"mpi_reply not valid at %s:%d/%s()!\n" ,return 1 ;if (event != MPI2_EVENT_LOG_ENTRY_ADDED)0 );switch (event) {/* handle these */ case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE:1 ;1 ;1 ;1 ;1 ;eck WarpDrive documentation for additional details.\n");aded range. Check WarpDrive documentation for additional details.\n");system. The storage device will be in read-only mode. Check WarpDrive documentation for additional details.\n");ystem. Check WarpDrive documentation for additional details.\n");12 Gb/s rate)\n");1 ;4 ;1 ;1 ;0 x%04 x), sas_addr(0 x%016 llx), port:%d\n",0 , sizeof(Mpi26IoUnitControlRequest_t));0 x%04 x), loginfo(0 x%08 x)\n",0 , sizeof (Mpi2RaidActionRequest_t));if (!ioc->hide_ir_msg)"IR shutdown (sending)\n" );10 *HZ);if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) {"%s: timeout\n" , __func__);goto out;if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) {if (!ioc->hide_ir_msg)"IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n" ,/** * _ scsih_get_shost_and_ioc - get shost and ioc * and verify whether they are NULL or not * @ pdev : PCI device struct * @ shost : address of scsi host pointer * @ ioc : address of HBA adapter pointer * * Return zero if * shost and * ioc are not NULL otherwise return error number . static int struct pci_dev *pdev,struct Scsi_Host **shost, struct MPT3SAS_ADAPTER **ioc)if (*shost == NULL) {"pdev's driver data is null\n" );return -ENXIO;if (*ioc == NULL) {"shost's private data is null\n" );return -ENXIO;return 0 ;/** * scsih_remove - detach and remove add host * @ pdev : PCI device struct * * Routine called when unloading the driver . static void scsih_remove(struct pci_dev *pdev)struct Scsi_Host *shost;struct MPT3SAS_ADAPTER *ioc;struct _sas_port *mpt3sas_port, *next_port;struct _raid_device *raid_device, *next;struct MPT3SAS_TARGET *sas_target_priv_data;struct _pcie_device *pcie_device, *pcienext;struct workqueue_struct *wq;unsigned long flags;struct hba_port *port, *port_next;if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc))1 ;1 ;0 x%04 x), wwid(0 x%016 llx)\n",0 ;1 ;1 ;0 ;1 st device2 , this routine reports the 1 st0 );0 );0 );0 );1 && diag_buffer_enable != 0 )0 )1 );0 )1 ;0 )0 ;0 ;1 with the1 .0 ;0 ) {0 ;0 ;1 ;300 * HZ)) {300 s)\n");0 ;1 ;0 );1 ;1 ;0 ;0 x%08 x)\n",0 ;0 ;1 ;1 ;0 ;1 ;1 )0 , qoff = 0 ; i < shost->nr_maps; i++) {0 ;0 ;2 .0 HBA devices */1 ,1 ,32767 ,7 ,1 ,2 .0 HBA devices */3 .0 HBA devices */1 ,1 ,32767 ,0 xffffffff,128 ,1 ,3 .0 HBA devices *//** * _ scsih_determine_hba_mpi_version - determine in which MPI version class * this device belongs to . * @ pdev : PCI device struct * * return MPI2_VERSION for SAS 2 . 0 HBA devices , * MPI25_VERSION for SAS 3 . 0 HBA devices , and * MPI26 VERSION for Cutlass & Invader SAS 3 . 0 HBA devices static u16struct pci_dev *pdev)switch (pdev->device) {case MPI2_MFGPAGE_DEVID_SSS6200:case MPI2_MFGPAGE_DEVID_SAS2004:case MPI2_MFGPAGE_DEVID_SAS2008:case MPI2_MFGPAGE_DEVID_SAS2108_1:case MPI2_MFGPAGE_DEVID_SAS2108_2:case MPI2_MFGPAGE_DEVID_SAS2108_3:case MPI2_MFGPAGE_DEVID_SAS2116_1:case MPI2_MFGPAGE_DEVID_SAS2116_2:case MPI2_MFGPAGE_DEVID_SAS2208_1:case MPI2_MFGPAGE_DEVID_SAS2208_2:case MPI2_MFGPAGE_DEVID_SAS2208_3:case MPI2_MFGPAGE_DEVID_SAS2208_4:case MPI2_MFGPAGE_DEVID_SAS2208_5:case MPI2_MFGPAGE_DEVID_SAS2208_6:case MPI2_MFGPAGE_DEVID_SAS2308_1:case MPI2_MFGPAGE_DEVID_SAS2308_2:case MPI2_MFGPAGE_DEVID_SAS2308_3:case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP:case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1:return MPI2_VERSION;case MPI25_MFGPAGE_DEVID_SAS3004:case MPI25_MFGPAGE_DEVID_SAS3008:case MPI25_MFGPAGE_DEVID_SAS3108_1:case MPI25_MFGPAGE_DEVID_SAS3108_2:case MPI25_MFGPAGE_DEVID_SAS3108_5:case MPI25_MFGPAGE_DEVID_SAS3108_6:return MPI25_VERSION;case MPI26_MFGPAGE_DEVID_SAS3216:case MPI26_MFGPAGE_DEVID_SAS3224:case MPI26_MFGPAGE_DEVID_SAS3316_1:case MPI26_MFGPAGE_DEVID_SAS3316_2:case MPI26_MFGPAGE_DEVID_SAS3316_3:case MPI26_MFGPAGE_DEVID_SAS3316_4:case MPI26_MFGPAGE_DEVID_SAS3324_1:case MPI26_MFGPAGE_DEVID_SAS3324_2:case MPI26_MFGPAGE_DEVID_SAS3324_3:case MPI26_MFGPAGE_DEVID_SAS3324_4:case MPI26_MFGPAGE_DEVID_SAS3508:case MPI26_MFGPAGE_DEVID_SAS3508_1:case MPI26_MFGPAGE_DEVID_SAS3408:case MPI26_MFGPAGE_DEVID_SAS3516:case MPI26_MFGPAGE_DEVID_SAS3516_1:case MPI26_MFGPAGE_DEVID_SAS3416:case MPI26_MFGPAGE_DEVID_SAS3616:case MPI26_ATLAS_PCIe_SWITCH_DEVID:case MPI26_MFGPAGE_DEVID_CFG_SEC_3916:case MPI26_MFGPAGE_DEVID_HARD_SEC_3916:case MPI26_MFGPAGE_DEVID_CFG_SEC_3816:case MPI26_MFGPAGE_DEVID_HARD_SEC_3816:case MPI26_MFGPAGE_DEVID_INVALID0_3916:case MPI26_MFGPAGE_DEVID_INVALID1_3916:case MPI26_MFGPAGE_DEVID_INVALID0_3816:case MPI26_MFGPAGE_DEVID_INVALID1_3816:return MPI26_VERSION;return 0 ;/** * _ scsih_probe - attach and add scsi host * @ pdev : PCI device struct * @ id : pci device id * * Return : 0 success , anything else error . static int struct pci_dev *pdev, const struct pci_device_id *id)struct MPT3SAS_ADAPTER *ioc;struct Scsi_Host *shost = NULL;int rv;int iopoll_q_count = 0 ;/* Determine in which MPI version class this pci device belongs */ if (hba_mpi_version == 0 )return -ENODEV;/* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one, * for other generation HBA ' s return with - ENODEV if ((hbas_to_enumerate == 1 ) && (hba_mpi_version != MPI2_VERSION))return -ENODEV;/* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two, * for other generation HBA ' s return with - ENODEV if ((hbas_to_enumerate == 2 ) && (!(hba_mpi_version == MPI25_VERSIONreturn -ENODEV;switch (hba_mpi_version) {case MPI2_VERSION:/* Use mpt2sas driver host template for SAS 2.0 HBA's */ sizeof (struct MPT3SAS_ADAPTER));if (!shost)return -ENODEV;0 , sizeof (struct MPT3SAS_ADAPTER));"%s" , MPT2SAS_DRIVER_NAME);switch (pdev->device) {case MPI2_MFGPAGE_DEVID_SSS6200:1 ;1 ;break ;case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP:case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1:1 ;break ;default :break ;if (multipath_on_hba == -1 || multipath_on_hba == 0 )0 ;else 1 ;break ;case MPI25_VERSION:case MPI26_VERSION:/* Use mpt3sas driver host template for SAS 3.0 HBA's */ sizeof (struct MPT3SAS_ADAPTER));if (!shost)return -ENODEV;0 , sizeof (struct MPT3SAS_ADAPTER));"%s" , MPT3SAS_DRIVER_NAME);switch (pdev->device) {case MPI26_MFGPAGE_DEVID_SAS3508:case MPI26_MFGPAGE_DEVID_SAS3508_1:case MPI26_MFGPAGE_DEVID_SAS3408:case MPI26_MFGPAGE_DEVID_SAS3516:case MPI26_MFGPAGE_DEVID_SAS3516_1:case MPI26_MFGPAGE_DEVID_SAS3416:case MPI26_MFGPAGE_DEVID_SAS3616:case MPI26_ATLAS_PCIe_SWITCH_DEVID:1 ;break ;case MPI26_MFGPAGE_DEVID_INVALID0_3816:case MPI26_MFGPAGE_DEVID_INVALID0_3916:"HBA with DeviceId 0x%04x, sub VendorId 0x%04x, sub DeviceId 0x%04x is Invalid" ,return 1 ;case MPI26_MFGPAGE_DEVID_INVALID1_3816:case MPI26_MFGPAGE_DEVID_INVALID1_3916:"HBA with DeviceId 0x%04x, sub VendorId 0x%04x, sub DeviceId 0x%04x is Tampered" ,return 1 ;case MPI26_MFGPAGE_DEVID_CFG_SEC_3816:case MPI26_MFGPAGE_DEVID_CFG_SEC_3916:"HBA is in Configurable Secure mode\n" );case MPI26_MFGPAGE_DEVID_HARD_SEC_3816:case MPI26_MFGPAGE_DEVID_HARD_SEC_3916:1 ;break ;default :0 ;if ((ioc->hba_mpi_version_belonged == MPI25_VERSION &&1 ;if (ioc->is_gen35_ioc)else switch (ioc->is_gen35_ioc) {case 0 :if (multipath_on_hba == -1 || multipath_on_hba == 0 )0 ;else 1 ;break ;case 1 :if (multipath_on_hba == -1 || multipath_on_hba > 0 )1 ;else 0 ;break ;default :break ;break ;default :return -ENODEV;/* Host waits for minimum of six seconds */ /* * Enable MEMORY MOVE support flag . /* Enable ADDITIONAL QUERY support flag. */ /* misc semaphores and spin locks */ /* initializing pci_access_mutex lock */ "%s_cm%d" , ioc->driver_name, ioc->id);/* init shost parameters */ 32 ;if (ioc->is_mcpu_endpoint) {/* mCPU MPI support 64K max IO */ 128 ;"The max_sectors value is set to %d\n" ,else {if (max_sectors != 0 xFFFF) {if (max_sectors < 64 ) {64 ;"Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n" ,else if (max_sectors > 32767 ) {32767 ;"Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n" ,else {0 xFFFE;"The max_sectors value is set to %d\n" ,/* register EEDP capabilities with SCSI layer */ if (prot_mask >= 0 )0 x07));else /* event thread */ "fw_event_%s%d" , 0 , ioc->driver_name, ioc->id);if (!ioc->firmware_event_thread) {"failure at %s:%d/%s()!\n" ,goto out_thread_fail;0 ;if (ioc->is_gen35_ioc && host_tagset_enable)1 ;1 ;if ((mpt3sas_base_attach(ioc))) {"failure at %s:%d/%s()!\n" ,goto out_attach_fail;if (ioc->is_warpdrive) {if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS)0 ;else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS)1 ;else {if (mpt3sas_get_num_volumes(ioc))1 ;else 0 ;else 0 ;1 ;if (shost->host_tagset) {3 : 1 ;"Max SCSIIO MPT commands: %d shared with nr_hw_queues = %d\n" ,if (rv) {"failure at %s:%d/%s()!\n" ,goto out_add_shost_fail;return 0 ;0 success, anything else error.0 x%p, slot=%s, entering operating state\n",0 ;0 success, anything else error.0 x%p, slot=%s, previous operating state [D%d]\n",0 ;1 ;1 ;0 ;0 ) ? "success" : "failed");2004 */2008 */2108 */2116 */2208 */2308 */3004 and 3008 */3108 */3216 and 3224 */3316 and 3324 */3516 , 3416 , 3508 & 3408 */3616 */0 x00E1 Configurable Secure0 x00E2 Hard Secure0 x00E0 Invalid, 0 x00E3 Tampered0 x00E5 Configurable Secure0 x00E6 Hard Secure0 x00E4 Invalid, 0 x00E7 Tampered0 } /* Terminating entry */0 success, anything else error.0 ;0 ;0 ;0 success, anything else error.1 )2 )0 success, anything else error.1 ) {2 ) {
Messung V0.5 in Prozent C=97 H=94 G=95
¤ Dauer der Verarbeitung: 3.66 Sekunden
¤ *© Formatika GbR, Deutschland
