1f92363d1SSreekanth Reddy /* 2f92363d1SSreekanth Reddy * Management Module Support for MPT (Message Passing Technology) based 3f92363d1SSreekanth Reddy * controllers 4f92363d1SSreekanth Reddy * 5f92363d1SSreekanth Reddy * This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.c 6a4ffce0dSSreekanth Reddy * Copyright (C) 2012-2014 LSI Corporation 7a03bd153SSreekanth Reddy * Copyright (C) 2013-2014 Avago Technologies 8a03bd153SSreekanth Reddy * (mailto: MPT-FusionLinux.pdl@avagotech.com) 9f92363d1SSreekanth Reddy * 10f92363d1SSreekanth Reddy * This program is free software; you can redistribute it and/or 11f92363d1SSreekanth Reddy * modify it under the terms of the GNU General Public License 12f92363d1SSreekanth Reddy * as published by the Free Software Foundation; either version 2 13f92363d1SSreekanth Reddy * of the License, or (at your option) any later version. 14f92363d1SSreekanth Reddy * 15f92363d1SSreekanth Reddy * This program is distributed in the hope that it will be useful, 16f92363d1SSreekanth Reddy * but WITHOUT ANY WARRANTY; without even the implied warranty of 17f92363d1SSreekanth Reddy * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18f92363d1SSreekanth Reddy * GNU General Public License for more details. 19f92363d1SSreekanth Reddy * 20f92363d1SSreekanth Reddy * NO WARRANTY 21f92363d1SSreekanth Reddy * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 22f92363d1SSreekanth Reddy * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 23f92363d1SSreekanth Reddy * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 24f92363d1SSreekanth Reddy * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 25f92363d1SSreekanth Reddy * solely responsible for determining the appropriateness of using and 26f92363d1SSreekanth Reddy * distributing the Program and assumes all risks associated with its 27f92363d1SSreekanth Reddy * exercise of rights under this Agreement, including but not limited to 28f92363d1SSreekanth Reddy * the risks and costs of program errors, damage to or loss of data, 29f92363d1SSreekanth Reddy * programs or equipment, and unavailability or interruption of operations. 30f92363d1SSreekanth Reddy 31f92363d1SSreekanth Reddy * DISCLAIMER OF LIABILITY 32f92363d1SSreekanth Reddy * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 33f92363d1SSreekanth Reddy * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 34f92363d1SSreekanth Reddy * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 35f92363d1SSreekanth Reddy * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 36f92363d1SSreekanth Reddy * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 37f92363d1SSreekanth Reddy * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 38f92363d1SSreekanth Reddy * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 39f92363d1SSreekanth Reddy 40f92363d1SSreekanth Reddy * You should have received a copy of the GNU General Public License 41f92363d1SSreekanth Reddy * along with this program; if not, write to the Free Software 42f92363d1SSreekanth Reddy * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 43f92363d1SSreekanth Reddy * USA. 44f92363d1SSreekanth Reddy */ 45f92363d1SSreekanth Reddy 46f92363d1SSreekanth Reddy #include <linux/kernel.h> 47f92363d1SSreekanth Reddy #include <linux/module.h> 48f92363d1SSreekanth Reddy #include <linux/errno.h> 49f92363d1SSreekanth Reddy #include <linux/init.h> 50f92363d1SSreekanth Reddy #include <linux/slab.h> 51f92363d1SSreekanth Reddy #include <linux/types.h> 52f92363d1SSreekanth Reddy #include <linux/pci.h> 53f92363d1SSreekanth Reddy #include <linux/delay.h> 54f92363d1SSreekanth Reddy #include <linux/compat.h> 55f92363d1SSreekanth Reddy #include <linux/poll.h> 56f92363d1SSreekanth Reddy 57f92363d1SSreekanth Reddy #include <linux/io.h> 58f92363d1SSreekanth Reddy #include <linux/uaccess.h> 59f92363d1SSreekanth Reddy 60f92363d1SSreekanth Reddy #include "mpt3sas_base.h" 61f92363d1SSreekanth Reddy #include "mpt3sas_ctl.h" 62f92363d1SSreekanth Reddy 63f92363d1SSreekanth Reddy 64f92363d1SSreekanth Reddy static struct fasync_struct *async_queue; 65f92363d1SSreekanth Reddy static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait); 66f92363d1SSreekanth Reddy 67f92363d1SSreekanth Reddy 68f92363d1SSreekanth Reddy /** 69f92363d1SSreekanth Reddy * enum block_state - blocking state 70f92363d1SSreekanth Reddy * @NON_BLOCKING: non blocking 71f92363d1SSreekanth Reddy * @BLOCKING: blocking 72f92363d1SSreekanth Reddy * 73f92363d1SSreekanth Reddy * These states are for ioctls that need to wait for a response 74f92363d1SSreekanth Reddy * from firmware, so they probably require sleep. 75f92363d1SSreekanth Reddy */ 76f92363d1SSreekanth Reddy enum block_state { 77f92363d1SSreekanth Reddy NON_BLOCKING, 78f92363d1SSreekanth Reddy BLOCKING, 79f92363d1SSreekanth Reddy }; 80f92363d1SSreekanth Reddy 81f92363d1SSreekanth Reddy /** 82f92363d1SSreekanth Reddy * _ctl_sas_device_find_by_handle - sas device search 83f92363d1SSreekanth Reddy * @ioc: per adapter object 84f92363d1SSreekanth Reddy * @handle: sas device handle (assigned by firmware) 85f92363d1SSreekanth Reddy * Context: Calling function should acquire ioc->sas_device_lock 86f92363d1SSreekanth Reddy * 87f92363d1SSreekanth Reddy * This searches for sas_device based on sas_address, then return sas_device 88f92363d1SSreekanth Reddy * object. 89f92363d1SSreekanth Reddy */ 90f92363d1SSreekanth Reddy static struct _sas_device * 91f92363d1SSreekanth Reddy _ctl_sas_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 92f92363d1SSreekanth Reddy { 93f92363d1SSreekanth Reddy struct _sas_device *sas_device, *r; 94f92363d1SSreekanth Reddy 95f92363d1SSreekanth Reddy r = NULL; 96f92363d1SSreekanth Reddy list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 97f92363d1SSreekanth Reddy if (sas_device->handle != handle) 98f92363d1SSreekanth Reddy continue; 99f92363d1SSreekanth Reddy r = sas_device; 100f92363d1SSreekanth Reddy goto out; 101f92363d1SSreekanth Reddy } 102f92363d1SSreekanth Reddy 103f92363d1SSreekanth Reddy out: 104f92363d1SSreekanth Reddy return r; 105f92363d1SSreekanth Reddy } 106f92363d1SSreekanth Reddy 107f92363d1SSreekanth Reddy /** 108f92363d1SSreekanth Reddy * _ctl_display_some_debug - debug routine 109f92363d1SSreekanth Reddy * @ioc: per adapter object 110f92363d1SSreekanth Reddy * @smid: system request message index 111f92363d1SSreekanth Reddy * @calling_function_name: string pass from calling function 112f92363d1SSreekanth Reddy * @mpi_reply: reply message frame 113f92363d1SSreekanth Reddy * Context: none. 114f92363d1SSreekanth Reddy * 115f92363d1SSreekanth Reddy * Function for displaying debug info helpful when debugging issues 116f92363d1SSreekanth Reddy * in this module. 117f92363d1SSreekanth Reddy */ 118f92363d1SSreekanth Reddy static void 119f92363d1SSreekanth Reddy _ctl_display_some_debug(struct MPT3SAS_ADAPTER *ioc, u16 smid, 120f92363d1SSreekanth Reddy char *calling_function_name, MPI2DefaultReply_t *mpi_reply) 121f92363d1SSreekanth Reddy { 122f92363d1SSreekanth Reddy Mpi2ConfigRequest_t *mpi_request; 123f92363d1SSreekanth Reddy char *desc = NULL; 124f92363d1SSreekanth Reddy 125f92363d1SSreekanth Reddy if (!(ioc->logging_level & MPT_DEBUG_IOCTL)) 126f92363d1SSreekanth Reddy return; 127f92363d1SSreekanth Reddy 128f92363d1SSreekanth Reddy mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 129f92363d1SSreekanth Reddy switch (mpi_request->Function) { 130f92363d1SSreekanth Reddy case MPI2_FUNCTION_SCSI_IO_REQUEST: 131f92363d1SSreekanth Reddy { 132f92363d1SSreekanth Reddy Mpi2SCSIIORequest_t *scsi_request = 133f92363d1SSreekanth Reddy (Mpi2SCSIIORequest_t *)mpi_request; 134f92363d1SSreekanth Reddy 135f92363d1SSreekanth Reddy snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 136f92363d1SSreekanth Reddy "scsi_io, cmd(0x%02x), cdb_len(%d)", 137f92363d1SSreekanth Reddy scsi_request->CDB.CDB32[0], 138f92363d1SSreekanth Reddy le16_to_cpu(scsi_request->IoFlags) & 0xF); 139f92363d1SSreekanth Reddy desc = ioc->tmp_string; 140f92363d1SSreekanth Reddy break; 141f92363d1SSreekanth Reddy } 142f92363d1SSreekanth Reddy case MPI2_FUNCTION_SCSI_TASK_MGMT: 143f92363d1SSreekanth Reddy desc = "task_mgmt"; 144f92363d1SSreekanth Reddy break; 145f92363d1SSreekanth Reddy case MPI2_FUNCTION_IOC_INIT: 146f92363d1SSreekanth Reddy desc = "ioc_init"; 147f92363d1SSreekanth Reddy break; 148f92363d1SSreekanth Reddy case MPI2_FUNCTION_IOC_FACTS: 149f92363d1SSreekanth Reddy desc = "ioc_facts"; 150f92363d1SSreekanth Reddy break; 151f92363d1SSreekanth Reddy case MPI2_FUNCTION_CONFIG: 152f92363d1SSreekanth Reddy { 153f92363d1SSreekanth Reddy Mpi2ConfigRequest_t *config_request = 154f92363d1SSreekanth Reddy (Mpi2ConfigRequest_t *)mpi_request; 155f92363d1SSreekanth Reddy 156f92363d1SSreekanth Reddy snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 157f92363d1SSreekanth Reddy "config, type(0x%02x), ext_type(0x%02x), number(%d)", 158f92363d1SSreekanth Reddy (config_request->Header.PageType & 159f92363d1SSreekanth Reddy MPI2_CONFIG_PAGETYPE_MASK), config_request->ExtPageType, 160f92363d1SSreekanth Reddy config_request->Header.PageNumber); 161f92363d1SSreekanth Reddy desc = ioc->tmp_string; 162f92363d1SSreekanth Reddy break; 163f92363d1SSreekanth Reddy } 164f92363d1SSreekanth Reddy case MPI2_FUNCTION_PORT_FACTS: 165f92363d1SSreekanth Reddy desc = "port_facts"; 166f92363d1SSreekanth Reddy break; 167f92363d1SSreekanth Reddy case MPI2_FUNCTION_PORT_ENABLE: 168f92363d1SSreekanth Reddy desc = "port_enable"; 169f92363d1SSreekanth Reddy break; 170f92363d1SSreekanth Reddy case MPI2_FUNCTION_EVENT_NOTIFICATION: 171f92363d1SSreekanth Reddy desc = "event_notification"; 172f92363d1SSreekanth Reddy break; 173f92363d1SSreekanth Reddy case MPI2_FUNCTION_FW_DOWNLOAD: 174f92363d1SSreekanth Reddy desc = "fw_download"; 175f92363d1SSreekanth Reddy break; 176f92363d1SSreekanth Reddy case MPI2_FUNCTION_FW_UPLOAD: 177f92363d1SSreekanth Reddy desc = "fw_upload"; 178f92363d1SSreekanth Reddy break; 179f92363d1SSreekanth Reddy case MPI2_FUNCTION_RAID_ACTION: 180f92363d1SSreekanth Reddy desc = "raid_action"; 181f92363d1SSreekanth Reddy break; 182f92363d1SSreekanth Reddy case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH: 183f92363d1SSreekanth Reddy { 184f92363d1SSreekanth Reddy Mpi2SCSIIORequest_t *scsi_request = 185f92363d1SSreekanth Reddy (Mpi2SCSIIORequest_t *)mpi_request; 186f92363d1SSreekanth Reddy 187f92363d1SSreekanth Reddy snprintf(ioc->tmp_string, MPT_STRING_LENGTH, 188f92363d1SSreekanth Reddy "raid_pass, cmd(0x%02x), cdb_len(%d)", 189f92363d1SSreekanth Reddy scsi_request->CDB.CDB32[0], 190f92363d1SSreekanth Reddy le16_to_cpu(scsi_request->IoFlags) & 0xF); 191f92363d1SSreekanth Reddy desc = ioc->tmp_string; 192f92363d1SSreekanth Reddy break; 193f92363d1SSreekanth Reddy } 194f92363d1SSreekanth Reddy case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL: 195f92363d1SSreekanth Reddy desc = "sas_iounit_cntl"; 196f92363d1SSreekanth Reddy break; 197f92363d1SSreekanth Reddy case MPI2_FUNCTION_SATA_PASSTHROUGH: 198f92363d1SSreekanth Reddy desc = "sata_pass"; 199f92363d1SSreekanth Reddy break; 200f92363d1SSreekanth Reddy case MPI2_FUNCTION_DIAG_BUFFER_POST: 201f92363d1SSreekanth Reddy desc = "diag_buffer_post"; 202f92363d1SSreekanth Reddy break; 203f92363d1SSreekanth Reddy case MPI2_FUNCTION_DIAG_RELEASE: 204f92363d1SSreekanth Reddy desc = "diag_release"; 205f92363d1SSreekanth Reddy break; 206f92363d1SSreekanth Reddy case MPI2_FUNCTION_SMP_PASSTHROUGH: 207f92363d1SSreekanth Reddy desc = "smp_passthrough"; 208f92363d1SSreekanth Reddy break; 209f92363d1SSreekanth Reddy } 210f92363d1SSreekanth Reddy 211f92363d1SSreekanth Reddy if (!desc) 212f92363d1SSreekanth Reddy return; 213f92363d1SSreekanth Reddy 214f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "%s: %s, smid(%d)\n", 215f92363d1SSreekanth Reddy ioc->name, calling_function_name, desc, smid); 216f92363d1SSreekanth Reddy 217f92363d1SSreekanth Reddy if (!mpi_reply) 218f92363d1SSreekanth Reddy return; 219f92363d1SSreekanth Reddy 220f92363d1SSreekanth Reddy if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo) 221f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 222f92363d1SSreekanth Reddy "\tiocstatus(0x%04x), loginfo(0x%08x)\n", 223f92363d1SSreekanth Reddy ioc->name, le16_to_cpu(mpi_reply->IOCStatus), 224f92363d1SSreekanth Reddy le32_to_cpu(mpi_reply->IOCLogInfo)); 225f92363d1SSreekanth Reddy 226f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 227f92363d1SSreekanth Reddy mpi_request->Function == 228f92363d1SSreekanth Reddy MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 229f92363d1SSreekanth Reddy Mpi2SCSIIOReply_t *scsi_reply = 230f92363d1SSreekanth Reddy (Mpi2SCSIIOReply_t *)mpi_reply; 231f92363d1SSreekanth Reddy struct _sas_device *sas_device = NULL; 232f92363d1SSreekanth Reddy unsigned long flags; 233f92363d1SSreekanth Reddy 234f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->sas_device_lock, flags); 235f92363d1SSreekanth Reddy sas_device = _ctl_sas_device_find_by_handle(ioc, 236f92363d1SSreekanth Reddy le16_to_cpu(scsi_reply->DevHandle)); 237f92363d1SSreekanth Reddy if (sas_device) { 238f92363d1SSreekanth Reddy pr_warn(MPT3SAS_FMT "\tsas_address(0x%016llx), phy(%d)\n", 239f92363d1SSreekanth Reddy ioc->name, (unsigned long long) 240f92363d1SSreekanth Reddy sas_device->sas_address, sas_device->phy); 241f92363d1SSreekanth Reddy pr_warn(MPT3SAS_FMT 242f92363d1SSreekanth Reddy "\tenclosure_logical_id(0x%016llx), slot(%d)\n", 243f92363d1SSreekanth Reddy ioc->name, (unsigned long long) 244f92363d1SSreekanth Reddy sas_device->enclosure_logical_id, sas_device->slot); 245f92363d1SSreekanth Reddy } 246f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 247f92363d1SSreekanth Reddy if (scsi_reply->SCSIState || scsi_reply->SCSIStatus) 248f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 249f92363d1SSreekanth Reddy "\tscsi_state(0x%02x), scsi_status" 250f92363d1SSreekanth Reddy "(0x%02x)\n", ioc->name, 251f92363d1SSreekanth Reddy scsi_reply->SCSIState, 252f92363d1SSreekanth Reddy scsi_reply->SCSIStatus); 253f92363d1SSreekanth Reddy } 254f92363d1SSreekanth Reddy } 255f92363d1SSreekanth Reddy 256f92363d1SSreekanth Reddy /** 257f92363d1SSreekanth Reddy * mpt3sas_ctl_done - ctl module completion routine 258f92363d1SSreekanth Reddy * @ioc: per adapter object 259f92363d1SSreekanth Reddy * @smid: system request message index 260f92363d1SSreekanth Reddy * @msix_index: MSIX table index supplied by the OS 261f92363d1SSreekanth Reddy * @reply: reply message frame(lower 32bit addr) 262f92363d1SSreekanth Reddy * Context: none. 263f92363d1SSreekanth Reddy * 264f92363d1SSreekanth Reddy * The callback handler when using ioc->ctl_cb_idx. 265f92363d1SSreekanth Reddy * 266f92363d1SSreekanth Reddy * Return 1 meaning mf should be freed from _base_interrupt 267f92363d1SSreekanth Reddy * 0 means the mf is freed from this function. 268f92363d1SSreekanth Reddy */ 269f92363d1SSreekanth Reddy u8 270f92363d1SSreekanth Reddy mpt3sas_ctl_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, 271f92363d1SSreekanth Reddy u32 reply) 272f92363d1SSreekanth Reddy { 273f92363d1SSreekanth Reddy MPI2DefaultReply_t *mpi_reply; 274f92363d1SSreekanth Reddy Mpi2SCSIIOReply_t *scsiio_reply; 275*aff39e61SSuganath Prabu Subramani Mpi26NVMeEncapsulatedErrorReply_t *nvme_error_reply; 276f92363d1SSreekanth Reddy const void *sense_data; 277f92363d1SSreekanth Reddy u32 sz; 278f92363d1SSreekanth Reddy 279f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status == MPT3_CMD_NOT_USED) 280f92363d1SSreekanth Reddy return 1; 281f92363d1SSreekanth Reddy if (ioc->ctl_cmds.smid != smid) 282f92363d1SSreekanth Reddy return 1; 283f92363d1SSreekanth Reddy ioc->ctl_cmds.status |= MPT3_CMD_COMPLETE; 284f92363d1SSreekanth Reddy mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 285f92363d1SSreekanth Reddy if (mpi_reply) { 286f92363d1SSreekanth Reddy memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4); 287f92363d1SSreekanth Reddy ioc->ctl_cmds.status |= MPT3_CMD_REPLY_VALID; 288f92363d1SSreekanth Reddy /* get sense data */ 289f92363d1SSreekanth Reddy if (mpi_reply->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 290f92363d1SSreekanth Reddy mpi_reply->Function == 291f92363d1SSreekanth Reddy MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 292f92363d1SSreekanth Reddy scsiio_reply = (Mpi2SCSIIOReply_t *)mpi_reply; 293f92363d1SSreekanth Reddy if (scsiio_reply->SCSIState & 294f92363d1SSreekanth Reddy MPI2_SCSI_STATE_AUTOSENSE_VALID) { 295f92363d1SSreekanth Reddy sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, 296f92363d1SSreekanth Reddy le32_to_cpu(scsiio_reply->SenseCount)); 297f92363d1SSreekanth Reddy sense_data = mpt3sas_base_get_sense_buffer(ioc, 298f92363d1SSreekanth Reddy smid); 299f92363d1SSreekanth Reddy memcpy(ioc->ctl_cmds.sense, sense_data, sz); 300f92363d1SSreekanth Reddy } 301f92363d1SSreekanth Reddy } 302*aff39e61SSuganath Prabu Subramani /* 303*aff39e61SSuganath Prabu Subramani * Get Error Response data for NVMe device. The ctl_cmds.sense 304*aff39e61SSuganath Prabu Subramani * buffer is used to store the Error Response data. 305*aff39e61SSuganath Prabu Subramani */ 306*aff39e61SSuganath Prabu Subramani if (mpi_reply->Function == MPI2_FUNCTION_NVME_ENCAPSULATED) { 307*aff39e61SSuganath Prabu Subramani nvme_error_reply = 308*aff39e61SSuganath Prabu Subramani (Mpi26NVMeEncapsulatedErrorReply_t *)mpi_reply; 309*aff39e61SSuganath Prabu Subramani sz = min_t(u32, NVME_ERROR_RESPONSE_SIZE, 310*aff39e61SSuganath Prabu Subramani le32_to_cpu(nvme_error_reply->ErrorResponseCount)); 311*aff39e61SSuganath Prabu Subramani sense_data = mpt3sas_base_get_sense_buffer(ioc, smid); 312*aff39e61SSuganath Prabu Subramani memcpy(ioc->ctl_cmds.sense, sense_data, sz); 313*aff39e61SSuganath Prabu Subramani } 314f92363d1SSreekanth Reddy } 315016d5c35SSuganath Prabu Subramani 316f92363d1SSreekanth Reddy _ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply); 317f92363d1SSreekanth Reddy ioc->ctl_cmds.status &= ~MPT3_CMD_PENDING; 318f92363d1SSreekanth Reddy complete(&ioc->ctl_cmds.done); 319f92363d1SSreekanth Reddy return 1; 320f92363d1SSreekanth Reddy } 321f92363d1SSreekanth Reddy 322f92363d1SSreekanth Reddy /** 323f92363d1SSreekanth Reddy * _ctl_check_event_type - determines when an event needs logging 324f92363d1SSreekanth Reddy * @ioc: per adapter object 325f92363d1SSreekanth Reddy * @event: firmware event 326f92363d1SSreekanth Reddy * 327f92363d1SSreekanth Reddy * The bitmask in ioc->event_type[] indicates which events should be 328f92363d1SSreekanth Reddy * be saved in the driver event_log. This bitmask is set by application. 329f92363d1SSreekanth Reddy * 330f92363d1SSreekanth Reddy * Returns 1 when event should be captured, or zero means no match. 331f92363d1SSreekanth Reddy */ 332f92363d1SSreekanth Reddy static int 333f92363d1SSreekanth Reddy _ctl_check_event_type(struct MPT3SAS_ADAPTER *ioc, u16 event) 334f92363d1SSreekanth Reddy { 335f92363d1SSreekanth Reddy u16 i; 336f92363d1SSreekanth Reddy u32 desired_event; 337f92363d1SSreekanth Reddy 338f92363d1SSreekanth Reddy if (event >= 128 || !event || !ioc->event_log) 339f92363d1SSreekanth Reddy return 0; 340f92363d1SSreekanth Reddy 341f92363d1SSreekanth Reddy desired_event = (1 << (event % 32)); 342f92363d1SSreekanth Reddy if (!desired_event) 343f92363d1SSreekanth Reddy desired_event = 1; 344f92363d1SSreekanth Reddy i = event / 32; 345f92363d1SSreekanth Reddy return desired_event & ioc->event_type[i]; 346f92363d1SSreekanth Reddy } 347f92363d1SSreekanth Reddy 348f92363d1SSreekanth Reddy /** 349f92363d1SSreekanth Reddy * mpt3sas_ctl_add_to_event_log - add event 350f92363d1SSreekanth Reddy * @ioc: per adapter object 351f92363d1SSreekanth Reddy * @mpi_reply: reply message frame 352f92363d1SSreekanth Reddy * 353f92363d1SSreekanth Reddy * Return nothing. 354f92363d1SSreekanth Reddy */ 355f92363d1SSreekanth Reddy void 356f92363d1SSreekanth Reddy mpt3sas_ctl_add_to_event_log(struct MPT3SAS_ADAPTER *ioc, 357f92363d1SSreekanth Reddy Mpi2EventNotificationReply_t *mpi_reply) 358f92363d1SSreekanth Reddy { 359f92363d1SSreekanth Reddy struct MPT3_IOCTL_EVENTS *event_log; 360f92363d1SSreekanth Reddy u16 event; 361f92363d1SSreekanth Reddy int i; 362f92363d1SSreekanth Reddy u32 sz, event_data_sz; 363f92363d1SSreekanth Reddy u8 send_aen = 0; 364f92363d1SSreekanth Reddy 365f92363d1SSreekanth Reddy if (!ioc->event_log) 366f92363d1SSreekanth Reddy return; 367f92363d1SSreekanth Reddy 368f92363d1SSreekanth Reddy event = le16_to_cpu(mpi_reply->Event); 369f92363d1SSreekanth Reddy 370f92363d1SSreekanth Reddy if (_ctl_check_event_type(ioc, event)) { 371f92363d1SSreekanth Reddy 372f92363d1SSreekanth Reddy /* insert entry into circular event_log */ 373f92363d1SSreekanth Reddy i = ioc->event_context % MPT3SAS_CTL_EVENT_LOG_SIZE; 374f92363d1SSreekanth Reddy event_log = ioc->event_log; 375f92363d1SSreekanth Reddy event_log[i].event = event; 376f92363d1SSreekanth Reddy event_log[i].context = ioc->event_context++; 377f92363d1SSreekanth Reddy 378f92363d1SSreekanth Reddy event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4; 379f92363d1SSreekanth Reddy sz = min_t(u32, event_data_sz, MPT3_EVENT_DATA_SIZE); 380f92363d1SSreekanth Reddy memset(event_log[i].data, 0, MPT3_EVENT_DATA_SIZE); 381f92363d1SSreekanth Reddy memcpy(event_log[i].data, mpi_reply->EventData, sz); 382f92363d1SSreekanth Reddy send_aen = 1; 383f92363d1SSreekanth Reddy } 384f92363d1SSreekanth Reddy 385f92363d1SSreekanth Reddy /* This aen_event_read_flag flag is set until the 386f92363d1SSreekanth Reddy * application has read the event log. 387f92363d1SSreekanth Reddy * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify. 388f92363d1SSreekanth Reddy */ 389f92363d1SSreekanth Reddy if (event == MPI2_EVENT_LOG_ENTRY_ADDED || 390f92363d1SSreekanth Reddy (send_aen && !ioc->aen_event_read_flag)) { 391f92363d1SSreekanth Reddy ioc->aen_event_read_flag = 1; 392f92363d1SSreekanth Reddy wake_up_interruptible(&ctl_poll_wait); 393f92363d1SSreekanth Reddy if (async_queue) 394f92363d1SSreekanth Reddy kill_fasync(&async_queue, SIGIO, POLL_IN); 395f92363d1SSreekanth Reddy } 396f92363d1SSreekanth Reddy } 397f92363d1SSreekanth Reddy 398f92363d1SSreekanth Reddy /** 399f92363d1SSreekanth Reddy * mpt3sas_ctl_event_callback - firmware event handler (called at ISR time) 400f92363d1SSreekanth Reddy * @ioc: per adapter object 401f92363d1SSreekanth Reddy * @msix_index: MSIX table index supplied by the OS 402f92363d1SSreekanth Reddy * @reply: reply message frame(lower 32bit addr) 403f92363d1SSreekanth Reddy * Context: interrupt. 404f92363d1SSreekanth Reddy * 405f92363d1SSreekanth Reddy * This function merely adds a new work task into ioc->firmware_event_thread. 406f92363d1SSreekanth Reddy * The tasks are worked from _firmware_event_work in user context. 407f92363d1SSreekanth Reddy * 408f92363d1SSreekanth Reddy * Return 1 meaning mf should be freed from _base_interrupt 409f92363d1SSreekanth Reddy * 0 means the mf is freed from this function. 410f92363d1SSreekanth Reddy */ 411f92363d1SSreekanth Reddy u8 412f92363d1SSreekanth Reddy mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index, 413f92363d1SSreekanth Reddy u32 reply) 414f92363d1SSreekanth Reddy { 415f92363d1SSreekanth Reddy Mpi2EventNotificationReply_t *mpi_reply; 416f92363d1SSreekanth Reddy 417f92363d1SSreekanth Reddy mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 418869817f9SSuganath prabu Subramani if (mpi_reply) 419f92363d1SSreekanth Reddy mpt3sas_ctl_add_to_event_log(ioc, mpi_reply); 420f92363d1SSreekanth Reddy return 1; 421f92363d1SSreekanth Reddy } 422f92363d1SSreekanth Reddy 423f92363d1SSreekanth Reddy /** 424f92363d1SSreekanth Reddy * _ctl_verify_adapter - validates ioc_number passed from application 425f92363d1SSreekanth Reddy * @ioc: per adapter object 426f92363d1SSreekanth Reddy * @iocpp: The ioc pointer is returned in this. 427c84b06a4SSreekanth Reddy * @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device & 428b130b0d5SSuganath prabu Subramani * MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device. 429f92363d1SSreekanth Reddy * 430f92363d1SSreekanth Reddy * Return (-1) means error, else ioc_number. 431f92363d1SSreekanth Reddy */ 432f92363d1SSreekanth Reddy static int 433c84b06a4SSreekanth Reddy _ctl_verify_adapter(int ioc_number, struct MPT3SAS_ADAPTER **iocpp, 434c84b06a4SSreekanth Reddy int mpi_version) 435f92363d1SSreekanth Reddy { 436f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 437b130b0d5SSuganath prabu Subramani int version = 0; 43808c4d550SSreekanth Reddy /* global ioc lock to protect controller on list operations */ 43908c4d550SSreekanth Reddy spin_lock(&gioc_lock); 440f92363d1SSreekanth Reddy list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 441f92363d1SSreekanth Reddy if (ioc->id != ioc_number) 442f92363d1SSreekanth Reddy continue; 443c84b06a4SSreekanth Reddy /* Check whether this ioctl command is from right 444c84b06a4SSreekanth Reddy * ioctl device or not, if not continue the search. 445c84b06a4SSreekanth Reddy */ 446b130b0d5SSuganath prabu Subramani version = ioc->hba_mpi_version_belonged; 447b130b0d5SSuganath prabu Subramani /* MPI25_VERSION and MPI26_VERSION uses same ioctl 448b130b0d5SSuganath prabu Subramani * device. 449b130b0d5SSuganath prabu Subramani */ 450b130b0d5SSuganath prabu Subramani if (mpi_version == (MPI25_VERSION | MPI26_VERSION)) { 451b130b0d5SSuganath prabu Subramani if ((version == MPI25_VERSION) || 452b130b0d5SSuganath prabu Subramani (version == MPI26_VERSION)) 453b130b0d5SSuganath prabu Subramani goto out; 454b130b0d5SSuganath prabu Subramani else 455c84b06a4SSreekanth Reddy continue; 456b130b0d5SSuganath prabu Subramani } else { 457b130b0d5SSuganath prabu Subramani if (version != mpi_version) 458b130b0d5SSuganath prabu Subramani continue; 459b130b0d5SSuganath prabu Subramani } 460b130b0d5SSuganath prabu Subramani out: 46108c4d550SSreekanth Reddy spin_unlock(&gioc_lock); 462f92363d1SSreekanth Reddy *iocpp = ioc; 463f92363d1SSreekanth Reddy return ioc_number; 464f92363d1SSreekanth Reddy } 46508c4d550SSreekanth Reddy spin_unlock(&gioc_lock); 466f92363d1SSreekanth Reddy *iocpp = NULL; 467f92363d1SSreekanth Reddy return -1; 468f92363d1SSreekanth Reddy } 469f92363d1SSreekanth Reddy 470f92363d1SSreekanth Reddy /** 471f92363d1SSreekanth Reddy * mpt3sas_ctl_reset_handler - reset callback handler (for ctl) 472f92363d1SSreekanth Reddy * @ioc: per adapter object 473f92363d1SSreekanth Reddy * @reset_phase: phase 474f92363d1SSreekanth Reddy * 475f92363d1SSreekanth Reddy * The handler for doing any required cleanup or initialization. 476f92363d1SSreekanth Reddy * 477f92363d1SSreekanth Reddy * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET, 478f92363d1SSreekanth Reddy * MPT3_IOC_DONE_RESET 479f92363d1SSreekanth Reddy */ 480f92363d1SSreekanth Reddy void 481f92363d1SSreekanth Reddy mpt3sas_ctl_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase) 482f92363d1SSreekanth Reddy { 483f92363d1SSreekanth Reddy int i; 484f92363d1SSreekanth Reddy u8 issue_reset; 485f92363d1SSreekanth Reddy 486f92363d1SSreekanth Reddy switch (reset_phase) { 487f92363d1SSreekanth Reddy case MPT3_IOC_PRE_RESET: 488f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 489f92363d1SSreekanth Reddy "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__)); 490f92363d1SSreekanth Reddy for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 491f92363d1SSreekanth Reddy if (!(ioc->diag_buffer_status[i] & 492f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED)) 493f92363d1SSreekanth Reddy continue; 494f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[i] & 495f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 496f92363d1SSreekanth Reddy continue; 497f92363d1SSreekanth Reddy mpt3sas_send_diag_release(ioc, i, &issue_reset); 498f92363d1SSreekanth Reddy } 499f92363d1SSreekanth Reddy break; 500f92363d1SSreekanth Reddy case MPT3_IOC_AFTER_RESET: 501f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 502f92363d1SSreekanth Reddy "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__)); 503f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status & MPT3_CMD_PENDING) { 504f92363d1SSreekanth Reddy ioc->ctl_cmds.status |= MPT3_CMD_RESET; 505f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, ioc->ctl_cmds.smid); 506f92363d1SSreekanth Reddy complete(&ioc->ctl_cmds.done); 507f92363d1SSreekanth Reddy } 508f92363d1SSreekanth Reddy break; 509f92363d1SSreekanth Reddy case MPT3_IOC_DONE_RESET: 510f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 511f92363d1SSreekanth Reddy "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__)); 512f92363d1SSreekanth Reddy 513f92363d1SSreekanth Reddy for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 514f92363d1SSreekanth Reddy if (!(ioc->diag_buffer_status[i] & 515f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED)) 516f92363d1SSreekanth Reddy continue; 517f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[i] & 518f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 519f92363d1SSreekanth Reddy continue; 520f92363d1SSreekanth Reddy ioc->diag_buffer_status[i] |= 521f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_DIAG_RESET; 522f92363d1SSreekanth Reddy } 523f92363d1SSreekanth Reddy break; 524f92363d1SSreekanth Reddy } 525f92363d1SSreekanth Reddy } 526f92363d1SSreekanth Reddy 527f92363d1SSreekanth Reddy /** 528c84b06a4SSreekanth Reddy * _ctl_fasync - 529f92363d1SSreekanth Reddy * @fd - 530f92363d1SSreekanth Reddy * @filep - 531f92363d1SSreekanth Reddy * @mode - 532f92363d1SSreekanth Reddy * 533f92363d1SSreekanth Reddy * Called when application request fasyn callback handler. 534f92363d1SSreekanth Reddy */ 5358bbb1cf6SCalvin Owens static int 536c84b06a4SSreekanth Reddy _ctl_fasync(int fd, struct file *filep, int mode) 537f92363d1SSreekanth Reddy { 538f92363d1SSreekanth Reddy return fasync_helper(fd, filep, mode, &async_queue); 539f92363d1SSreekanth Reddy } 540f92363d1SSreekanth Reddy 541f92363d1SSreekanth Reddy /** 542c84b06a4SSreekanth Reddy * _ctl_poll - 543f92363d1SSreekanth Reddy * @file - 544f92363d1SSreekanth Reddy * @wait - 545f92363d1SSreekanth Reddy * 546f92363d1SSreekanth Reddy */ 5478bbb1cf6SCalvin Owens static unsigned int 548c84b06a4SSreekanth Reddy _ctl_poll(struct file *filep, poll_table *wait) 549f92363d1SSreekanth Reddy { 550f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 551f92363d1SSreekanth Reddy 552f92363d1SSreekanth Reddy poll_wait(filep, &ctl_poll_wait, wait); 553f92363d1SSreekanth Reddy 55408c4d550SSreekanth Reddy /* global ioc lock to protect controller on list operations */ 55508c4d550SSreekanth Reddy spin_lock(&gioc_lock); 556f92363d1SSreekanth Reddy list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 55708c4d550SSreekanth Reddy if (ioc->aen_event_read_flag) { 55808c4d550SSreekanth Reddy spin_unlock(&gioc_lock); 559f92363d1SSreekanth Reddy return POLLIN | POLLRDNORM; 560f92363d1SSreekanth Reddy } 56108c4d550SSreekanth Reddy } 56208c4d550SSreekanth Reddy spin_unlock(&gioc_lock); 563f92363d1SSreekanth Reddy return 0; 564f92363d1SSreekanth Reddy } 565f92363d1SSreekanth Reddy 566f92363d1SSreekanth Reddy /** 567f92363d1SSreekanth Reddy * _ctl_set_task_mid - assign an active smid to tm request 568f92363d1SSreekanth Reddy * @ioc: per adapter object 569f92363d1SSreekanth Reddy * @karg - (struct mpt3_ioctl_command) 570f92363d1SSreekanth Reddy * @tm_request - pointer to mf from user space 571f92363d1SSreekanth Reddy * 572f92363d1SSreekanth Reddy * Returns 0 when an smid if found, else fail. 573f92363d1SSreekanth Reddy * during failure, the reply frame is filled. 574f92363d1SSreekanth Reddy */ 575f92363d1SSreekanth Reddy static int 576f92363d1SSreekanth Reddy _ctl_set_task_mid(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command *karg, 577f92363d1SSreekanth Reddy Mpi2SCSITaskManagementRequest_t *tm_request) 578f92363d1SSreekanth Reddy { 579f92363d1SSreekanth Reddy u8 found = 0; 580f92363d1SSreekanth Reddy u16 i; 581f92363d1SSreekanth Reddy u16 handle; 582f92363d1SSreekanth Reddy struct scsi_cmnd *scmd; 583f92363d1SSreekanth Reddy struct MPT3SAS_DEVICE *priv_data; 584f92363d1SSreekanth Reddy unsigned long flags; 585f92363d1SSreekanth Reddy Mpi2SCSITaskManagementReply_t *tm_reply; 586f92363d1SSreekanth Reddy u32 sz; 587f92363d1SSreekanth Reddy u32 lun; 588f92363d1SSreekanth Reddy char *desc = NULL; 589f92363d1SSreekanth Reddy 590f92363d1SSreekanth Reddy if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK) 591f92363d1SSreekanth Reddy desc = "abort_task"; 592f92363d1SSreekanth Reddy else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) 593f92363d1SSreekanth Reddy desc = "query_task"; 594f92363d1SSreekanth Reddy else 595f92363d1SSreekanth Reddy return 0; 596f92363d1SSreekanth Reddy 597f92363d1SSreekanth Reddy lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN); 598f92363d1SSreekanth Reddy 599f92363d1SSreekanth Reddy handle = le16_to_cpu(tm_request->DevHandle); 600f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 601f92363d1SSreekanth Reddy for (i = ioc->scsiio_depth; i && !found; i--) { 602f92363d1SSreekanth Reddy scmd = ioc->scsi_lookup[i - 1].scmd; 603f92363d1SSreekanth Reddy if (scmd == NULL || scmd->device == NULL || 604f92363d1SSreekanth Reddy scmd->device->hostdata == NULL) 605f92363d1SSreekanth Reddy continue; 606f92363d1SSreekanth Reddy if (lun != scmd->device->lun) 607f92363d1SSreekanth Reddy continue; 608f92363d1SSreekanth Reddy priv_data = scmd->device->hostdata; 609f92363d1SSreekanth Reddy if (priv_data->sas_target == NULL) 610f92363d1SSreekanth Reddy continue; 611f92363d1SSreekanth Reddy if (priv_data->sas_target->handle != handle) 612f92363d1SSreekanth Reddy continue; 613f92363d1SSreekanth Reddy tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid); 614f92363d1SSreekanth Reddy found = 1; 615f92363d1SSreekanth Reddy } 616f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 617f92363d1SSreekanth Reddy 618f92363d1SSreekanth Reddy if (!found) { 619f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 620f92363d1SSreekanth Reddy "%s: handle(0x%04x), lun(%d), no active mid!!\n", 621f92363d1SSreekanth Reddy ioc->name, 622f92363d1SSreekanth Reddy desc, le16_to_cpu(tm_request->DevHandle), lun)); 623f92363d1SSreekanth Reddy tm_reply = ioc->ctl_cmds.reply; 624f92363d1SSreekanth Reddy tm_reply->DevHandle = tm_request->DevHandle; 625f92363d1SSreekanth Reddy tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 626f92363d1SSreekanth Reddy tm_reply->TaskType = tm_request->TaskType; 627f92363d1SSreekanth Reddy tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4; 628f92363d1SSreekanth Reddy tm_reply->VP_ID = tm_request->VP_ID; 629f92363d1SSreekanth Reddy tm_reply->VF_ID = tm_request->VF_ID; 630f92363d1SSreekanth Reddy sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz); 631f92363d1SSreekanth Reddy if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply, 632f92363d1SSreekanth Reddy sz)) 633f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 634f92363d1SSreekanth Reddy __LINE__, __func__); 635f92363d1SSreekanth Reddy return 1; 636f92363d1SSreekanth Reddy } 637f92363d1SSreekanth Reddy 638f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 639f92363d1SSreekanth Reddy "%s: handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name, 640f92363d1SSreekanth Reddy desc, le16_to_cpu(tm_request->DevHandle), lun, 641f92363d1SSreekanth Reddy le16_to_cpu(tm_request->TaskMID))); 642f92363d1SSreekanth Reddy return 0; 643f92363d1SSreekanth Reddy } 644f92363d1SSreekanth Reddy 645f92363d1SSreekanth Reddy /** 646f92363d1SSreekanth Reddy * _ctl_do_mpt_command - main handler for MPT3COMMAND opcode 647f92363d1SSreekanth Reddy * @ioc: per adapter object 648f92363d1SSreekanth Reddy * @karg - (struct mpt3_ioctl_command) 649f92363d1SSreekanth Reddy * @mf - pointer to mf in user space 650f92363d1SSreekanth Reddy */ 651f92363d1SSreekanth Reddy static long 652f92363d1SSreekanth Reddy _ctl_do_mpt_command(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command karg, 653f92363d1SSreekanth Reddy void __user *mf) 654f92363d1SSreekanth Reddy { 655f92363d1SSreekanth Reddy MPI2RequestHeader_t *mpi_request = NULL, *request; 656f92363d1SSreekanth Reddy MPI2DefaultReply_t *mpi_reply; 657*aff39e61SSuganath Prabu Subramani Mpi26NVMeEncapsulatedRequest_t *nvme_encap_request = NULL; 658f92363d1SSreekanth Reddy u32 ioc_state; 659f92363d1SSreekanth Reddy u16 smid; 6608bbb1cf6SCalvin Owens unsigned long timeout; 661f92363d1SSreekanth Reddy u8 issue_reset; 662*aff39e61SSuganath Prabu Subramani u32 sz, sz_arg; 663f92363d1SSreekanth Reddy void *psge; 664f92363d1SSreekanth Reddy void *data_out = NULL; 665f92363d1SSreekanth Reddy dma_addr_t data_out_dma = 0; 666f92363d1SSreekanth Reddy size_t data_out_sz = 0; 667f92363d1SSreekanth Reddy void *data_in = NULL; 668f92363d1SSreekanth Reddy dma_addr_t data_in_dma = 0; 669f92363d1SSreekanth Reddy size_t data_in_sz = 0; 670f92363d1SSreekanth Reddy long ret; 671f92363d1SSreekanth Reddy u16 wait_state_count; 672c696f7b8SSuganath Prabu Subramani u16 device_handle = MPT3SAS_INVALID_DEVICE_HANDLE; 673f92363d1SSreekanth Reddy 674f92363d1SSreekanth Reddy issue_reset = 0; 675f92363d1SSreekanth Reddy 676f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 677f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 678f92363d1SSreekanth Reddy ioc->name, __func__); 679f92363d1SSreekanth Reddy ret = -EAGAIN; 680f92363d1SSreekanth Reddy goto out; 681f92363d1SSreekanth Reddy } 682f92363d1SSreekanth Reddy 683f92363d1SSreekanth Reddy wait_state_count = 0; 684f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 685f92363d1SSreekanth Reddy while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 686f92363d1SSreekanth Reddy if (wait_state_count++ == 10) { 687f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 688f92363d1SSreekanth Reddy "%s: failed due to ioc not operational\n", 689f92363d1SSreekanth Reddy ioc->name, __func__); 690f92363d1SSreekanth Reddy ret = -EFAULT; 691f92363d1SSreekanth Reddy goto out; 692f92363d1SSreekanth Reddy } 693f92363d1SSreekanth Reddy ssleep(1); 694f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 695f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 696f92363d1SSreekanth Reddy "%s: waiting for operational state(count=%d)\n", 697f92363d1SSreekanth Reddy ioc->name, 698f92363d1SSreekanth Reddy __func__, wait_state_count); 699f92363d1SSreekanth Reddy } 700f92363d1SSreekanth Reddy if (wait_state_count) 701f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "%s: ioc is operational\n", 702f92363d1SSreekanth Reddy ioc->name, __func__); 703f92363d1SSreekanth Reddy 704f92363d1SSreekanth Reddy mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL); 705f92363d1SSreekanth Reddy if (!mpi_request) { 706f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 707f92363d1SSreekanth Reddy "%s: failed obtaining a memory for mpi_request\n", 708f92363d1SSreekanth Reddy ioc->name, __func__); 709f92363d1SSreekanth Reddy ret = -ENOMEM; 710f92363d1SSreekanth Reddy goto out; 711f92363d1SSreekanth Reddy } 712f92363d1SSreekanth Reddy 713f92363d1SSreekanth Reddy /* Check for overflow and wraparound */ 714f92363d1SSreekanth Reddy if (karg.data_sge_offset * 4 > ioc->request_sz || 715f92363d1SSreekanth Reddy karg.data_sge_offset > (UINT_MAX / 4)) { 716f92363d1SSreekanth Reddy ret = -EINVAL; 717f92363d1SSreekanth Reddy goto out; 718f92363d1SSreekanth Reddy } 719f92363d1SSreekanth Reddy 720f92363d1SSreekanth Reddy /* copy in request message frame from user */ 721f92363d1SSreekanth Reddy if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) { 722f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__, 723f92363d1SSreekanth Reddy __func__); 724f92363d1SSreekanth Reddy ret = -EFAULT; 725f92363d1SSreekanth Reddy goto out; 726f92363d1SSreekanth Reddy } 727f92363d1SSreekanth Reddy 728f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 729f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx); 730f92363d1SSreekanth Reddy if (!smid) { 731f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 732f92363d1SSreekanth Reddy ioc->name, __func__); 733f92363d1SSreekanth Reddy ret = -EAGAIN; 734f92363d1SSreekanth Reddy goto out; 735f92363d1SSreekanth Reddy } 736f92363d1SSreekanth Reddy } else { 737f92363d1SSreekanth Reddy 738f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->ctl_cb_idx, NULL); 739f92363d1SSreekanth Reddy if (!smid) { 740f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 741f92363d1SSreekanth Reddy ioc->name, __func__); 742f92363d1SSreekanth Reddy ret = -EAGAIN; 743f92363d1SSreekanth Reddy goto out; 744f92363d1SSreekanth Reddy } 745f92363d1SSreekanth Reddy } 746f92363d1SSreekanth Reddy 747f92363d1SSreekanth Reddy ret = 0; 748f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 749f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 750f92363d1SSreekanth Reddy request = mpt3sas_base_get_msg_frame(ioc, smid); 751f92363d1SSreekanth Reddy memcpy(request, mpi_request, karg.data_sge_offset*4); 752f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 753f92363d1SSreekanth Reddy data_out_sz = karg.data_out_size; 754f92363d1SSreekanth Reddy data_in_sz = karg.data_in_size; 755f92363d1SSreekanth Reddy 756f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 757c696f7b8SSuganath Prabu Subramani mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || 758c696f7b8SSuganath Prabu Subramani mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT || 759*aff39e61SSuganath Prabu Subramani mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH || 760*aff39e61SSuganath Prabu Subramani mpi_request->Function == MPI2_FUNCTION_NVME_ENCAPSULATED) { 761c696f7b8SSuganath Prabu Subramani 762c696f7b8SSuganath Prabu Subramani device_handle = le16_to_cpu(mpi_request->FunctionDependent1); 763c696f7b8SSuganath Prabu Subramani if (!device_handle || (device_handle > 764c696f7b8SSuganath Prabu Subramani ioc->facts.MaxDevHandle)) { 765f92363d1SSreekanth Reddy ret = -EINVAL; 766f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 767f92363d1SSreekanth Reddy goto out; 768f92363d1SSreekanth Reddy } 769f92363d1SSreekanth Reddy } 770f92363d1SSreekanth Reddy 771f92363d1SSreekanth Reddy /* obtain dma-able memory for data transfer */ 772f92363d1SSreekanth Reddy if (data_out_sz) /* WRITE */ { 773f92363d1SSreekanth Reddy data_out = pci_alloc_consistent(ioc->pdev, data_out_sz, 774f92363d1SSreekanth Reddy &data_out_dma); 775f92363d1SSreekanth Reddy if (!data_out) { 776f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 777f92363d1SSreekanth Reddy __LINE__, __func__); 778f92363d1SSreekanth Reddy ret = -ENOMEM; 779f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 780f92363d1SSreekanth Reddy goto out; 781f92363d1SSreekanth Reddy } 782f92363d1SSreekanth Reddy if (copy_from_user(data_out, karg.data_out_buf_ptr, 783f92363d1SSreekanth Reddy data_out_sz)) { 784f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 785f92363d1SSreekanth Reddy __LINE__, __func__); 786f92363d1SSreekanth Reddy ret = -EFAULT; 787f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 788f92363d1SSreekanth Reddy goto out; 789f92363d1SSreekanth Reddy } 790f92363d1SSreekanth Reddy } 791f92363d1SSreekanth Reddy 792f92363d1SSreekanth Reddy if (data_in_sz) /* READ */ { 793f92363d1SSreekanth Reddy data_in = pci_alloc_consistent(ioc->pdev, data_in_sz, 794f92363d1SSreekanth Reddy &data_in_dma); 795f92363d1SSreekanth Reddy if (!data_in) { 796f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 797f92363d1SSreekanth Reddy __LINE__, __func__); 798f92363d1SSreekanth Reddy ret = -ENOMEM; 799f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 800f92363d1SSreekanth Reddy goto out; 801f92363d1SSreekanth Reddy } 802f92363d1SSreekanth Reddy } 803f92363d1SSreekanth Reddy 804f92363d1SSreekanth Reddy psge = (void *)request + (karg.data_sge_offset*4); 805f92363d1SSreekanth Reddy 806f92363d1SSreekanth Reddy /* send command to firmware */ 807f92363d1SSreekanth Reddy _ctl_display_some_debug(ioc, smid, "ctl_request", NULL); 808f92363d1SSreekanth Reddy 809f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 810f92363d1SSreekanth Reddy switch (mpi_request->Function) { 811*aff39e61SSuganath Prabu Subramani case MPI2_FUNCTION_NVME_ENCAPSULATED: 812*aff39e61SSuganath Prabu Subramani { 813*aff39e61SSuganath Prabu Subramani nvme_encap_request = (Mpi26NVMeEncapsulatedRequest_t *)request; 814*aff39e61SSuganath Prabu Subramani /* 815*aff39e61SSuganath Prabu Subramani * Get the Physical Address of the sense buffer. 816*aff39e61SSuganath Prabu Subramani * Use Error Response buffer address field to hold the sense 817*aff39e61SSuganath Prabu Subramani * buffer address. 818*aff39e61SSuganath Prabu Subramani * Clear the internal sense buffer, which will potentially hold 819*aff39e61SSuganath Prabu Subramani * the Completion Queue Entry on return, or 0 if no Entry. 820*aff39e61SSuganath Prabu Subramani * Build the PRPs and set direction bits. 821*aff39e61SSuganath Prabu Subramani * Send the request. 822*aff39e61SSuganath Prabu Subramani */ 823*aff39e61SSuganath Prabu Subramani nvme_encap_request->ErrorResponseBaseAddress = ioc->sense_dma & 824*aff39e61SSuganath Prabu Subramani 0xFFFFFFFF00000000; 825*aff39e61SSuganath Prabu Subramani nvme_encap_request->ErrorResponseBaseAddress |= 826*aff39e61SSuganath Prabu Subramani (U64)mpt3sas_base_get_sense_buffer_dma(ioc, smid); 827*aff39e61SSuganath Prabu Subramani nvme_encap_request->ErrorResponseAllocationLength = 828*aff39e61SSuganath Prabu Subramani NVME_ERROR_RESPONSE_SIZE; 829*aff39e61SSuganath Prabu Subramani memset(ioc->ctl_cmds.sense, 0, NVME_ERROR_RESPONSE_SIZE); 830*aff39e61SSuganath Prabu Subramani ioc->build_nvme_prp(ioc, smid, nvme_encap_request, 831*aff39e61SSuganath Prabu Subramani data_out_dma, data_out_sz, data_in_dma, data_in_sz); 832*aff39e61SSuganath Prabu Subramani if (test_bit(device_handle, ioc->device_remove_in_progress)) { 833*aff39e61SSuganath Prabu Subramani dtmprintk(ioc, pr_info(MPT3SAS_FMT "handle(0x%04x) :" 834*aff39e61SSuganath Prabu Subramani "ioctl failed due to device removal in progress\n", 835*aff39e61SSuganath Prabu Subramani ioc->name, device_handle)); 836*aff39e61SSuganath Prabu Subramani mpt3sas_base_free_smid(ioc, smid); 837*aff39e61SSuganath Prabu Subramani ret = -EINVAL; 838*aff39e61SSuganath Prabu Subramani goto out; 839*aff39e61SSuganath Prabu Subramani } 840*aff39e61SSuganath Prabu Subramani ioc->put_smid_nvme_encap(ioc, smid); 841*aff39e61SSuganath Prabu Subramani break; 842*aff39e61SSuganath Prabu Subramani } 843f92363d1SSreekanth Reddy case MPI2_FUNCTION_SCSI_IO_REQUEST: 844f92363d1SSreekanth Reddy case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH: 845f92363d1SSreekanth Reddy { 846f92363d1SSreekanth Reddy Mpi2SCSIIORequest_t *scsiio_request = 847f92363d1SSreekanth Reddy (Mpi2SCSIIORequest_t *)request; 848f92363d1SSreekanth Reddy scsiio_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 849f92363d1SSreekanth Reddy scsiio_request->SenseBufferLowAddress = 850f92363d1SSreekanth Reddy mpt3sas_base_get_sense_buffer_dma(ioc, smid); 851f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE); 852c696f7b8SSuganath Prabu Subramani if (test_bit(device_handle, ioc->device_remove_in_progress)) { 853c696f7b8SSuganath Prabu Subramani dtmprintk(ioc, pr_info(MPT3SAS_FMT 854c696f7b8SSuganath Prabu Subramani "handle(0x%04x) :ioctl failed due to device removal in progress\n", 855c696f7b8SSuganath Prabu Subramani ioc->name, device_handle)); 856c696f7b8SSuganath Prabu Subramani mpt3sas_base_free_smid(ioc, smid); 857c696f7b8SSuganath Prabu Subramani ret = -EINVAL; 858c696f7b8SSuganath Prabu Subramani goto out; 859c696f7b8SSuganath Prabu Subramani } 860f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, 861f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 862f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST) 86381c16f83SSuganath Prabu Subramani ioc->put_smid_scsi_io(ioc, smid, device_handle); 864f92363d1SSreekanth Reddy else 86581c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 866f92363d1SSreekanth Reddy break; 867f92363d1SSreekanth Reddy } 868f92363d1SSreekanth Reddy case MPI2_FUNCTION_SCSI_TASK_MGMT: 869f92363d1SSreekanth Reddy { 870f92363d1SSreekanth Reddy Mpi2SCSITaskManagementRequest_t *tm_request = 871f92363d1SSreekanth Reddy (Mpi2SCSITaskManagementRequest_t *)request; 872f92363d1SSreekanth Reddy 873f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 874f92363d1SSreekanth Reddy "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n", 875f92363d1SSreekanth Reddy ioc->name, 876f92363d1SSreekanth Reddy le16_to_cpu(tm_request->DevHandle), tm_request->TaskType)); 877459325c4SChaitra P B ioc->got_task_abort_from_ioctl = 1; 878f92363d1SSreekanth Reddy if (tm_request->TaskType == 879f92363d1SSreekanth Reddy MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK || 880f92363d1SSreekanth Reddy tm_request->TaskType == 881f92363d1SSreekanth Reddy MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) { 882f92363d1SSreekanth Reddy if (_ctl_set_task_mid(ioc, &karg, tm_request)) { 883f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 884459325c4SChaitra P B ioc->got_task_abort_from_ioctl = 0; 885f92363d1SSreekanth Reddy goto out; 886f92363d1SSreekanth Reddy } 887f92363d1SSreekanth Reddy } 888459325c4SChaitra P B ioc->got_task_abort_from_ioctl = 0; 889f92363d1SSreekanth Reddy 890c696f7b8SSuganath Prabu Subramani if (test_bit(device_handle, ioc->device_remove_in_progress)) { 891c696f7b8SSuganath Prabu Subramani dtmprintk(ioc, pr_info(MPT3SAS_FMT 892c696f7b8SSuganath Prabu Subramani "handle(0x%04x) :ioctl failed due to device removal in progress\n", 893c696f7b8SSuganath Prabu Subramani ioc->name, device_handle)); 894c696f7b8SSuganath Prabu Subramani mpt3sas_base_free_smid(ioc, smid); 895c696f7b8SSuganath Prabu Subramani ret = -EINVAL; 896c696f7b8SSuganath Prabu Subramani goto out; 897c696f7b8SSuganath Prabu Subramani } 898f92363d1SSreekanth Reddy mpt3sas_scsih_set_tm_flag(ioc, le16_to_cpu( 899f92363d1SSreekanth Reddy tm_request->DevHandle)); 900f92363d1SSreekanth Reddy ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 901f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 90281c16f83SSuganath Prabu Subramani ioc->put_smid_hi_priority(ioc, smid, 0); 903f92363d1SSreekanth Reddy break; 904f92363d1SSreekanth Reddy } 905f92363d1SSreekanth Reddy case MPI2_FUNCTION_SMP_PASSTHROUGH: 906f92363d1SSreekanth Reddy { 907f92363d1SSreekanth Reddy Mpi2SmpPassthroughRequest_t *smp_request = 908f92363d1SSreekanth Reddy (Mpi2SmpPassthroughRequest_t *)mpi_request; 909f92363d1SSreekanth Reddy u8 *data; 910f92363d1SSreekanth Reddy 911f92363d1SSreekanth Reddy /* ioc determines which port to use */ 912f92363d1SSreekanth Reddy smp_request->PhysicalPort = 0xFF; 913f92363d1SSreekanth Reddy if (smp_request->PassthroughFlags & 914f92363d1SSreekanth Reddy MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE) 915f92363d1SSreekanth Reddy data = (u8 *)&smp_request->SGL; 916f92363d1SSreekanth Reddy else { 917f92363d1SSreekanth Reddy if (unlikely(data_out == NULL)) { 918f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 919f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 920f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 921f92363d1SSreekanth Reddy ret = -EINVAL; 922f92363d1SSreekanth Reddy goto out; 923f92363d1SSreekanth Reddy } 924f92363d1SSreekanth Reddy data = data_out; 925f92363d1SSreekanth Reddy } 926f92363d1SSreekanth Reddy 927f92363d1SSreekanth Reddy if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) { 928f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress = 1; 929f92363d1SSreekanth Reddy ioc->ignore_loginfos = 1; 930f92363d1SSreekanth Reddy } 931f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 932f92363d1SSreekanth Reddy data_in_sz); 93381c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 934f92363d1SSreekanth Reddy break; 935f92363d1SSreekanth Reddy } 936f92363d1SSreekanth Reddy case MPI2_FUNCTION_SATA_PASSTHROUGH: 937c696f7b8SSuganath Prabu Subramani { 938c696f7b8SSuganath Prabu Subramani if (test_bit(device_handle, ioc->device_remove_in_progress)) { 939c696f7b8SSuganath Prabu Subramani dtmprintk(ioc, pr_info(MPT3SAS_FMT 940c696f7b8SSuganath Prabu Subramani "handle(0x%04x) :ioctl failed due to device removal in progress\n", 941c696f7b8SSuganath Prabu Subramani ioc->name, device_handle)); 942c696f7b8SSuganath Prabu Subramani mpt3sas_base_free_smid(ioc, smid); 943c696f7b8SSuganath Prabu Subramani ret = -EINVAL; 944c696f7b8SSuganath Prabu Subramani goto out; 945c696f7b8SSuganath Prabu Subramani } 946c696f7b8SSuganath Prabu Subramani ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 947c696f7b8SSuganath Prabu Subramani data_in_sz); 94881c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 949c696f7b8SSuganath Prabu Subramani break; 950c696f7b8SSuganath Prabu Subramani } 951f92363d1SSreekanth Reddy case MPI2_FUNCTION_FW_DOWNLOAD: 952f92363d1SSreekanth Reddy case MPI2_FUNCTION_FW_UPLOAD: 953f92363d1SSreekanth Reddy { 954f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 955f92363d1SSreekanth Reddy data_in_sz); 95681c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 957f92363d1SSreekanth Reddy break; 958f92363d1SSreekanth Reddy } 959f92363d1SSreekanth Reddy case MPI2_FUNCTION_TOOLBOX: 960f92363d1SSreekanth Reddy { 961f92363d1SSreekanth Reddy Mpi2ToolboxCleanRequest_t *toolbox_request = 962f92363d1SSreekanth Reddy (Mpi2ToolboxCleanRequest_t *)mpi_request; 963f92363d1SSreekanth Reddy 964f92363d1SSreekanth Reddy if (toolbox_request->Tool == MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL) { 965f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, 966f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 967f92363d1SSreekanth Reddy } else { 968f92363d1SSreekanth Reddy ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 969f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 970f92363d1SSreekanth Reddy } 97181c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 972f92363d1SSreekanth Reddy break; 973f92363d1SSreekanth Reddy } 974f92363d1SSreekanth Reddy case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL: 975f92363d1SSreekanth Reddy { 976f92363d1SSreekanth Reddy Mpi2SasIoUnitControlRequest_t *sasiounit_request = 977f92363d1SSreekanth Reddy (Mpi2SasIoUnitControlRequest_t *)mpi_request; 978f92363d1SSreekanth Reddy 979f92363d1SSreekanth Reddy if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET 980f92363d1SSreekanth Reddy || sasiounit_request->Operation == 981f92363d1SSreekanth Reddy MPI2_SAS_OP_PHY_LINK_RESET) { 982f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress = 1; 983f92363d1SSreekanth Reddy ioc->ignore_loginfos = 1; 984f92363d1SSreekanth Reddy } 985f92363d1SSreekanth Reddy /* drop to default case for posting the request */ 986f92363d1SSreekanth Reddy } 987f92363d1SSreekanth Reddy default: 988f92363d1SSreekanth Reddy ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 989f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 99081c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 991f92363d1SSreekanth Reddy break; 992f92363d1SSreekanth Reddy } 993f92363d1SSreekanth Reddy 994f92363d1SSreekanth Reddy if (karg.timeout < MPT3_IOCTL_DEFAULT_TIMEOUT) 995f92363d1SSreekanth Reddy timeout = MPT3_IOCTL_DEFAULT_TIMEOUT; 996f92363d1SSreekanth Reddy else 997f92363d1SSreekanth Reddy timeout = karg.timeout; 9988bbb1cf6SCalvin Owens wait_for_completion_timeout(&ioc->ctl_cmds.done, timeout*HZ); 999f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 1000f92363d1SSreekanth Reddy Mpi2SCSITaskManagementRequest_t *tm_request = 1001f92363d1SSreekanth Reddy (Mpi2SCSITaskManagementRequest_t *)mpi_request; 1002f92363d1SSreekanth Reddy mpt3sas_scsih_clear_tm_flag(ioc, le16_to_cpu( 1003f92363d1SSreekanth Reddy tm_request->DevHandle)); 1004f92363d1SSreekanth Reddy mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT); 1005f92363d1SSreekanth Reddy } else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH || 1006f92363d1SSreekanth Reddy mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) && 1007f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress) { 1008f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress = 0; 1009f92363d1SSreekanth Reddy ioc->ignore_loginfos = 0; 1010f92363d1SSreekanth Reddy } 1011f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 1012f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 1013f92363d1SSreekanth Reddy __func__); 1014f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, karg.data_sge_offset); 1015f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 1016f92363d1SSreekanth Reddy issue_reset = 1; 1017f92363d1SSreekanth Reddy goto issue_host_reset; 1018f92363d1SSreekanth Reddy } 1019f92363d1SSreekanth Reddy 1020f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 1021f92363d1SSreekanth Reddy 1022f92363d1SSreekanth Reddy if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT && 1023f92363d1SSreekanth Reddy (ioc->logging_level & MPT_DEBUG_TM)) { 1024f92363d1SSreekanth Reddy Mpi2SCSITaskManagementReply_t *tm_reply = 1025f92363d1SSreekanth Reddy (Mpi2SCSITaskManagementReply_t *)mpi_reply; 1026f92363d1SSreekanth Reddy 1027f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "TASK_MGMT: " \ 1028f92363d1SSreekanth Reddy "IOCStatus(0x%04x), IOCLogInfo(0x%08x), " 1029f92363d1SSreekanth Reddy "TerminationCount(0x%08x)\n", ioc->name, 1030f92363d1SSreekanth Reddy le16_to_cpu(tm_reply->IOCStatus), 1031f92363d1SSreekanth Reddy le32_to_cpu(tm_reply->IOCLogInfo), 1032f92363d1SSreekanth Reddy le32_to_cpu(tm_reply->TerminationCount)); 1033f92363d1SSreekanth Reddy } 1034af009411SSreekanth Reddy 1035f92363d1SSreekanth Reddy /* copy out xdata to user */ 1036f92363d1SSreekanth Reddy if (data_in_sz) { 1037f92363d1SSreekanth Reddy if (copy_to_user(karg.data_in_buf_ptr, data_in, 1038f92363d1SSreekanth Reddy data_in_sz)) { 1039f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 1040f92363d1SSreekanth Reddy __LINE__, __func__); 1041f92363d1SSreekanth Reddy ret = -ENODATA; 1042f92363d1SSreekanth Reddy goto out; 1043f92363d1SSreekanth Reddy } 1044f92363d1SSreekanth Reddy } 1045f92363d1SSreekanth Reddy 1046f92363d1SSreekanth Reddy /* copy out reply message frame to user */ 1047f92363d1SSreekanth Reddy if (karg.max_reply_bytes) { 1048f92363d1SSreekanth Reddy sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz); 1049f92363d1SSreekanth Reddy if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply, 1050f92363d1SSreekanth Reddy sz)) { 1051f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 1052f92363d1SSreekanth Reddy __LINE__, __func__); 1053f92363d1SSreekanth Reddy ret = -ENODATA; 1054f92363d1SSreekanth Reddy goto out; 1055f92363d1SSreekanth Reddy } 1056f92363d1SSreekanth Reddy } 1057f92363d1SSreekanth Reddy 1058*aff39e61SSuganath Prabu Subramani /* copy out sense/NVMe Error Response to user */ 1059f92363d1SSreekanth Reddy if (karg.max_sense_bytes && (mpi_request->Function == 1060f92363d1SSreekanth Reddy MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function == 1061*aff39e61SSuganath Prabu Subramani MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || mpi_request->Function == 1062*aff39e61SSuganath Prabu Subramani MPI2_FUNCTION_NVME_ENCAPSULATED)) { 1063*aff39e61SSuganath Prabu Subramani if (karg.sense_data_ptr == NULL) { 1064*aff39e61SSuganath Prabu Subramani pr_info(MPT3SAS_FMT "Response buffer provided" 1065*aff39e61SSuganath Prabu Subramani " by application is NULL; Response data will" 1066*aff39e61SSuganath Prabu Subramani " not be returned.\n", ioc->name); 1067*aff39e61SSuganath Prabu Subramani goto out; 1068*aff39e61SSuganath Prabu Subramani } 1069*aff39e61SSuganath Prabu Subramani sz_arg = (mpi_request->Function == 1070*aff39e61SSuganath Prabu Subramani MPI2_FUNCTION_NVME_ENCAPSULATED) ? NVME_ERROR_RESPONSE_SIZE : 1071*aff39e61SSuganath Prabu Subramani SCSI_SENSE_BUFFERSIZE; 1072*aff39e61SSuganath Prabu Subramani sz = min_t(u32, karg.max_sense_bytes, sz_arg); 1073f92363d1SSreekanth Reddy if (copy_to_user(karg.sense_data_ptr, ioc->ctl_cmds.sense, 1074f92363d1SSreekanth Reddy sz)) { 1075f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 1076f92363d1SSreekanth Reddy __LINE__, __func__); 1077f92363d1SSreekanth Reddy ret = -ENODATA; 1078f92363d1SSreekanth Reddy goto out; 1079f92363d1SSreekanth Reddy } 1080f92363d1SSreekanth Reddy } 1081f92363d1SSreekanth Reddy 1082f92363d1SSreekanth Reddy issue_host_reset: 1083f92363d1SSreekanth Reddy if (issue_reset) { 1084f92363d1SSreekanth Reddy ret = -ENODATA; 1085f92363d1SSreekanth Reddy if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 1086f92363d1SSreekanth Reddy mpi_request->Function == 1087f92363d1SSreekanth Reddy MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || 1088f92363d1SSreekanth Reddy mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH)) { 1089f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "issue target reset: handle = (0x%04x)\n", 1090f92363d1SSreekanth Reddy ioc->name, 1091f92363d1SSreekanth Reddy le16_to_cpu(mpi_request->FunctionDependent1)); 1092f92363d1SSreekanth Reddy mpt3sas_halt_firmware(ioc); 109396902835SCalvin Owens mpt3sas_scsih_issue_locked_tm(ioc, 1094f92363d1SSreekanth Reddy le16_to_cpu(mpi_request->FunctionDependent1), 0, 0, 109596902835SCalvin Owens 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 30); 1096f92363d1SSreekanth Reddy } else 109798c56ad3SCalvin Owens mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 1098f92363d1SSreekanth Reddy } 1099f92363d1SSreekanth Reddy 1100f92363d1SSreekanth Reddy out: 1101f92363d1SSreekanth Reddy 1102f92363d1SSreekanth Reddy /* free memory associated with sg buffers */ 1103f92363d1SSreekanth Reddy if (data_in) 1104f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, data_in_sz, data_in, 1105f92363d1SSreekanth Reddy data_in_dma); 1106f92363d1SSreekanth Reddy 1107f92363d1SSreekanth Reddy if (data_out) 1108f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, data_out_sz, data_out, 1109f92363d1SSreekanth Reddy data_out_dma); 1110f92363d1SSreekanth Reddy 1111f92363d1SSreekanth Reddy kfree(mpi_request); 1112f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 1113f92363d1SSreekanth Reddy return ret; 1114f92363d1SSreekanth Reddy } 1115f92363d1SSreekanth Reddy 1116f92363d1SSreekanth Reddy /** 1117f92363d1SSreekanth Reddy * _ctl_getiocinfo - main handler for MPT3IOCINFO opcode 1118f92363d1SSreekanth Reddy * @ioc: per adapter object 1119f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1120f92363d1SSreekanth Reddy */ 1121f92363d1SSreekanth Reddy static long 1122f92363d1SSreekanth Reddy _ctl_getiocinfo(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1123f92363d1SSreekanth Reddy { 1124f92363d1SSreekanth Reddy struct mpt3_ioctl_iocinfo karg; 1125f92363d1SSreekanth Reddy 1126f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1127f92363d1SSreekanth Reddy __func__)); 1128f92363d1SSreekanth Reddy 1129f92363d1SSreekanth Reddy memset(&karg, 0 , sizeof(karg)); 1130f92363d1SSreekanth Reddy if (ioc->pfacts) 1131f92363d1SSreekanth Reddy karg.port_number = ioc->pfacts[0].PortNumber; 1132f92363d1SSreekanth Reddy karg.hw_rev = ioc->pdev->revision; 1133f92363d1SSreekanth Reddy karg.pci_id = ioc->pdev->device; 1134f92363d1SSreekanth Reddy karg.subsystem_device = ioc->pdev->subsystem_device; 1135f92363d1SSreekanth Reddy karg.subsystem_vendor = ioc->pdev->subsystem_vendor; 1136f92363d1SSreekanth Reddy karg.pci_information.u.bits.bus = ioc->pdev->bus->number; 1137f92363d1SSreekanth Reddy karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn); 1138f92363d1SSreekanth Reddy karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn); 1139f92363d1SSreekanth Reddy karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus); 1140f92363d1SSreekanth Reddy karg.firmware_version = ioc->facts.FWVersion.Word; 1141c84b06a4SSreekanth Reddy strcpy(karg.driver_version, ioc->driver_name); 1142f92363d1SSreekanth Reddy strcat(karg.driver_version, "-"); 1143d357e84dSSreekanth Reddy switch (ioc->hba_mpi_version_belonged) { 1144d357e84dSSreekanth Reddy case MPI2_VERSION: 11457786ab6aSSreekanth Reddy if (ioc->is_warpdrive) 11467786ab6aSSreekanth Reddy karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2_SSS6200; 11477786ab6aSSreekanth Reddy else 1148d357e84dSSreekanth Reddy karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2; 1149d357e84dSSreekanth Reddy strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION); 1150d357e84dSSreekanth Reddy break; 1151d357e84dSSreekanth Reddy case MPI25_VERSION: 1152b130b0d5SSuganath prabu Subramani case MPI26_VERSION: 1153998f26aeSSuganath Prabu Subramani if (ioc->is_gen35_ioc) 1154998f26aeSSuganath Prabu Subramani karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS35; 1155998f26aeSSuganath Prabu Subramani else 1156d357e84dSSreekanth Reddy karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS3; 1157d357e84dSSreekanth Reddy strcat(karg.driver_version, MPT3SAS_DRIVER_VERSION); 1158d357e84dSSreekanth Reddy break; 1159d357e84dSSreekanth Reddy } 1160f92363d1SSreekanth Reddy karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 1161f92363d1SSreekanth Reddy 1162f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(karg))) { 1163f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1164f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1165f92363d1SSreekanth Reddy return -EFAULT; 1166f92363d1SSreekanth Reddy } 1167f92363d1SSreekanth Reddy return 0; 1168f92363d1SSreekanth Reddy } 1169f92363d1SSreekanth Reddy 1170f92363d1SSreekanth Reddy /** 1171f92363d1SSreekanth Reddy * _ctl_eventquery - main handler for MPT3EVENTQUERY opcode 1172f92363d1SSreekanth Reddy * @ioc: per adapter object 1173f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1174f92363d1SSreekanth Reddy */ 1175f92363d1SSreekanth Reddy static long 1176f92363d1SSreekanth Reddy _ctl_eventquery(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1177f92363d1SSreekanth Reddy { 1178f92363d1SSreekanth Reddy struct mpt3_ioctl_eventquery karg; 1179f92363d1SSreekanth Reddy 1180f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1181f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1182f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1183f92363d1SSreekanth Reddy return -EFAULT; 1184f92363d1SSreekanth Reddy } 1185f92363d1SSreekanth Reddy 1186f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1187f92363d1SSreekanth Reddy __func__)); 1188f92363d1SSreekanth Reddy 1189f92363d1SSreekanth Reddy karg.event_entries = MPT3SAS_CTL_EVENT_LOG_SIZE; 1190f92363d1SSreekanth Reddy memcpy(karg.event_types, ioc->event_type, 1191f92363d1SSreekanth Reddy MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1192f92363d1SSreekanth Reddy 1193f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(karg))) { 1194f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1195f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1196f92363d1SSreekanth Reddy return -EFAULT; 1197f92363d1SSreekanth Reddy } 1198f92363d1SSreekanth Reddy return 0; 1199f92363d1SSreekanth Reddy } 1200f92363d1SSreekanth Reddy 1201f92363d1SSreekanth Reddy /** 1202f92363d1SSreekanth Reddy * _ctl_eventenable - main handler for MPT3EVENTENABLE opcode 1203f92363d1SSreekanth Reddy * @ioc: per adapter object 1204f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1205f92363d1SSreekanth Reddy */ 1206f92363d1SSreekanth Reddy static long 1207f92363d1SSreekanth Reddy _ctl_eventenable(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1208f92363d1SSreekanth Reddy { 1209f92363d1SSreekanth Reddy struct mpt3_ioctl_eventenable karg; 1210f92363d1SSreekanth Reddy 1211f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1212f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1213f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1214f92363d1SSreekanth Reddy return -EFAULT; 1215f92363d1SSreekanth Reddy } 1216f92363d1SSreekanth Reddy 1217f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1218f92363d1SSreekanth Reddy __func__)); 1219f92363d1SSreekanth Reddy 1220f92363d1SSreekanth Reddy memcpy(ioc->event_type, karg.event_types, 1221f92363d1SSreekanth Reddy MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1222f92363d1SSreekanth Reddy mpt3sas_base_validate_event_type(ioc, ioc->event_type); 1223f92363d1SSreekanth Reddy 1224f92363d1SSreekanth Reddy if (ioc->event_log) 1225f92363d1SSreekanth Reddy return 0; 1226f92363d1SSreekanth Reddy /* initialize event_log */ 1227f92363d1SSreekanth Reddy ioc->event_context = 0; 1228f92363d1SSreekanth Reddy ioc->aen_event_read_flag = 0; 1229f92363d1SSreekanth Reddy ioc->event_log = kcalloc(MPT3SAS_CTL_EVENT_LOG_SIZE, 1230f92363d1SSreekanth Reddy sizeof(struct MPT3_IOCTL_EVENTS), GFP_KERNEL); 1231f92363d1SSreekanth Reddy if (!ioc->event_log) { 1232f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1233f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1234f92363d1SSreekanth Reddy return -ENOMEM; 1235f92363d1SSreekanth Reddy } 1236f92363d1SSreekanth Reddy return 0; 1237f92363d1SSreekanth Reddy } 1238f92363d1SSreekanth Reddy 1239f92363d1SSreekanth Reddy /** 1240f92363d1SSreekanth Reddy * _ctl_eventreport - main handler for MPT3EVENTREPORT opcode 1241f92363d1SSreekanth Reddy * @ioc: per adapter object 1242f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1243f92363d1SSreekanth Reddy */ 1244f92363d1SSreekanth Reddy static long 1245f92363d1SSreekanth Reddy _ctl_eventreport(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1246f92363d1SSreekanth Reddy { 1247f92363d1SSreekanth Reddy struct mpt3_ioctl_eventreport karg; 1248f92363d1SSreekanth Reddy u32 number_bytes, max_events, max; 1249f92363d1SSreekanth Reddy struct mpt3_ioctl_eventreport __user *uarg = arg; 1250f92363d1SSreekanth Reddy 1251f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1252f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1253f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1254f92363d1SSreekanth Reddy return -EFAULT; 1255f92363d1SSreekanth Reddy } 1256f92363d1SSreekanth Reddy 1257f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1258f92363d1SSreekanth Reddy __func__)); 1259f92363d1SSreekanth Reddy 1260f92363d1SSreekanth Reddy number_bytes = karg.hdr.max_data_size - 1261f92363d1SSreekanth Reddy sizeof(struct mpt3_ioctl_header); 1262f92363d1SSreekanth Reddy max_events = number_bytes/sizeof(struct MPT3_IOCTL_EVENTS); 1263f92363d1SSreekanth Reddy max = min_t(u32, MPT3SAS_CTL_EVENT_LOG_SIZE, max_events); 1264f92363d1SSreekanth Reddy 1265f92363d1SSreekanth Reddy /* If fewer than 1 event is requested, there must have 1266f92363d1SSreekanth Reddy * been some type of error. 1267f92363d1SSreekanth Reddy */ 1268f92363d1SSreekanth Reddy if (!max || !ioc->event_log) 1269f92363d1SSreekanth Reddy return -ENODATA; 1270f92363d1SSreekanth Reddy 1271f92363d1SSreekanth Reddy number_bytes = max * sizeof(struct MPT3_IOCTL_EVENTS); 1272f92363d1SSreekanth Reddy if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) { 1273f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1274f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1275f92363d1SSreekanth Reddy return -EFAULT; 1276f92363d1SSreekanth Reddy } 1277f92363d1SSreekanth Reddy 1278f92363d1SSreekanth Reddy /* reset flag so SIGIO can restart */ 1279f92363d1SSreekanth Reddy ioc->aen_event_read_flag = 0; 1280f92363d1SSreekanth Reddy return 0; 1281f92363d1SSreekanth Reddy } 1282f92363d1SSreekanth Reddy 1283f92363d1SSreekanth Reddy /** 1284f92363d1SSreekanth Reddy * _ctl_do_reset - main handler for MPT3HARDRESET opcode 1285f92363d1SSreekanth Reddy * @ioc: per adapter object 1286f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1287f92363d1SSreekanth Reddy */ 1288f92363d1SSreekanth Reddy static long 1289f92363d1SSreekanth Reddy _ctl_do_reset(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1290f92363d1SSreekanth Reddy { 1291f92363d1SSreekanth Reddy struct mpt3_ioctl_diag_reset karg; 1292f92363d1SSreekanth Reddy int retval; 1293f92363d1SSreekanth Reddy 1294f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1295f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1296f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1297f92363d1SSreekanth Reddy return -EFAULT; 1298f92363d1SSreekanth Reddy } 1299f92363d1SSreekanth Reddy 1300f92363d1SSreekanth Reddy if (ioc->shost_recovery || ioc->pci_error_recovery || 1301f92363d1SSreekanth Reddy ioc->is_driver_loading) 1302f92363d1SSreekanth Reddy return -EAGAIN; 1303f92363d1SSreekanth Reddy 1304f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1305f92363d1SSreekanth Reddy __func__)); 1306f92363d1SSreekanth Reddy 130798c56ad3SCalvin Owens retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 1308f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "host reset: %s\n", 1309f92363d1SSreekanth Reddy ioc->name, ((!retval) ? "SUCCESS" : "FAILED")); 1310f92363d1SSreekanth Reddy return 0; 1311f92363d1SSreekanth Reddy } 1312f92363d1SSreekanth Reddy 1313f92363d1SSreekanth Reddy /** 1314f92363d1SSreekanth Reddy * _ctl_btdh_search_sas_device - searching for sas device 1315f92363d1SSreekanth Reddy * @ioc: per adapter object 1316f92363d1SSreekanth Reddy * @btdh: btdh ioctl payload 1317f92363d1SSreekanth Reddy */ 1318f92363d1SSreekanth Reddy static int 1319f92363d1SSreekanth Reddy _ctl_btdh_search_sas_device(struct MPT3SAS_ADAPTER *ioc, 1320f92363d1SSreekanth Reddy struct mpt3_ioctl_btdh_mapping *btdh) 1321f92363d1SSreekanth Reddy { 1322f92363d1SSreekanth Reddy struct _sas_device *sas_device; 1323f92363d1SSreekanth Reddy unsigned long flags; 1324f92363d1SSreekanth Reddy int rc = 0; 1325f92363d1SSreekanth Reddy 1326f92363d1SSreekanth Reddy if (list_empty(&ioc->sas_device_list)) 1327f92363d1SSreekanth Reddy return rc; 1328f92363d1SSreekanth Reddy 1329f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->sas_device_lock, flags); 1330f92363d1SSreekanth Reddy list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 1331f92363d1SSreekanth Reddy if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1332f92363d1SSreekanth Reddy btdh->handle == sas_device->handle) { 1333f92363d1SSreekanth Reddy btdh->bus = sas_device->channel; 1334f92363d1SSreekanth Reddy btdh->id = sas_device->id; 1335f92363d1SSreekanth Reddy rc = 1; 1336f92363d1SSreekanth Reddy goto out; 1337f92363d1SSreekanth Reddy } else if (btdh->bus == sas_device->channel && btdh->id == 1338f92363d1SSreekanth Reddy sas_device->id && btdh->handle == 0xFFFF) { 1339f92363d1SSreekanth Reddy btdh->handle = sas_device->handle; 1340f92363d1SSreekanth Reddy rc = 1; 1341f92363d1SSreekanth Reddy goto out; 1342f92363d1SSreekanth Reddy } 1343f92363d1SSreekanth Reddy } 1344f92363d1SSreekanth Reddy out: 1345f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1346f92363d1SSreekanth Reddy return rc; 1347f92363d1SSreekanth Reddy } 1348f92363d1SSreekanth Reddy 1349f92363d1SSreekanth Reddy /** 1350f92363d1SSreekanth Reddy * _ctl_btdh_search_raid_device - searching for raid device 1351f92363d1SSreekanth Reddy * @ioc: per adapter object 1352f92363d1SSreekanth Reddy * @btdh: btdh ioctl payload 1353f92363d1SSreekanth Reddy */ 1354f92363d1SSreekanth Reddy static int 1355f92363d1SSreekanth Reddy _ctl_btdh_search_raid_device(struct MPT3SAS_ADAPTER *ioc, 1356f92363d1SSreekanth Reddy struct mpt3_ioctl_btdh_mapping *btdh) 1357f92363d1SSreekanth Reddy { 1358f92363d1SSreekanth Reddy struct _raid_device *raid_device; 1359f92363d1SSreekanth Reddy unsigned long flags; 1360f92363d1SSreekanth Reddy int rc = 0; 1361f92363d1SSreekanth Reddy 1362f92363d1SSreekanth Reddy if (list_empty(&ioc->raid_device_list)) 1363f92363d1SSreekanth Reddy return rc; 1364f92363d1SSreekanth Reddy 1365f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->raid_device_lock, flags); 1366f92363d1SSreekanth Reddy list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 1367f92363d1SSreekanth Reddy if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1368f92363d1SSreekanth Reddy btdh->handle == raid_device->handle) { 1369f92363d1SSreekanth Reddy btdh->bus = raid_device->channel; 1370f92363d1SSreekanth Reddy btdh->id = raid_device->id; 1371f92363d1SSreekanth Reddy rc = 1; 1372f92363d1SSreekanth Reddy goto out; 1373f92363d1SSreekanth Reddy } else if (btdh->bus == raid_device->channel && btdh->id == 1374f92363d1SSreekanth Reddy raid_device->id && btdh->handle == 0xFFFF) { 1375f92363d1SSreekanth Reddy btdh->handle = raid_device->handle; 1376f92363d1SSreekanth Reddy rc = 1; 1377f92363d1SSreekanth Reddy goto out; 1378f92363d1SSreekanth Reddy } 1379f92363d1SSreekanth Reddy } 1380f92363d1SSreekanth Reddy out: 1381f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1382f92363d1SSreekanth Reddy return rc; 1383f92363d1SSreekanth Reddy } 1384f92363d1SSreekanth Reddy 1385f92363d1SSreekanth Reddy /** 1386f92363d1SSreekanth Reddy * _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode 1387f92363d1SSreekanth Reddy * @ioc: per adapter object 1388f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1389f92363d1SSreekanth Reddy */ 1390f92363d1SSreekanth Reddy static long 1391f92363d1SSreekanth Reddy _ctl_btdh_mapping(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1392f92363d1SSreekanth Reddy { 1393f92363d1SSreekanth Reddy struct mpt3_ioctl_btdh_mapping karg; 1394f92363d1SSreekanth Reddy int rc; 1395f92363d1SSreekanth Reddy 1396f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1397f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1398f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1399f92363d1SSreekanth Reddy return -EFAULT; 1400f92363d1SSreekanth Reddy } 1401f92363d1SSreekanth Reddy 1402f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1403f92363d1SSreekanth Reddy __func__)); 1404f92363d1SSreekanth Reddy 1405f92363d1SSreekanth Reddy rc = _ctl_btdh_search_sas_device(ioc, &karg); 1406f92363d1SSreekanth Reddy if (!rc) 1407f92363d1SSreekanth Reddy _ctl_btdh_search_raid_device(ioc, &karg); 1408f92363d1SSreekanth Reddy 1409f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(karg))) { 1410f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1411f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1412f92363d1SSreekanth Reddy return -EFAULT; 1413f92363d1SSreekanth Reddy } 1414f92363d1SSreekanth Reddy return 0; 1415f92363d1SSreekanth Reddy } 1416f92363d1SSreekanth Reddy 1417f92363d1SSreekanth Reddy /** 1418f92363d1SSreekanth Reddy * _ctl_diag_capability - return diag buffer capability 1419f92363d1SSreekanth Reddy * @ioc: per adapter object 1420f92363d1SSreekanth Reddy * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED 1421f92363d1SSreekanth Reddy * 1422f92363d1SSreekanth Reddy * returns 1 when diag buffer support is enabled in firmware 1423f92363d1SSreekanth Reddy */ 1424f92363d1SSreekanth Reddy static u8 1425f92363d1SSreekanth Reddy _ctl_diag_capability(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type) 1426f92363d1SSreekanth Reddy { 1427f92363d1SSreekanth Reddy u8 rc = 0; 1428f92363d1SSreekanth Reddy 1429f92363d1SSreekanth Reddy switch (buffer_type) { 1430f92363d1SSreekanth Reddy case MPI2_DIAG_BUF_TYPE_TRACE: 1431f92363d1SSreekanth Reddy if (ioc->facts.IOCCapabilities & 1432f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER) 1433f92363d1SSreekanth Reddy rc = 1; 1434f92363d1SSreekanth Reddy break; 1435f92363d1SSreekanth Reddy case MPI2_DIAG_BUF_TYPE_SNAPSHOT: 1436f92363d1SSreekanth Reddy if (ioc->facts.IOCCapabilities & 1437f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER) 1438f92363d1SSreekanth Reddy rc = 1; 1439f92363d1SSreekanth Reddy break; 1440f92363d1SSreekanth Reddy case MPI2_DIAG_BUF_TYPE_EXTENDED: 1441f92363d1SSreekanth Reddy if (ioc->facts.IOCCapabilities & 1442f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) 1443f92363d1SSreekanth Reddy rc = 1; 1444f92363d1SSreekanth Reddy } 1445f92363d1SSreekanth Reddy 1446f92363d1SSreekanth Reddy return rc; 1447f92363d1SSreekanth Reddy } 1448f92363d1SSreekanth Reddy 1449f92363d1SSreekanth Reddy 1450f92363d1SSreekanth Reddy /** 1451f92363d1SSreekanth Reddy * _ctl_diag_register_2 - wrapper for registering diag buffer support 1452f92363d1SSreekanth Reddy * @ioc: per adapter object 1453f92363d1SSreekanth Reddy * @diag_register: the diag_register struct passed in from user space 1454f92363d1SSreekanth Reddy * 1455f92363d1SSreekanth Reddy */ 1456f92363d1SSreekanth Reddy static long 1457f92363d1SSreekanth Reddy _ctl_diag_register_2(struct MPT3SAS_ADAPTER *ioc, 1458f92363d1SSreekanth Reddy struct mpt3_diag_register *diag_register) 1459f92363d1SSreekanth Reddy { 1460f92363d1SSreekanth Reddy int rc, i; 1461f92363d1SSreekanth Reddy void *request_data = NULL; 1462f92363d1SSreekanth Reddy dma_addr_t request_data_dma; 1463f92363d1SSreekanth Reddy u32 request_data_sz = 0; 1464f92363d1SSreekanth Reddy Mpi2DiagBufferPostRequest_t *mpi_request; 1465f92363d1SSreekanth Reddy Mpi2DiagBufferPostReply_t *mpi_reply; 1466f92363d1SSreekanth Reddy u8 buffer_type; 1467f92363d1SSreekanth Reddy u16 smid; 1468f92363d1SSreekanth Reddy u16 ioc_status; 1469f92363d1SSreekanth Reddy u32 ioc_state; 1470f92363d1SSreekanth Reddy u8 issue_reset = 0; 1471f92363d1SSreekanth Reddy 1472f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1473f92363d1SSreekanth Reddy __func__)); 1474f92363d1SSreekanth Reddy 1475f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 1476f92363d1SSreekanth Reddy if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 1477f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1478f92363d1SSreekanth Reddy "%s: failed due to ioc not operational\n", 1479f92363d1SSreekanth Reddy ioc->name, __func__); 1480f92363d1SSreekanth Reddy rc = -EAGAIN; 1481f92363d1SSreekanth Reddy goto out; 1482f92363d1SSreekanth Reddy } 1483f92363d1SSreekanth Reddy 1484f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 1485f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 1486f92363d1SSreekanth Reddy ioc->name, __func__); 1487f92363d1SSreekanth Reddy rc = -EAGAIN; 1488f92363d1SSreekanth Reddy goto out; 1489f92363d1SSreekanth Reddy } 1490f92363d1SSreekanth Reddy 1491f92363d1SSreekanth Reddy buffer_type = diag_register->buffer_type; 1492f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1493f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1494f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1495f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1496f92363d1SSreekanth Reddy return -EPERM; 1497f92363d1SSreekanth Reddy } 1498f92363d1SSreekanth Reddy 1499f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & 1500f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) { 1501f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1502f92363d1SSreekanth Reddy "%s: already has a registered buffer for buffer_type(0x%02x)\n", 1503f92363d1SSreekanth Reddy ioc->name, __func__, 1504f92363d1SSreekanth Reddy buffer_type); 1505f92363d1SSreekanth Reddy return -EINVAL; 1506f92363d1SSreekanth Reddy } 1507f92363d1SSreekanth Reddy 1508f92363d1SSreekanth Reddy if (diag_register->requested_buffer_size % 4) { 1509f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1510f92363d1SSreekanth Reddy "%s: the requested_buffer_size is not 4 byte aligned\n", 1511f92363d1SSreekanth Reddy ioc->name, __func__); 1512f92363d1SSreekanth Reddy return -EINVAL; 1513f92363d1SSreekanth Reddy } 1514f92363d1SSreekanth Reddy 1515f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1516f92363d1SSreekanth Reddy if (!smid) { 1517f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 1518f92363d1SSreekanth Reddy ioc->name, __func__); 1519f92363d1SSreekanth Reddy rc = -EAGAIN; 1520f92363d1SSreekanth Reddy goto out; 1521f92363d1SSreekanth Reddy } 1522f92363d1SSreekanth Reddy 1523f92363d1SSreekanth Reddy rc = 0; 1524f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 1525f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1526f92363d1SSreekanth Reddy mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 1527f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 1528f92363d1SSreekanth Reddy 1529f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 1530f92363d1SSreekanth Reddy request_data_sz = diag_register->requested_buffer_size; 1531f92363d1SSreekanth Reddy ioc->unique_id[buffer_type] = diag_register->unique_id; 1532f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] = 0; 1533f92363d1SSreekanth Reddy memcpy(ioc->product_specific[buffer_type], 1534f92363d1SSreekanth Reddy diag_register->product_specific, MPT3_PRODUCT_SPECIFIC_DWORDS); 1535f92363d1SSreekanth Reddy ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags; 1536f92363d1SSreekanth Reddy 1537f92363d1SSreekanth Reddy if (request_data) { 1538f92363d1SSreekanth Reddy request_data_dma = ioc->diag_buffer_dma[buffer_type]; 1539f92363d1SSreekanth Reddy if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) { 1540f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, 1541f92363d1SSreekanth Reddy ioc->diag_buffer_sz[buffer_type], 1542f92363d1SSreekanth Reddy request_data, request_data_dma); 1543f92363d1SSreekanth Reddy request_data = NULL; 1544f92363d1SSreekanth Reddy } 1545f92363d1SSreekanth Reddy } 1546f92363d1SSreekanth Reddy 1547f92363d1SSreekanth Reddy if (request_data == NULL) { 1548f92363d1SSreekanth Reddy ioc->diag_buffer_sz[buffer_type] = 0; 1549f92363d1SSreekanth Reddy ioc->diag_buffer_dma[buffer_type] = 0; 1550f92363d1SSreekanth Reddy request_data = pci_alloc_consistent( 1551f92363d1SSreekanth Reddy ioc->pdev, request_data_sz, &request_data_dma); 1552f92363d1SSreekanth Reddy if (request_data == NULL) { 1553f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed allocating memory" \ 1554f92363d1SSreekanth Reddy " for diag buffers, requested size(%d)\n", 1555f92363d1SSreekanth Reddy ioc->name, __func__, request_data_sz); 1556f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 1557f92363d1SSreekanth Reddy return -ENOMEM; 1558f92363d1SSreekanth Reddy } 1559f92363d1SSreekanth Reddy ioc->diag_buffer[buffer_type] = request_data; 1560f92363d1SSreekanth Reddy ioc->diag_buffer_sz[buffer_type] = request_data_sz; 1561f92363d1SSreekanth Reddy ioc->diag_buffer_dma[buffer_type] = request_data_dma; 1562f92363d1SSreekanth Reddy } 1563f92363d1SSreekanth Reddy 1564f92363d1SSreekanth Reddy mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 1565f92363d1SSreekanth Reddy mpi_request->BufferType = diag_register->buffer_type; 1566f92363d1SSreekanth Reddy mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags); 1567f92363d1SSreekanth Reddy mpi_request->BufferAddress = cpu_to_le64(request_data_dma); 1568f92363d1SSreekanth Reddy mpi_request->BufferLength = cpu_to_le32(request_data_sz); 1569f92363d1SSreekanth Reddy mpi_request->VF_ID = 0; /* TODO */ 1570f92363d1SSreekanth Reddy mpi_request->VP_ID = 0; 1571f92363d1SSreekanth Reddy 1572f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 1573f92363d1SSreekanth Reddy "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n", 1574f92363d1SSreekanth Reddy ioc->name, __func__, request_data, 1575f92363d1SSreekanth Reddy (unsigned long long)request_data_dma, 1576f92363d1SSreekanth Reddy le32_to_cpu(mpi_request->BufferLength))); 1577f92363d1SSreekanth Reddy 1578f92363d1SSreekanth Reddy for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 1579f92363d1SSreekanth Reddy mpi_request->ProductSpecific[i] = 1580f92363d1SSreekanth Reddy cpu_to_le32(ioc->product_specific[buffer_type][i]); 1581f92363d1SSreekanth Reddy 1582f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 158381c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 15848bbb1cf6SCalvin Owens wait_for_completion_timeout(&ioc->ctl_cmds.done, 1585f92363d1SSreekanth Reddy MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 1586f92363d1SSreekanth Reddy 1587f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 1588f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 1589f92363d1SSreekanth Reddy __func__); 1590f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, 1591f92363d1SSreekanth Reddy sizeof(Mpi2DiagBufferPostRequest_t)/4); 1592f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 1593f92363d1SSreekanth Reddy issue_reset = 1; 1594f92363d1SSreekanth Reddy goto issue_host_reset; 1595f92363d1SSreekanth Reddy } 1596f92363d1SSreekanth Reddy 1597f92363d1SSreekanth Reddy /* process the completed Reply Message Frame */ 1598f92363d1SSreekanth Reddy if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 1599f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: no reply message\n", 1600f92363d1SSreekanth Reddy ioc->name, __func__); 1601f92363d1SSreekanth Reddy rc = -EFAULT; 1602f92363d1SSreekanth Reddy goto out; 1603f92363d1SSreekanth Reddy } 1604f92363d1SSreekanth Reddy 1605f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 1606f92363d1SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1607f92363d1SSreekanth Reddy 1608f92363d1SSreekanth Reddy if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 1609f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 1610f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED; 1611f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n", 1612f92363d1SSreekanth Reddy ioc->name, __func__)); 1613f92363d1SSreekanth Reddy } else { 1614f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 1615f92363d1SSreekanth Reddy "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 1616f92363d1SSreekanth Reddy ioc->name, __func__, 1617f92363d1SSreekanth Reddy ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 1618f92363d1SSreekanth Reddy rc = -EFAULT; 1619f92363d1SSreekanth Reddy } 1620f92363d1SSreekanth Reddy 1621f92363d1SSreekanth Reddy issue_host_reset: 1622f92363d1SSreekanth Reddy if (issue_reset) 162398c56ad3SCalvin Owens mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 1624f92363d1SSreekanth Reddy 1625f92363d1SSreekanth Reddy out: 1626f92363d1SSreekanth Reddy 1627f92363d1SSreekanth Reddy if (rc && request_data) 1628f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, request_data_sz, 1629f92363d1SSreekanth Reddy request_data, request_data_dma); 1630f92363d1SSreekanth Reddy 1631f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 1632f92363d1SSreekanth Reddy return rc; 1633f92363d1SSreekanth Reddy } 1634f92363d1SSreekanth Reddy 1635f92363d1SSreekanth Reddy /** 1636f92363d1SSreekanth Reddy * mpt3sas_enable_diag_buffer - enabling diag_buffers support driver load time 1637f92363d1SSreekanth Reddy * @ioc: per adapter object 1638f92363d1SSreekanth Reddy * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1 1639f92363d1SSreekanth Reddy * 1640f92363d1SSreekanth Reddy * This is called when command line option diag_buffer_enable is enabled 1641f92363d1SSreekanth Reddy * at driver load time. 1642f92363d1SSreekanth Reddy */ 1643f92363d1SSreekanth Reddy void 1644f92363d1SSreekanth Reddy mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER *ioc, u8 bits_to_register) 1645f92363d1SSreekanth Reddy { 1646f92363d1SSreekanth Reddy struct mpt3_diag_register diag_register; 1647f92363d1SSreekanth Reddy 1648f92363d1SSreekanth Reddy memset(&diag_register, 0, sizeof(struct mpt3_diag_register)); 1649f92363d1SSreekanth Reddy 1650f92363d1SSreekanth Reddy if (bits_to_register & 1) { 1651f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "registering trace buffer support\n", 1652f92363d1SSreekanth Reddy ioc->name); 1653f92363d1SSreekanth Reddy ioc->diag_trigger_master.MasterData = 1654f92363d1SSreekanth Reddy (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET); 1655f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 1656f92363d1SSreekanth Reddy /* register for 2MB buffers */ 1657f92363d1SSreekanth Reddy diag_register.requested_buffer_size = 2 * (1024 * 1024); 1658f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075900; 1659f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 1660f92363d1SSreekanth Reddy } 1661f92363d1SSreekanth Reddy 1662f92363d1SSreekanth Reddy if (bits_to_register & 2) { 1663f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "registering snapshot buffer support\n", 1664f92363d1SSreekanth Reddy ioc->name); 1665f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT; 1666f92363d1SSreekanth Reddy /* register for 2MB buffers */ 1667f92363d1SSreekanth Reddy diag_register.requested_buffer_size = 2 * (1024 * 1024); 1668f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075901; 1669f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 1670f92363d1SSreekanth Reddy } 1671f92363d1SSreekanth Reddy 1672f92363d1SSreekanth Reddy if (bits_to_register & 4) { 1673f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "registering extended buffer support\n", 1674f92363d1SSreekanth Reddy ioc->name); 1675f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED; 1676f92363d1SSreekanth Reddy /* register for 2MB buffers */ 1677f92363d1SSreekanth Reddy diag_register.requested_buffer_size = 2 * (1024 * 1024); 1678f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075901; 1679f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 1680f92363d1SSreekanth Reddy } 1681f92363d1SSreekanth Reddy } 1682f92363d1SSreekanth Reddy 1683f92363d1SSreekanth Reddy /** 1684f92363d1SSreekanth Reddy * _ctl_diag_register - application register with driver 1685f92363d1SSreekanth Reddy * @ioc: per adapter object 1686f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1687f92363d1SSreekanth Reddy * 1688f92363d1SSreekanth Reddy * This will allow the driver to setup any required buffers that will be 1689f92363d1SSreekanth Reddy * needed by firmware to communicate with the driver. 1690f92363d1SSreekanth Reddy */ 1691f92363d1SSreekanth Reddy static long 1692f92363d1SSreekanth Reddy _ctl_diag_register(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1693f92363d1SSreekanth Reddy { 1694f92363d1SSreekanth Reddy struct mpt3_diag_register karg; 1695f92363d1SSreekanth Reddy long rc; 1696f92363d1SSreekanth Reddy 1697f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1698f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1699f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1700f92363d1SSreekanth Reddy return -EFAULT; 1701f92363d1SSreekanth Reddy } 1702f92363d1SSreekanth Reddy 1703f92363d1SSreekanth Reddy rc = _ctl_diag_register_2(ioc, &karg); 1704f92363d1SSreekanth Reddy return rc; 1705f92363d1SSreekanth Reddy } 1706f92363d1SSreekanth Reddy 1707f92363d1SSreekanth Reddy /** 1708f92363d1SSreekanth Reddy * _ctl_diag_unregister - application unregister with driver 1709f92363d1SSreekanth Reddy * @ioc: per adapter object 1710f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1711f92363d1SSreekanth Reddy * 1712f92363d1SSreekanth Reddy * This will allow the driver to cleanup any memory allocated for diag 1713f92363d1SSreekanth Reddy * messages and to free up any resources. 1714f92363d1SSreekanth Reddy */ 1715f92363d1SSreekanth Reddy static long 1716f92363d1SSreekanth Reddy _ctl_diag_unregister(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1717f92363d1SSreekanth Reddy { 1718f92363d1SSreekanth Reddy struct mpt3_diag_unregister karg; 1719f92363d1SSreekanth Reddy void *request_data; 1720f92363d1SSreekanth Reddy dma_addr_t request_data_dma; 1721f92363d1SSreekanth Reddy u32 request_data_sz; 1722f92363d1SSreekanth Reddy u8 buffer_type; 1723f92363d1SSreekanth Reddy 1724f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1725f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1726f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1727f92363d1SSreekanth Reddy return -EFAULT; 1728f92363d1SSreekanth Reddy } 1729f92363d1SSreekanth Reddy 1730f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1731f92363d1SSreekanth Reddy __func__)); 1732f92363d1SSreekanth Reddy 1733f92363d1SSreekanth Reddy buffer_type = karg.unique_id & 0x000000ff; 1734f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1735f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1736f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1737f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1738f92363d1SSreekanth Reddy return -EPERM; 1739f92363d1SSreekanth Reddy } 1740f92363d1SSreekanth Reddy 1741f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1742f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 1743f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1744f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is not registered\n", 1745f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1746f92363d1SSreekanth Reddy return -EINVAL; 1747f92363d1SSreekanth Reddy } 1748f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1749f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) == 0) { 1750f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1751f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) has not been released\n", 1752f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1753f92363d1SSreekanth Reddy return -EINVAL; 1754f92363d1SSreekanth Reddy } 1755f92363d1SSreekanth Reddy 1756f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 1757f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1758f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 1759f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 1760f92363d1SSreekanth Reddy return -EINVAL; 1761f92363d1SSreekanth Reddy } 1762f92363d1SSreekanth Reddy 1763f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 1764f92363d1SSreekanth Reddy if (!request_data) { 1765f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1766f92363d1SSreekanth Reddy "%s: doesn't have memory allocated for buffer_type(0x%02x)\n", 1767f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1768f92363d1SSreekanth Reddy return -ENOMEM; 1769f92363d1SSreekanth Reddy } 1770f92363d1SSreekanth Reddy 1771f92363d1SSreekanth Reddy request_data_sz = ioc->diag_buffer_sz[buffer_type]; 1772f92363d1SSreekanth Reddy request_data_dma = ioc->diag_buffer_dma[buffer_type]; 1773f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, request_data_sz, 1774f92363d1SSreekanth Reddy request_data, request_data_dma); 1775f92363d1SSreekanth Reddy ioc->diag_buffer[buffer_type] = NULL; 1776f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] = 0; 1777f92363d1SSreekanth Reddy return 0; 1778f92363d1SSreekanth Reddy } 1779f92363d1SSreekanth Reddy 1780f92363d1SSreekanth Reddy /** 1781f92363d1SSreekanth Reddy * _ctl_diag_query - query relevant info associated with diag buffers 1782f92363d1SSreekanth Reddy * @ioc: per adapter object 1783f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1784f92363d1SSreekanth Reddy * 1785f92363d1SSreekanth Reddy * The application will send only buffer_type and unique_id. Driver will 1786f92363d1SSreekanth Reddy * inspect unique_id first, if valid, fill in all the info. If unique_id is 1787f92363d1SSreekanth Reddy * 0x00, the driver will return info specified by Buffer Type. 1788f92363d1SSreekanth Reddy */ 1789f92363d1SSreekanth Reddy static long 1790f92363d1SSreekanth Reddy _ctl_diag_query(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1791f92363d1SSreekanth Reddy { 1792f92363d1SSreekanth Reddy struct mpt3_diag_query karg; 1793f92363d1SSreekanth Reddy void *request_data; 1794f92363d1SSreekanth Reddy int i; 1795f92363d1SSreekanth Reddy u8 buffer_type; 1796f92363d1SSreekanth Reddy 1797f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1798f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1799f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1800f92363d1SSreekanth Reddy return -EFAULT; 1801f92363d1SSreekanth Reddy } 1802f92363d1SSreekanth Reddy 1803f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1804f92363d1SSreekanth Reddy __func__)); 1805f92363d1SSreekanth Reddy 1806f92363d1SSreekanth Reddy karg.application_flags = 0; 1807f92363d1SSreekanth Reddy buffer_type = karg.buffer_type; 1808f92363d1SSreekanth Reddy 1809f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1810f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1811f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1812f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1813f92363d1SSreekanth Reddy return -EPERM; 1814f92363d1SSreekanth Reddy } 1815f92363d1SSreekanth Reddy 1816f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1817f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 1818f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1819f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is not registered\n", 1820f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1821f92363d1SSreekanth Reddy return -EINVAL; 1822f92363d1SSreekanth Reddy } 1823f92363d1SSreekanth Reddy 1824f92363d1SSreekanth Reddy if (karg.unique_id & 0xffffff00) { 1825f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 1826f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1827f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 1828f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 1829f92363d1SSreekanth Reddy return -EINVAL; 1830f92363d1SSreekanth Reddy } 1831f92363d1SSreekanth Reddy } 1832f92363d1SSreekanth Reddy 1833f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 1834f92363d1SSreekanth Reddy if (!request_data) { 1835f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1836f92363d1SSreekanth Reddy "%s: doesn't have buffer for buffer_type(0x%02x)\n", 1837f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1838f92363d1SSreekanth Reddy return -ENOMEM; 1839f92363d1SSreekanth Reddy } 1840f92363d1SSreekanth Reddy 1841f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & MPT3_DIAG_BUFFER_IS_RELEASED) 1842f92363d1SSreekanth Reddy karg.application_flags = (MPT3_APP_FLAGS_APP_OWNED | 1843f92363d1SSreekanth Reddy MPT3_APP_FLAGS_BUFFER_VALID); 1844f92363d1SSreekanth Reddy else 1845f92363d1SSreekanth Reddy karg.application_flags = (MPT3_APP_FLAGS_APP_OWNED | 1846f92363d1SSreekanth Reddy MPT3_APP_FLAGS_BUFFER_VALID | 1847f92363d1SSreekanth Reddy MPT3_APP_FLAGS_FW_BUFFER_ACCESS); 1848f92363d1SSreekanth Reddy 1849f92363d1SSreekanth Reddy for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 1850f92363d1SSreekanth Reddy karg.product_specific[i] = 1851f92363d1SSreekanth Reddy ioc->product_specific[buffer_type][i]; 1852f92363d1SSreekanth Reddy 1853f92363d1SSreekanth Reddy karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type]; 1854f92363d1SSreekanth Reddy karg.driver_added_buffer_size = 0; 1855f92363d1SSreekanth Reddy karg.unique_id = ioc->unique_id[buffer_type]; 1856f92363d1SSreekanth Reddy karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type]; 1857f92363d1SSreekanth Reddy 1858f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(struct mpt3_diag_query))) { 1859f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1860f92363d1SSreekanth Reddy "%s: unable to write mpt3_diag_query data @ %p\n", 1861f92363d1SSreekanth Reddy ioc->name, __func__, arg); 1862f92363d1SSreekanth Reddy return -EFAULT; 1863f92363d1SSreekanth Reddy } 1864f92363d1SSreekanth Reddy return 0; 1865f92363d1SSreekanth Reddy } 1866f92363d1SSreekanth Reddy 1867f92363d1SSreekanth Reddy /** 1868f92363d1SSreekanth Reddy * mpt3sas_send_diag_release - Diag Release Message 1869f92363d1SSreekanth Reddy * @ioc: per adapter object 1870f92363d1SSreekanth Reddy * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED 1871f92363d1SSreekanth Reddy * @issue_reset - specifies whether host reset is required. 1872f92363d1SSreekanth Reddy * 1873f92363d1SSreekanth Reddy */ 1874f92363d1SSreekanth Reddy int 1875f92363d1SSreekanth Reddy mpt3sas_send_diag_release(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type, 1876f92363d1SSreekanth Reddy u8 *issue_reset) 1877f92363d1SSreekanth Reddy { 1878f92363d1SSreekanth Reddy Mpi2DiagReleaseRequest_t *mpi_request; 1879f92363d1SSreekanth Reddy Mpi2DiagReleaseReply_t *mpi_reply; 1880f92363d1SSreekanth Reddy u16 smid; 1881f92363d1SSreekanth Reddy u16 ioc_status; 1882f92363d1SSreekanth Reddy u32 ioc_state; 1883f92363d1SSreekanth Reddy int rc; 1884f92363d1SSreekanth Reddy 1885f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1886f92363d1SSreekanth Reddy __func__)); 1887f92363d1SSreekanth Reddy 1888f92363d1SSreekanth Reddy rc = 0; 1889f92363d1SSreekanth Reddy *issue_reset = 0; 1890f92363d1SSreekanth Reddy 1891f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 1892f92363d1SSreekanth Reddy if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 1893f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & 1894f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) 1895f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 1896f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED; 1897f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 1898f92363d1SSreekanth Reddy "%s: skipping due to FAULT state\n", ioc->name, 1899f92363d1SSreekanth Reddy __func__)); 1900f92363d1SSreekanth Reddy rc = -EAGAIN; 1901f92363d1SSreekanth Reddy goto out; 1902f92363d1SSreekanth Reddy } 1903f92363d1SSreekanth Reddy 1904f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 1905f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 1906f92363d1SSreekanth Reddy ioc->name, __func__); 1907f92363d1SSreekanth Reddy rc = -EAGAIN; 1908f92363d1SSreekanth Reddy goto out; 1909f92363d1SSreekanth Reddy } 1910f92363d1SSreekanth Reddy 1911f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1912f92363d1SSreekanth Reddy if (!smid) { 1913f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 1914f92363d1SSreekanth Reddy ioc->name, __func__); 1915f92363d1SSreekanth Reddy rc = -EAGAIN; 1916f92363d1SSreekanth Reddy goto out; 1917f92363d1SSreekanth Reddy } 1918f92363d1SSreekanth Reddy 1919f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 1920f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1921f92363d1SSreekanth Reddy mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 1922f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 1923f92363d1SSreekanth Reddy 1924f92363d1SSreekanth Reddy mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE; 1925f92363d1SSreekanth Reddy mpi_request->BufferType = buffer_type; 1926f92363d1SSreekanth Reddy mpi_request->VF_ID = 0; /* TODO */ 1927f92363d1SSreekanth Reddy mpi_request->VP_ID = 0; 1928f92363d1SSreekanth Reddy 1929f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 193081c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 19318bbb1cf6SCalvin Owens wait_for_completion_timeout(&ioc->ctl_cmds.done, 1932f92363d1SSreekanth Reddy MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 1933f92363d1SSreekanth Reddy 1934f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 1935f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 1936f92363d1SSreekanth Reddy __func__); 1937f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, 1938f92363d1SSreekanth Reddy sizeof(Mpi2DiagReleaseRequest_t)/4); 1939f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 1940f92363d1SSreekanth Reddy *issue_reset = 1; 1941f92363d1SSreekanth Reddy rc = -EFAULT; 1942f92363d1SSreekanth Reddy goto out; 1943f92363d1SSreekanth Reddy } 1944f92363d1SSreekanth Reddy 1945f92363d1SSreekanth Reddy /* process the completed Reply Message Frame */ 1946f92363d1SSreekanth Reddy if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 1947f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: no reply message\n", 1948f92363d1SSreekanth Reddy ioc->name, __func__); 1949f92363d1SSreekanth Reddy rc = -EFAULT; 1950f92363d1SSreekanth Reddy goto out; 1951f92363d1SSreekanth Reddy } 1952f92363d1SSreekanth Reddy 1953f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 1954f92363d1SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1955f92363d1SSreekanth Reddy 1956f92363d1SSreekanth Reddy if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 1957f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 1958f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED; 1959f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n", 1960f92363d1SSreekanth Reddy ioc->name, __func__)); 1961f92363d1SSreekanth Reddy } else { 1962f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 1963f92363d1SSreekanth Reddy "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 1964f92363d1SSreekanth Reddy ioc->name, __func__, 1965f92363d1SSreekanth Reddy ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 1966f92363d1SSreekanth Reddy rc = -EFAULT; 1967f92363d1SSreekanth Reddy } 1968f92363d1SSreekanth Reddy 1969f92363d1SSreekanth Reddy out: 1970f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 1971f92363d1SSreekanth Reddy return rc; 1972f92363d1SSreekanth Reddy } 1973f92363d1SSreekanth Reddy 1974f92363d1SSreekanth Reddy /** 1975f92363d1SSreekanth Reddy * _ctl_diag_release - request to send Diag Release Message to firmware 1976f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1977f92363d1SSreekanth Reddy * 1978f92363d1SSreekanth Reddy * This allows ownership of the specified buffer to returned to the driver, 1979f92363d1SSreekanth Reddy * allowing an application to read the buffer without fear that firmware is 19809a284e5cSMasahiro Yamada * overwriting information in the buffer. 1981f92363d1SSreekanth Reddy */ 1982f92363d1SSreekanth Reddy static long 1983f92363d1SSreekanth Reddy _ctl_diag_release(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1984f92363d1SSreekanth Reddy { 1985f92363d1SSreekanth Reddy struct mpt3_diag_release karg; 1986f92363d1SSreekanth Reddy void *request_data; 1987f92363d1SSreekanth Reddy int rc; 1988f92363d1SSreekanth Reddy u8 buffer_type; 1989f92363d1SSreekanth Reddy u8 issue_reset = 0; 1990f92363d1SSreekanth Reddy 1991f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1992f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1993f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1994f92363d1SSreekanth Reddy return -EFAULT; 1995f92363d1SSreekanth Reddy } 1996f92363d1SSreekanth Reddy 1997f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1998f92363d1SSreekanth Reddy __func__)); 1999f92363d1SSreekanth Reddy 2000f92363d1SSreekanth Reddy buffer_type = karg.unique_id & 0x000000ff; 2001f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 2002f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2003f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 2004f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 2005f92363d1SSreekanth Reddy return -EPERM; 2006f92363d1SSreekanth Reddy } 2007f92363d1SSreekanth Reddy 2008f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 2009f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 2010f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2011f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is not registered\n", 2012f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 2013f92363d1SSreekanth Reddy return -EINVAL; 2014f92363d1SSreekanth Reddy } 2015f92363d1SSreekanth Reddy 2016f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 2017f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2018f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 2019f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 2020f92363d1SSreekanth Reddy return -EINVAL; 2021f92363d1SSreekanth Reddy } 2022f92363d1SSreekanth Reddy 2023f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & 2024f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) { 2025f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2026f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is already released\n", 2027f92363d1SSreekanth Reddy ioc->name, __func__, 2028f92363d1SSreekanth Reddy buffer_type); 2029f92363d1SSreekanth Reddy return 0; 2030f92363d1SSreekanth Reddy } 2031f92363d1SSreekanth Reddy 2032f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 2033f92363d1SSreekanth Reddy 2034f92363d1SSreekanth Reddy if (!request_data) { 2035f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2036f92363d1SSreekanth Reddy "%s: doesn't have memory allocated for buffer_type(0x%02x)\n", 2037f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 2038f92363d1SSreekanth Reddy return -ENOMEM; 2039f92363d1SSreekanth Reddy } 2040f92363d1SSreekanth Reddy 2041f92363d1SSreekanth Reddy /* buffers were released by due to host reset */ 2042f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 2043f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_DIAG_RESET)) { 2044f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 2045f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED; 2046f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] &= 2047f92363d1SSreekanth Reddy ~MPT3_DIAG_BUFFER_IS_DIAG_RESET; 2048f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2049f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) was released due to host reset\n", 2050f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 2051f92363d1SSreekanth Reddy return 0; 2052f92363d1SSreekanth Reddy } 2053f92363d1SSreekanth Reddy 2054f92363d1SSreekanth Reddy rc = mpt3sas_send_diag_release(ioc, buffer_type, &issue_reset); 2055f92363d1SSreekanth Reddy 2056f92363d1SSreekanth Reddy if (issue_reset) 205798c56ad3SCalvin Owens mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 2058f92363d1SSreekanth Reddy 2059f92363d1SSreekanth Reddy return rc; 2060f92363d1SSreekanth Reddy } 2061f92363d1SSreekanth Reddy 2062f92363d1SSreekanth Reddy /** 2063f92363d1SSreekanth Reddy * _ctl_diag_read_buffer - request for copy of the diag buffer 2064f92363d1SSreekanth Reddy * @ioc: per adapter object 2065f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 2066f92363d1SSreekanth Reddy */ 2067f92363d1SSreekanth Reddy static long 2068f92363d1SSreekanth Reddy _ctl_diag_read_buffer(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 2069f92363d1SSreekanth Reddy { 2070f92363d1SSreekanth Reddy struct mpt3_diag_read_buffer karg; 2071f92363d1SSreekanth Reddy struct mpt3_diag_read_buffer __user *uarg = arg; 2072f92363d1SSreekanth Reddy void *request_data, *diag_data; 2073f92363d1SSreekanth Reddy Mpi2DiagBufferPostRequest_t *mpi_request; 2074f92363d1SSreekanth Reddy Mpi2DiagBufferPostReply_t *mpi_reply; 2075f92363d1SSreekanth Reddy int rc, i; 2076f92363d1SSreekanth Reddy u8 buffer_type; 20778bbb1cf6SCalvin Owens unsigned long request_size, copy_size; 2078f92363d1SSreekanth Reddy u16 smid; 2079f92363d1SSreekanth Reddy u16 ioc_status; 2080f92363d1SSreekanth Reddy u8 issue_reset = 0; 2081f92363d1SSreekanth Reddy 2082f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 2083f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 2084f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 2085f92363d1SSreekanth Reddy return -EFAULT; 2086f92363d1SSreekanth Reddy } 2087f92363d1SSreekanth Reddy 2088f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 2089f92363d1SSreekanth Reddy __func__)); 2090f92363d1SSreekanth Reddy 2091f92363d1SSreekanth Reddy buffer_type = karg.unique_id & 0x000000ff; 2092f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 2093f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2094f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 2095f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 2096f92363d1SSreekanth Reddy return -EPERM; 2097f92363d1SSreekanth Reddy } 2098f92363d1SSreekanth Reddy 2099f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 2100f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2101f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 2102f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 2103f92363d1SSreekanth Reddy return -EINVAL; 2104f92363d1SSreekanth Reddy } 2105f92363d1SSreekanth Reddy 2106f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 2107f92363d1SSreekanth Reddy if (!request_data) { 2108f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2109f92363d1SSreekanth Reddy "%s: doesn't have buffer for buffer_type(0x%02x)\n", 2110f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 2111f92363d1SSreekanth Reddy return -ENOMEM; 2112f92363d1SSreekanth Reddy } 2113f92363d1SSreekanth Reddy 2114f92363d1SSreekanth Reddy request_size = ioc->diag_buffer_sz[buffer_type]; 2115f92363d1SSreekanth Reddy 2116f92363d1SSreekanth Reddy if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) { 2117f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: either the starting_offset " \ 2118f92363d1SSreekanth Reddy "or bytes_to_read are not 4 byte aligned\n", ioc->name, 2119f92363d1SSreekanth Reddy __func__); 2120f92363d1SSreekanth Reddy return -EINVAL; 2121f92363d1SSreekanth Reddy } 2122f92363d1SSreekanth Reddy 2123f92363d1SSreekanth Reddy if (karg.starting_offset > request_size) 2124f92363d1SSreekanth Reddy return -EINVAL; 2125f92363d1SSreekanth Reddy 2126f92363d1SSreekanth Reddy diag_data = (void *)(request_data + karg.starting_offset); 2127f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2128f92363d1SSreekanth Reddy "%s: diag_buffer(%p), offset(%d), sz(%d)\n", 2129f92363d1SSreekanth Reddy ioc->name, __func__, 2130f92363d1SSreekanth Reddy diag_data, karg.starting_offset, karg.bytes_to_read)); 2131f92363d1SSreekanth Reddy 2132f92363d1SSreekanth Reddy /* Truncate data on requests that are too large */ 2133f92363d1SSreekanth Reddy if ((diag_data + karg.bytes_to_read < diag_data) || 2134f92363d1SSreekanth Reddy (diag_data + karg.bytes_to_read > request_data + request_size)) 2135f92363d1SSreekanth Reddy copy_size = request_size - karg.starting_offset; 2136f92363d1SSreekanth Reddy else 2137f92363d1SSreekanth Reddy copy_size = karg.bytes_to_read; 2138f92363d1SSreekanth Reddy 2139f92363d1SSreekanth Reddy if (copy_to_user((void __user *)uarg->diagnostic_data, 2140f92363d1SSreekanth Reddy diag_data, copy_size)) { 2141f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2142f92363d1SSreekanth Reddy "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n", 2143f92363d1SSreekanth Reddy ioc->name, __func__, diag_data); 2144f92363d1SSreekanth Reddy return -EFAULT; 2145f92363d1SSreekanth Reddy } 2146f92363d1SSreekanth Reddy 2147f92363d1SSreekanth Reddy if ((karg.flags & MPT3_FLAGS_REREGISTER) == 0) 2148f92363d1SSreekanth Reddy return 0; 2149f92363d1SSreekanth Reddy 2150f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2151f92363d1SSreekanth Reddy "%s: Reregister buffer_type(0x%02x)\n", 2152f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type)); 2153f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 2154f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) == 0) { 2155f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2156f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is still registered\n", 2157f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type)); 2158f92363d1SSreekanth Reddy return 0; 2159f92363d1SSreekanth Reddy } 2160f92363d1SSreekanth Reddy /* Get a free request frame and save the message context. 2161f92363d1SSreekanth Reddy */ 2162f92363d1SSreekanth Reddy 2163f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 2164f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 2165f92363d1SSreekanth Reddy ioc->name, __func__); 2166f92363d1SSreekanth Reddy rc = -EAGAIN; 2167f92363d1SSreekanth Reddy goto out; 2168f92363d1SSreekanth Reddy } 2169f92363d1SSreekanth Reddy 2170f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 2171f92363d1SSreekanth Reddy if (!smid) { 2172f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 2173f92363d1SSreekanth Reddy ioc->name, __func__); 2174f92363d1SSreekanth Reddy rc = -EAGAIN; 2175f92363d1SSreekanth Reddy goto out; 2176f92363d1SSreekanth Reddy } 2177f92363d1SSreekanth Reddy 2178f92363d1SSreekanth Reddy rc = 0; 2179f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 2180f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 2181f92363d1SSreekanth Reddy mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 2182f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 2183f92363d1SSreekanth Reddy 2184f92363d1SSreekanth Reddy mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 2185f92363d1SSreekanth Reddy mpi_request->BufferType = buffer_type; 2186f92363d1SSreekanth Reddy mpi_request->BufferLength = 2187f92363d1SSreekanth Reddy cpu_to_le32(ioc->diag_buffer_sz[buffer_type]); 2188f92363d1SSreekanth Reddy mpi_request->BufferAddress = 2189f92363d1SSreekanth Reddy cpu_to_le64(ioc->diag_buffer_dma[buffer_type]); 2190f92363d1SSreekanth Reddy for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 2191f92363d1SSreekanth Reddy mpi_request->ProductSpecific[i] = 2192f92363d1SSreekanth Reddy cpu_to_le32(ioc->product_specific[buffer_type][i]); 2193f92363d1SSreekanth Reddy mpi_request->VF_ID = 0; /* TODO */ 2194f92363d1SSreekanth Reddy mpi_request->VP_ID = 0; 2195f92363d1SSreekanth Reddy 2196f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 219781c16f83SSuganath Prabu Subramani ioc->put_smid_default(ioc, smid); 21988bbb1cf6SCalvin Owens wait_for_completion_timeout(&ioc->ctl_cmds.done, 2199f92363d1SSreekanth Reddy MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 2200f92363d1SSreekanth Reddy 2201f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 2202f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 2203f92363d1SSreekanth Reddy __func__); 2204f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, 2205f92363d1SSreekanth Reddy sizeof(Mpi2DiagBufferPostRequest_t)/4); 2206f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 2207f92363d1SSreekanth Reddy issue_reset = 1; 2208f92363d1SSreekanth Reddy goto issue_host_reset; 2209f92363d1SSreekanth Reddy } 2210f92363d1SSreekanth Reddy 2211f92363d1SSreekanth Reddy /* process the completed Reply Message Frame */ 2212f92363d1SSreekanth Reddy if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 2213f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: no reply message\n", 2214f92363d1SSreekanth Reddy ioc->name, __func__); 2215f92363d1SSreekanth Reddy rc = -EFAULT; 2216f92363d1SSreekanth Reddy goto out; 2217f92363d1SSreekanth Reddy } 2218f92363d1SSreekanth Reddy 2219f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 2220f92363d1SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 2221f92363d1SSreekanth Reddy 2222f92363d1SSreekanth Reddy if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 2223f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 2224f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED; 2225f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n", 2226f92363d1SSreekanth Reddy ioc->name, __func__)); 2227f92363d1SSreekanth Reddy } else { 2228f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 2229f92363d1SSreekanth Reddy "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 2230f92363d1SSreekanth Reddy ioc->name, __func__, 2231f92363d1SSreekanth Reddy ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 2232f92363d1SSreekanth Reddy rc = -EFAULT; 2233f92363d1SSreekanth Reddy } 2234f92363d1SSreekanth Reddy 2235f92363d1SSreekanth Reddy issue_host_reset: 2236f92363d1SSreekanth Reddy if (issue_reset) 223798c56ad3SCalvin Owens mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 2238f92363d1SSreekanth Reddy 2239f92363d1SSreekanth Reddy out: 2240f92363d1SSreekanth Reddy 2241f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 2242f92363d1SSreekanth Reddy return rc; 2243f92363d1SSreekanth Reddy } 2244f92363d1SSreekanth Reddy 2245f92363d1SSreekanth Reddy 2246f92363d1SSreekanth Reddy 2247f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2248f92363d1SSreekanth Reddy /** 2249f92363d1SSreekanth Reddy * _ctl_compat_mpt_command - convert 32bit pointers to 64bit. 2250f92363d1SSreekanth Reddy * @ioc: per adapter object 2251f92363d1SSreekanth Reddy * @cmd - ioctl opcode 2252f92363d1SSreekanth Reddy * @arg - (struct mpt3_ioctl_command32) 2253f92363d1SSreekanth Reddy * 2254f92363d1SSreekanth Reddy * MPT3COMMAND32 - Handle 32bit applications running on 64bit os. 2255f92363d1SSreekanth Reddy */ 2256f92363d1SSreekanth Reddy static long 2257f92363d1SSreekanth Reddy _ctl_compat_mpt_command(struct MPT3SAS_ADAPTER *ioc, unsigned cmd, 2258f92363d1SSreekanth Reddy void __user *arg) 2259f92363d1SSreekanth Reddy { 2260f92363d1SSreekanth Reddy struct mpt3_ioctl_command32 karg32; 2261f92363d1SSreekanth Reddy struct mpt3_ioctl_command32 __user *uarg; 2262f92363d1SSreekanth Reddy struct mpt3_ioctl_command karg; 2263f92363d1SSreekanth Reddy 2264f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) != sizeof(struct mpt3_ioctl_command32)) 2265f92363d1SSreekanth Reddy return -EINVAL; 2266f92363d1SSreekanth Reddy 2267f92363d1SSreekanth Reddy uarg = (struct mpt3_ioctl_command32 __user *) arg; 2268f92363d1SSreekanth Reddy 2269f92363d1SSreekanth Reddy if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) { 2270f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 2271f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 2272f92363d1SSreekanth Reddy return -EFAULT; 2273f92363d1SSreekanth Reddy } 2274f92363d1SSreekanth Reddy 2275f92363d1SSreekanth Reddy memset(&karg, 0, sizeof(struct mpt3_ioctl_command)); 2276f92363d1SSreekanth Reddy karg.hdr.ioc_number = karg32.hdr.ioc_number; 2277f92363d1SSreekanth Reddy karg.hdr.port_number = karg32.hdr.port_number; 2278f92363d1SSreekanth Reddy karg.hdr.max_data_size = karg32.hdr.max_data_size; 2279f92363d1SSreekanth Reddy karg.timeout = karg32.timeout; 2280f92363d1SSreekanth Reddy karg.max_reply_bytes = karg32.max_reply_bytes; 2281f92363d1SSreekanth Reddy karg.data_in_size = karg32.data_in_size; 2282f92363d1SSreekanth Reddy karg.data_out_size = karg32.data_out_size; 2283f92363d1SSreekanth Reddy karg.max_sense_bytes = karg32.max_sense_bytes; 2284f92363d1SSreekanth Reddy karg.data_sge_offset = karg32.data_sge_offset; 2285f92363d1SSreekanth Reddy karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr); 2286f92363d1SSreekanth Reddy karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr); 2287f92363d1SSreekanth Reddy karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr); 2288f92363d1SSreekanth Reddy karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr); 2289f92363d1SSreekanth Reddy return _ctl_do_mpt_command(ioc, karg, &uarg->mf); 2290f92363d1SSreekanth Reddy } 2291f92363d1SSreekanth Reddy #endif 2292f92363d1SSreekanth Reddy 2293f92363d1SSreekanth Reddy /** 2294f92363d1SSreekanth Reddy * _ctl_ioctl_main - main ioctl entry point 2295f92363d1SSreekanth Reddy * @file - (struct file) 2296f92363d1SSreekanth Reddy * @cmd - ioctl opcode 2297c84b06a4SSreekanth Reddy * @arg - user space data buffer 2298c84b06a4SSreekanth Reddy * @compat - handles 32 bit applications in 64bit os 2299c84b06a4SSreekanth Reddy * @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device & 2300b130b0d5SSuganath prabu Subramani * MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device. 2301f92363d1SSreekanth Reddy */ 2302f92363d1SSreekanth Reddy static long 2303f92363d1SSreekanth Reddy _ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg, 2304c84b06a4SSreekanth Reddy u8 compat, u16 mpi_version) 2305f92363d1SSreekanth Reddy { 2306f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 2307f92363d1SSreekanth Reddy struct mpt3_ioctl_header ioctl_header; 2308f92363d1SSreekanth Reddy enum block_state state; 2309f92363d1SSreekanth Reddy long ret = -EINVAL; 2310f92363d1SSreekanth Reddy 2311f92363d1SSreekanth Reddy /* get IOCTL header */ 2312f92363d1SSreekanth Reddy if (copy_from_user(&ioctl_header, (char __user *)arg, 2313f92363d1SSreekanth Reddy sizeof(struct mpt3_ioctl_header))) { 2314f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 2315f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 2316f92363d1SSreekanth Reddy return -EFAULT; 2317f92363d1SSreekanth Reddy } 2318f92363d1SSreekanth Reddy 2319c84b06a4SSreekanth Reddy if (_ctl_verify_adapter(ioctl_header.ioc_number, 2320c84b06a4SSreekanth Reddy &ioc, mpi_version) == -1 || !ioc) 2321f92363d1SSreekanth Reddy return -ENODEV; 2322f92363d1SSreekanth Reddy 232308c4d550SSreekanth Reddy /* pci_access_mutex lock acquired by ioctl path */ 232408c4d550SSreekanth Reddy mutex_lock(&ioc->pci_access_mutex); 232508c4d550SSreekanth Reddy 2326f92363d1SSreekanth Reddy if (ioc->shost_recovery || ioc->pci_error_recovery || 232708c4d550SSreekanth Reddy ioc->is_driver_loading || ioc->remove_host) { 232808c4d550SSreekanth Reddy ret = -EAGAIN; 232908c4d550SSreekanth Reddy goto out_unlock_pciaccess; 233008c4d550SSreekanth Reddy } 2331f92363d1SSreekanth Reddy 2332f92363d1SSreekanth Reddy state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING; 2333f92363d1SSreekanth Reddy if (state == NON_BLOCKING) { 233408c4d550SSreekanth Reddy if (!mutex_trylock(&ioc->ctl_cmds.mutex)) { 233508c4d550SSreekanth Reddy ret = -EAGAIN; 233608c4d550SSreekanth Reddy goto out_unlock_pciaccess; 233708c4d550SSreekanth Reddy } 233808c4d550SSreekanth Reddy } else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) { 233908c4d550SSreekanth Reddy ret = -ERESTARTSYS; 234008c4d550SSreekanth Reddy goto out_unlock_pciaccess; 234108c4d550SSreekanth Reddy } 2342f92363d1SSreekanth Reddy 2343f92363d1SSreekanth Reddy 2344f92363d1SSreekanth Reddy switch (cmd) { 2345f92363d1SSreekanth Reddy case MPT3IOCINFO: 2346f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_iocinfo)) 2347f92363d1SSreekanth Reddy ret = _ctl_getiocinfo(ioc, arg); 2348f92363d1SSreekanth Reddy break; 2349f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2350f92363d1SSreekanth Reddy case MPT3COMMAND32: 2351f92363d1SSreekanth Reddy #endif 2352f92363d1SSreekanth Reddy case MPT3COMMAND: 2353f92363d1SSreekanth Reddy { 2354f92363d1SSreekanth Reddy struct mpt3_ioctl_command __user *uarg; 2355f92363d1SSreekanth Reddy struct mpt3_ioctl_command karg; 2356f92363d1SSreekanth Reddy 2357f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2358f92363d1SSreekanth Reddy if (compat) { 2359f92363d1SSreekanth Reddy ret = _ctl_compat_mpt_command(ioc, cmd, arg); 2360f92363d1SSreekanth Reddy break; 2361f92363d1SSreekanth Reddy } 2362f92363d1SSreekanth Reddy #endif 2363f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 2364f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 2365f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 2366f92363d1SSreekanth Reddy ret = -EFAULT; 2367f92363d1SSreekanth Reddy break; 2368f92363d1SSreekanth Reddy } 2369f92363d1SSreekanth Reddy 2370f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_command)) { 2371f92363d1SSreekanth Reddy uarg = arg; 2372f92363d1SSreekanth Reddy ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf); 2373f92363d1SSreekanth Reddy } 2374f92363d1SSreekanth Reddy break; 2375f92363d1SSreekanth Reddy } 2376f92363d1SSreekanth Reddy case MPT3EVENTQUERY: 2377f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventquery)) 2378f92363d1SSreekanth Reddy ret = _ctl_eventquery(ioc, arg); 2379f92363d1SSreekanth Reddy break; 2380f92363d1SSreekanth Reddy case MPT3EVENTENABLE: 2381f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventenable)) 2382f92363d1SSreekanth Reddy ret = _ctl_eventenable(ioc, arg); 2383f92363d1SSreekanth Reddy break; 2384f92363d1SSreekanth Reddy case MPT3EVENTREPORT: 2385f92363d1SSreekanth Reddy ret = _ctl_eventreport(ioc, arg); 2386f92363d1SSreekanth Reddy break; 2387f92363d1SSreekanth Reddy case MPT3HARDRESET: 2388f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_diag_reset)) 2389f92363d1SSreekanth Reddy ret = _ctl_do_reset(ioc, arg); 2390f92363d1SSreekanth Reddy break; 2391f92363d1SSreekanth Reddy case MPT3BTDHMAPPING: 2392f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_btdh_mapping)) 2393f92363d1SSreekanth Reddy ret = _ctl_btdh_mapping(ioc, arg); 2394f92363d1SSreekanth Reddy break; 2395f92363d1SSreekanth Reddy case MPT3DIAGREGISTER: 2396f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_register)) 2397f92363d1SSreekanth Reddy ret = _ctl_diag_register(ioc, arg); 2398f92363d1SSreekanth Reddy break; 2399f92363d1SSreekanth Reddy case MPT3DIAGUNREGISTER: 2400f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_unregister)) 2401f92363d1SSreekanth Reddy ret = _ctl_diag_unregister(ioc, arg); 2402f92363d1SSreekanth Reddy break; 2403f92363d1SSreekanth Reddy case MPT3DIAGQUERY: 2404f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_query)) 2405f92363d1SSreekanth Reddy ret = _ctl_diag_query(ioc, arg); 2406f92363d1SSreekanth Reddy break; 2407f92363d1SSreekanth Reddy case MPT3DIAGRELEASE: 2408f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_release)) 2409f92363d1SSreekanth Reddy ret = _ctl_diag_release(ioc, arg); 2410f92363d1SSreekanth Reddy break; 2411f92363d1SSreekanth Reddy case MPT3DIAGREADBUFFER: 2412f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_read_buffer)) 2413f92363d1SSreekanth Reddy ret = _ctl_diag_read_buffer(ioc, arg); 2414f92363d1SSreekanth Reddy break; 2415f92363d1SSreekanth Reddy default: 2416f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2417f92363d1SSreekanth Reddy "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd)); 2418f92363d1SSreekanth Reddy break; 2419f92363d1SSreekanth Reddy } 2420f92363d1SSreekanth Reddy 2421f92363d1SSreekanth Reddy mutex_unlock(&ioc->ctl_cmds.mutex); 242208c4d550SSreekanth Reddy out_unlock_pciaccess: 242308c4d550SSreekanth Reddy mutex_unlock(&ioc->pci_access_mutex); 2424f92363d1SSreekanth Reddy return ret; 2425f92363d1SSreekanth Reddy } 2426f92363d1SSreekanth Reddy 2427f92363d1SSreekanth Reddy /** 2428c84b06a4SSreekanth Reddy * _ctl_ioctl - mpt3ctl main ioctl entry point (unlocked) 2429f92363d1SSreekanth Reddy * @file - (struct file) 2430f92363d1SSreekanth Reddy * @cmd - ioctl opcode 2431f92363d1SSreekanth Reddy * @arg - 2432f92363d1SSreekanth Reddy */ 24338bbb1cf6SCalvin Owens static long 2434c84b06a4SSreekanth Reddy _ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2435f92363d1SSreekanth Reddy { 2436f92363d1SSreekanth Reddy long ret; 2437f92363d1SSreekanth Reddy 2438b130b0d5SSuganath prabu Subramani /* pass MPI25_VERSION | MPI26_VERSION value, 2439b130b0d5SSuganath prabu Subramani * to indicate that this ioctl cmd 2440c84b06a4SSreekanth Reddy * came from mpt3ctl ioctl device. 2441c84b06a4SSreekanth Reddy */ 2442b130b0d5SSuganath prabu Subramani ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0, 2443b130b0d5SSuganath prabu Subramani MPI25_VERSION | MPI26_VERSION); 2444f92363d1SSreekanth Reddy return ret; 2445f92363d1SSreekanth Reddy } 2446f92363d1SSreekanth Reddy 2447c84b06a4SSreekanth Reddy /** 2448c84b06a4SSreekanth Reddy * _ctl_mpt2_ioctl - mpt2ctl main ioctl entry point (unlocked) 2449c84b06a4SSreekanth Reddy * @file - (struct file) 2450c84b06a4SSreekanth Reddy * @cmd - ioctl opcode 2451c84b06a4SSreekanth Reddy * @arg - 2452c84b06a4SSreekanth Reddy */ 24538bbb1cf6SCalvin Owens static long 2454c84b06a4SSreekanth Reddy _ctl_mpt2_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2455c84b06a4SSreekanth Reddy { 2456c84b06a4SSreekanth Reddy long ret; 2457c84b06a4SSreekanth Reddy 2458c84b06a4SSreekanth Reddy /* pass MPI2_VERSION value, to indicate that this ioctl cmd 2459c84b06a4SSreekanth Reddy * came from mpt2ctl ioctl device. 2460c84b06a4SSreekanth Reddy */ 2461c84b06a4SSreekanth Reddy ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0, MPI2_VERSION); 2462c84b06a4SSreekanth Reddy return ret; 2463c84b06a4SSreekanth Reddy } 2464f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2465f92363d1SSreekanth Reddy /** 2466c84b06a4SSreekanth Reddy *_ ctl_ioctl_compat - main ioctl entry point (compat) 2467f92363d1SSreekanth Reddy * @file - 2468f92363d1SSreekanth Reddy * @cmd - 2469f92363d1SSreekanth Reddy * @arg - 2470f92363d1SSreekanth Reddy * 2471f92363d1SSreekanth Reddy * This routine handles 32 bit applications in 64bit os. 2472f92363d1SSreekanth Reddy */ 24738bbb1cf6SCalvin Owens static long 2474c84b06a4SSreekanth Reddy _ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg) 2475f92363d1SSreekanth Reddy { 2476f92363d1SSreekanth Reddy long ret; 2477f92363d1SSreekanth Reddy 2478b130b0d5SSuganath prabu Subramani ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1, 2479b130b0d5SSuganath prabu Subramani MPI25_VERSION | MPI26_VERSION); 2480c84b06a4SSreekanth Reddy return ret; 2481c84b06a4SSreekanth Reddy } 2482c84b06a4SSreekanth Reddy 2483c84b06a4SSreekanth Reddy /** 2484c84b06a4SSreekanth Reddy *_ ctl_mpt2_ioctl_compat - main ioctl entry point (compat) 2485c84b06a4SSreekanth Reddy * @file - 2486c84b06a4SSreekanth Reddy * @cmd - 2487c84b06a4SSreekanth Reddy * @arg - 2488c84b06a4SSreekanth Reddy * 2489c84b06a4SSreekanth Reddy * This routine handles 32 bit applications in 64bit os. 2490c84b06a4SSreekanth Reddy */ 24918bbb1cf6SCalvin Owens static long 2492c84b06a4SSreekanth Reddy _ctl_mpt2_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg) 2493c84b06a4SSreekanth Reddy { 2494c84b06a4SSreekanth Reddy long ret; 2495c84b06a4SSreekanth Reddy 2496c84b06a4SSreekanth Reddy ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1, MPI2_VERSION); 2497f92363d1SSreekanth Reddy return ret; 2498f92363d1SSreekanth Reddy } 2499f92363d1SSreekanth Reddy #endif 2500f92363d1SSreekanth Reddy 2501f92363d1SSreekanth Reddy /* scsi host attributes */ 2502f92363d1SSreekanth Reddy /** 2503f92363d1SSreekanth Reddy * _ctl_version_fw_show - firmware version 2504f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2505f92363d1SSreekanth Reddy * @buf - the buffer returned 2506f92363d1SSreekanth Reddy * 2507f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2508f92363d1SSreekanth Reddy */ 2509f92363d1SSreekanth Reddy static ssize_t 2510f92363d1SSreekanth Reddy _ctl_version_fw_show(struct device *cdev, struct device_attribute *attr, 2511f92363d1SSreekanth Reddy char *buf) 2512f92363d1SSreekanth Reddy { 2513f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2514f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2515f92363d1SSreekanth Reddy 2516f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2517f92363d1SSreekanth Reddy (ioc->facts.FWVersion.Word & 0xFF000000) >> 24, 2518f92363d1SSreekanth Reddy (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16, 2519f92363d1SSreekanth Reddy (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8, 2520f92363d1SSreekanth Reddy ioc->facts.FWVersion.Word & 0x000000FF); 2521f92363d1SSreekanth Reddy } 2522f92363d1SSreekanth Reddy static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL); 2523f92363d1SSreekanth Reddy 2524f92363d1SSreekanth Reddy /** 2525f92363d1SSreekanth Reddy * _ctl_version_bios_show - bios version 2526f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2527f92363d1SSreekanth Reddy * @buf - the buffer returned 2528f92363d1SSreekanth Reddy * 2529f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2530f92363d1SSreekanth Reddy */ 2531f92363d1SSreekanth Reddy static ssize_t 2532f92363d1SSreekanth Reddy _ctl_version_bios_show(struct device *cdev, struct device_attribute *attr, 2533f92363d1SSreekanth Reddy char *buf) 2534f92363d1SSreekanth Reddy { 2535f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2536f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2537f92363d1SSreekanth Reddy 2538f92363d1SSreekanth Reddy u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 2539f92363d1SSreekanth Reddy 2540f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2541f92363d1SSreekanth Reddy (version & 0xFF000000) >> 24, 2542f92363d1SSreekanth Reddy (version & 0x00FF0000) >> 16, 2543f92363d1SSreekanth Reddy (version & 0x0000FF00) >> 8, 2544f92363d1SSreekanth Reddy version & 0x000000FF); 2545f92363d1SSreekanth Reddy } 2546f92363d1SSreekanth Reddy static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL); 2547f92363d1SSreekanth Reddy 2548f92363d1SSreekanth Reddy /** 2549f92363d1SSreekanth Reddy * _ctl_version_mpi_show - MPI (message passing interface) version 2550f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2551f92363d1SSreekanth Reddy * @buf - the buffer returned 2552f92363d1SSreekanth Reddy * 2553f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2554f92363d1SSreekanth Reddy */ 2555f92363d1SSreekanth Reddy static ssize_t 2556f92363d1SSreekanth Reddy _ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr, 2557f92363d1SSreekanth Reddy char *buf) 2558f92363d1SSreekanth Reddy { 2559f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2560f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2561f92363d1SSreekanth Reddy 2562f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%03x.%02x\n", 2563f92363d1SSreekanth Reddy ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8); 2564f92363d1SSreekanth Reddy } 2565f92363d1SSreekanth Reddy static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL); 2566f92363d1SSreekanth Reddy 2567f92363d1SSreekanth Reddy /** 2568f92363d1SSreekanth Reddy * _ctl_version_product_show - product name 2569f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2570f92363d1SSreekanth Reddy * @buf - the buffer returned 2571f92363d1SSreekanth Reddy * 2572f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2573f92363d1SSreekanth Reddy */ 2574f92363d1SSreekanth Reddy static ssize_t 2575f92363d1SSreekanth Reddy _ctl_version_product_show(struct device *cdev, struct device_attribute *attr, 2576f92363d1SSreekanth Reddy char *buf) 2577f92363d1SSreekanth Reddy { 2578f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2579f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2580f92363d1SSreekanth Reddy 2581f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName); 2582f92363d1SSreekanth Reddy } 2583f92363d1SSreekanth Reddy static DEVICE_ATTR(version_product, S_IRUGO, _ctl_version_product_show, NULL); 2584f92363d1SSreekanth Reddy 2585f92363d1SSreekanth Reddy /** 2586f92363d1SSreekanth Reddy * _ctl_version_nvdata_persistent_show - ndvata persistent version 2587f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2588f92363d1SSreekanth Reddy * @buf - the buffer returned 2589f92363d1SSreekanth Reddy * 2590f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2591f92363d1SSreekanth Reddy */ 2592f92363d1SSreekanth Reddy static ssize_t 2593f92363d1SSreekanth Reddy _ctl_version_nvdata_persistent_show(struct device *cdev, 2594f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 2595f92363d1SSreekanth Reddy { 2596f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2597f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2598f92363d1SSreekanth Reddy 2599f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%08xh\n", 2600f92363d1SSreekanth Reddy le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word)); 2601f92363d1SSreekanth Reddy } 2602f92363d1SSreekanth Reddy static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO, 2603f92363d1SSreekanth Reddy _ctl_version_nvdata_persistent_show, NULL); 2604f92363d1SSreekanth Reddy 2605f92363d1SSreekanth Reddy /** 2606f92363d1SSreekanth Reddy * _ctl_version_nvdata_default_show - nvdata default version 2607f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2608f92363d1SSreekanth Reddy * @buf - the buffer returned 2609f92363d1SSreekanth Reddy * 2610f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2611f92363d1SSreekanth Reddy */ 2612f92363d1SSreekanth Reddy static ssize_t 2613f92363d1SSreekanth Reddy _ctl_version_nvdata_default_show(struct device *cdev, struct device_attribute 2614f92363d1SSreekanth Reddy *attr, char *buf) 2615f92363d1SSreekanth Reddy { 2616f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2617f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2618f92363d1SSreekanth Reddy 2619f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%08xh\n", 2620f92363d1SSreekanth Reddy le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word)); 2621f92363d1SSreekanth Reddy } 2622f92363d1SSreekanth Reddy static DEVICE_ATTR(version_nvdata_default, S_IRUGO, 2623f92363d1SSreekanth Reddy _ctl_version_nvdata_default_show, NULL); 2624f92363d1SSreekanth Reddy 2625f92363d1SSreekanth Reddy /** 2626f92363d1SSreekanth Reddy * _ctl_board_name_show - board name 2627f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2628f92363d1SSreekanth Reddy * @buf - the buffer returned 2629f92363d1SSreekanth Reddy * 2630f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2631f92363d1SSreekanth Reddy */ 2632f92363d1SSreekanth Reddy static ssize_t 2633f92363d1SSreekanth Reddy _ctl_board_name_show(struct device *cdev, struct device_attribute *attr, 2634f92363d1SSreekanth Reddy char *buf) 2635f92363d1SSreekanth Reddy { 2636f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2637f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2638f92363d1SSreekanth Reddy 2639f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName); 2640f92363d1SSreekanth Reddy } 2641f92363d1SSreekanth Reddy static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL); 2642f92363d1SSreekanth Reddy 2643f92363d1SSreekanth Reddy /** 2644f92363d1SSreekanth Reddy * _ctl_board_assembly_show - board assembly name 2645f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2646f92363d1SSreekanth Reddy * @buf - the buffer returned 2647f92363d1SSreekanth Reddy * 2648f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2649f92363d1SSreekanth Reddy */ 2650f92363d1SSreekanth Reddy static ssize_t 2651f92363d1SSreekanth Reddy _ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr, 2652f92363d1SSreekanth Reddy char *buf) 2653f92363d1SSreekanth Reddy { 2654f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2655f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2656f92363d1SSreekanth Reddy 2657f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly); 2658f92363d1SSreekanth Reddy } 2659f92363d1SSreekanth Reddy static DEVICE_ATTR(board_assembly, S_IRUGO, _ctl_board_assembly_show, NULL); 2660f92363d1SSreekanth Reddy 2661f92363d1SSreekanth Reddy /** 2662f92363d1SSreekanth Reddy * _ctl_board_tracer_show - board tracer number 2663f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2664f92363d1SSreekanth Reddy * @buf - the buffer returned 2665f92363d1SSreekanth Reddy * 2666f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2667f92363d1SSreekanth Reddy */ 2668f92363d1SSreekanth Reddy static ssize_t 2669f92363d1SSreekanth Reddy _ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr, 2670f92363d1SSreekanth Reddy char *buf) 2671f92363d1SSreekanth Reddy { 2672f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2673f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2674f92363d1SSreekanth Reddy 2675f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber); 2676f92363d1SSreekanth Reddy } 2677f92363d1SSreekanth Reddy static DEVICE_ATTR(board_tracer, S_IRUGO, _ctl_board_tracer_show, NULL); 2678f92363d1SSreekanth Reddy 2679f92363d1SSreekanth Reddy /** 2680f92363d1SSreekanth Reddy * _ctl_io_delay_show - io missing delay 2681f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2682f92363d1SSreekanth Reddy * @buf - the buffer returned 2683f92363d1SSreekanth Reddy * 2684f92363d1SSreekanth Reddy * This is for firmware implemention for deboucing device 2685f92363d1SSreekanth Reddy * removal events. 2686f92363d1SSreekanth Reddy * 2687f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2688f92363d1SSreekanth Reddy */ 2689f92363d1SSreekanth Reddy static ssize_t 2690f92363d1SSreekanth Reddy _ctl_io_delay_show(struct device *cdev, struct device_attribute *attr, 2691f92363d1SSreekanth Reddy char *buf) 2692f92363d1SSreekanth Reddy { 2693f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2694f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2695f92363d1SSreekanth Reddy 2696f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay); 2697f92363d1SSreekanth Reddy } 2698f92363d1SSreekanth Reddy static DEVICE_ATTR(io_delay, S_IRUGO, _ctl_io_delay_show, NULL); 2699f92363d1SSreekanth Reddy 2700f92363d1SSreekanth Reddy /** 2701f92363d1SSreekanth Reddy * _ctl_device_delay_show - device missing delay 2702f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2703f92363d1SSreekanth Reddy * @buf - the buffer returned 2704f92363d1SSreekanth Reddy * 2705f92363d1SSreekanth Reddy * This is for firmware implemention for deboucing device 2706f92363d1SSreekanth Reddy * removal events. 2707f92363d1SSreekanth Reddy * 2708f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2709f92363d1SSreekanth Reddy */ 2710f92363d1SSreekanth Reddy static ssize_t 2711f92363d1SSreekanth Reddy _ctl_device_delay_show(struct device *cdev, struct device_attribute *attr, 2712f92363d1SSreekanth Reddy char *buf) 2713f92363d1SSreekanth Reddy { 2714f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2715f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2716f92363d1SSreekanth Reddy 2717f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay); 2718f92363d1SSreekanth Reddy } 2719f92363d1SSreekanth Reddy static DEVICE_ATTR(device_delay, S_IRUGO, _ctl_device_delay_show, NULL); 2720f92363d1SSreekanth Reddy 2721f92363d1SSreekanth Reddy /** 2722f92363d1SSreekanth Reddy * _ctl_fw_queue_depth_show - global credits 2723f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2724f92363d1SSreekanth Reddy * @buf - the buffer returned 2725f92363d1SSreekanth Reddy * 2726f92363d1SSreekanth Reddy * This is firmware queue depth limit 2727f92363d1SSreekanth Reddy * 2728f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2729f92363d1SSreekanth Reddy */ 2730f92363d1SSreekanth Reddy static ssize_t 2731f92363d1SSreekanth Reddy _ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr, 2732f92363d1SSreekanth Reddy char *buf) 2733f92363d1SSreekanth Reddy { 2734f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2735f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2736f92363d1SSreekanth Reddy 2737f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit); 2738f92363d1SSreekanth Reddy } 2739f92363d1SSreekanth Reddy static DEVICE_ATTR(fw_queue_depth, S_IRUGO, _ctl_fw_queue_depth_show, NULL); 2740f92363d1SSreekanth Reddy 2741f92363d1SSreekanth Reddy /** 2742f92363d1SSreekanth Reddy * _ctl_sas_address_show - sas address 2743f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2744f92363d1SSreekanth Reddy * @buf - the buffer returned 2745f92363d1SSreekanth Reddy * 2746f92363d1SSreekanth Reddy * This is the controller sas address 2747f92363d1SSreekanth Reddy * 2748f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2749f92363d1SSreekanth Reddy */ 2750f92363d1SSreekanth Reddy static ssize_t 2751f92363d1SSreekanth Reddy _ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr, 2752f92363d1SSreekanth Reddy char *buf) 2753f92363d1SSreekanth Reddy 2754f92363d1SSreekanth Reddy { 2755f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2756f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2757f92363d1SSreekanth Reddy 2758f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 2759f92363d1SSreekanth Reddy (unsigned long long)ioc->sas_hba.sas_address); 2760f92363d1SSreekanth Reddy } 2761f92363d1SSreekanth Reddy static DEVICE_ATTR(host_sas_address, S_IRUGO, 2762f92363d1SSreekanth Reddy _ctl_host_sas_address_show, NULL); 2763f92363d1SSreekanth Reddy 2764f92363d1SSreekanth Reddy /** 2765f92363d1SSreekanth Reddy * _ctl_logging_level_show - logging level 2766f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2767f92363d1SSreekanth Reddy * @buf - the buffer returned 2768f92363d1SSreekanth Reddy * 2769f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 2770f92363d1SSreekanth Reddy */ 2771f92363d1SSreekanth Reddy static ssize_t 2772f92363d1SSreekanth Reddy _ctl_logging_level_show(struct device *cdev, struct device_attribute *attr, 2773f92363d1SSreekanth Reddy char *buf) 2774f92363d1SSreekanth Reddy { 2775f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2776f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2777f92363d1SSreekanth Reddy 2778f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level); 2779f92363d1SSreekanth Reddy } 2780f92363d1SSreekanth Reddy static ssize_t 2781f92363d1SSreekanth Reddy _ctl_logging_level_store(struct device *cdev, struct device_attribute *attr, 2782f92363d1SSreekanth Reddy const char *buf, size_t count) 2783f92363d1SSreekanth Reddy { 2784f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2785f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2786f92363d1SSreekanth Reddy int val = 0; 2787f92363d1SSreekanth Reddy 2788f92363d1SSreekanth Reddy if (sscanf(buf, "%x", &val) != 1) 2789f92363d1SSreekanth Reddy return -EINVAL; 2790f92363d1SSreekanth Reddy 2791f92363d1SSreekanth Reddy ioc->logging_level = val; 2792f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "logging_level=%08xh\n", ioc->name, 2793f92363d1SSreekanth Reddy ioc->logging_level); 2794f92363d1SSreekanth Reddy return strlen(buf); 2795f92363d1SSreekanth Reddy } 2796f92363d1SSreekanth Reddy static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR, _ctl_logging_level_show, 2797f92363d1SSreekanth Reddy _ctl_logging_level_store); 2798f92363d1SSreekanth Reddy 2799f92363d1SSreekanth Reddy /** 2800f92363d1SSreekanth Reddy * _ctl_fwfault_debug_show - show/store fwfault_debug 2801f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2802f92363d1SSreekanth Reddy * @buf - the buffer returned 2803f92363d1SSreekanth Reddy * 2804f92363d1SSreekanth Reddy * mpt3sas_fwfault_debug is command line option 2805f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 2806f92363d1SSreekanth Reddy */ 2807f92363d1SSreekanth Reddy static ssize_t 2808f92363d1SSreekanth Reddy _ctl_fwfault_debug_show(struct device *cdev, struct device_attribute *attr, 2809f92363d1SSreekanth Reddy char *buf) 2810f92363d1SSreekanth Reddy { 2811f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2812f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2813f92363d1SSreekanth Reddy 2814f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug); 2815f92363d1SSreekanth Reddy } 2816f92363d1SSreekanth Reddy static ssize_t 2817f92363d1SSreekanth Reddy _ctl_fwfault_debug_store(struct device *cdev, struct device_attribute *attr, 2818f92363d1SSreekanth Reddy const char *buf, size_t count) 2819f92363d1SSreekanth Reddy { 2820f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2821f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2822f92363d1SSreekanth Reddy int val = 0; 2823f92363d1SSreekanth Reddy 2824f92363d1SSreekanth Reddy if (sscanf(buf, "%d", &val) != 1) 2825f92363d1SSreekanth Reddy return -EINVAL; 2826f92363d1SSreekanth Reddy 2827f92363d1SSreekanth Reddy ioc->fwfault_debug = val; 2828f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "fwfault_debug=%d\n", ioc->name, 2829f92363d1SSreekanth Reddy ioc->fwfault_debug); 2830f92363d1SSreekanth Reddy return strlen(buf); 2831f92363d1SSreekanth Reddy } 2832f92363d1SSreekanth Reddy static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR, 2833f92363d1SSreekanth Reddy _ctl_fwfault_debug_show, _ctl_fwfault_debug_store); 2834f92363d1SSreekanth Reddy 2835f92363d1SSreekanth Reddy /** 2836f92363d1SSreekanth Reddy * _ctl_ioc_reset_count_show - ioc reset count 2837f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2838f92363d1SSreekanth Reddy * @buf - the buffer returned 2839f92363d1SSreekanth Reddy * 2840f92363d1SSreekanth Reddy * This is firmware queue depth limit 2841f92363d1SSreekanth Reddy * 2842f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2843f92363d1SSreekanth Reddy */ 2844f92363d1SSreekanth Reddy static ssize_t 2845f92363d1SSreekanth Reddy _ctl_ioc_reset_count_show(struct device *cdev, struct device_attribute *attr, 2846f92363d1SSreekanth Reddy char *buf) 2847f92363d1SSreekanth Reddy { 2848f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2849f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2850f92363d1SSreekanth Reddy 2851f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", ioc->ioc_reset_count); 2852f92363d1SSreekanth Reddy } 2853f92363d1SSreekanth Reddy static DEVICE_ATTR(ioc_reset_count, S_IRUGO, _ctl_ioc_reset_count_show, NULL); 2854f92363d1SSreekanth Reddy 2855f92363d1SSreekanth Reddy /** 2856f92363d1SSreekanth Reddy * _ctl_ioc_reply_queue_count_show - number of reply queues 2857f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2858f92363d1SSreekanth Reddy * @buf - the buffer returned 2859f92363d1SSreekanth Reddy * 2860f92363d1SSreekanth Reddy * This is number of reply queues 2861f92363d1SSreekanth Reddy * 2862f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2863f92363d1SSreekanth Reddy */ 2864f92363d1SSreekanth Reddy static ssize_t 2865f92363d1SSreekanth Reddy _ctl_ioc_reply_queue_count_show(struct device *cdev, 2866f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 2867f92363d1SSreekanth Reddy { 2868f92363d1SSreekanth Reddy u8 reply_queue_count; 2869f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2870f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2871f92363d1SSreekanth Reddy 2872f92363d1SSreekanth Reddy if ((ioc->facts.IOCCapabilities & 2873f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX) && ioc->msix_enable) 2874f92363d1SSreekanth Reddy reply_queue_count = ioc->reply_queue_count; 2875f92363d1SSreekanth Reddy else 2876f92363d1SSreekanth Reddy reply_queue_count = 1; 2877f92363d1SSreekanth Reddy 2878f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", reply_queue_count); 2879f92363d1SSreekanth Reddy } 2880f92363d1SSreekanth Reddy static DEVICE_ATTR(reply_queue_count, S_IRUGO, _ctl_ioc_reply_queue_count_show, 2881f92363d1SSreekanth Reddy NULL); 2882f92363d1SSreekanth Reddy 288342263095SSreekanth Reddy /** 288442263095SSreekanth Reddy * _ctl_BRM_status_show - Backup Rail Monitor Status 288542263095SSreekanth Reddy * @cdev - pointer to embedded class device 288642263095SSreekanth Reddy * @buf - the buffer returned 288742263095SSreekanth Reddy * 288842263095SSreekanth Reddy * This is number of reply queues 288942263095SSreekanth Reddy * 289042263095SSreekanth Reddy * A sysfs 'read-only' shost attribute. 289142263095SSreekanth Reddy */ 289242263095SSreekanth Reddy static ssize_t 289342263095SSreekanth Reddy _ctl_BRM_status_show(struct device *cdev, struct device_attribute *attr, 289442263095SSreekanth Reddy char *buf) 289542263095SSreekanth Reddy { 289642263095SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 289742263095SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 289842263095SSreekanth Reddy Mpi2IOUnitPage3_t *io_unit_pg3 = NULL; 289942263095SSreekanth Reddy Mpi2ConfigReply_t mpi_reply; 290042263095SSreekanth Reddy u16 backup_rail_monitor_status = 0; 290142263095SSreekanth Reddy u16 ioc_status; 290242263095SSreekanth Reddy int sz; 290342263095SSreekanth Reddy ssize_t rc = 0; 290442263095SSreekanth Reddy 290542263095SSreekanth Reddy if (!ioc->is_warpdrive) { 290642263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: BRM attribute is only for" 290742263095SSreekanth Reddy " warpdrive\n", ioc->name, __func__); 290842263095SSreekanth Reddy goto out; 290942263095SSreekanth Reddy } 291008c4d550SSreekanth Reddy /* pci_access_mutex lock acquired by sysfs show path */ 291108c4d550SSreekanth Reddy mutex_lock(&ioc->pci_access_mutex); 291208c4d550SSreekanth Reddy if (ioc->pci_error_recovery || ioc->remove_host) { 291308c4d550SSreekanth Reddy mutex_unlock(&ioc->pci_access_mutex); 291408c4d550SSreekanth Reddy return 0; 291508c4d550SSreekanth Reddy } 291642263095SSreekanth Reddy 291742263095SSreekanth Reddy /* allocate upto GPIOVal 36 entries */ 291842263095SSreekanth Reddy sz = offsetof(Mpi2IOUnitPage3_t, GPIOVal) + (sizeof(u16) * 36); 291942263095SSreekanth Reddy io_unit_pg3 = kzalloc(sz, GFP_KERNEL); 292042263095SSreekanth Reddy if (!io_unit_pg3) { 292142263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed allocating memory " 292242263095SSreekanth Reddy "for iounit_pg3: (%d) bytes\n", ioc->name, __func__, sz); 292342263095SSreekanth Reddy goto out; 292442263095SSreekanth Reddy } 292542263095SSreekanth Reddy 292642263095SSreekanth Reddy if (mpt3sas_config_get_iounit_pg3(ioc, &mpi_reply, io_unit_pg3, sz) != 292742263095SSreekanth Reddy 0) { 292842263095SSreekanth Reddy pr_err(MPT3SAS_FMT 292942263095SSreekanth Reddy "%s: failed reading iounit_pg3\n", ioc->name, 293042263095SSreekanth Reddy __func__); 293142263095SSreekanth Reddy goto out; 293242263095SSreekanth Reddy } 293342263095SSreekanth Reddy 293442263095SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 293542263095SSreekanth Reddy if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 293642263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: iounit_pg3 failed with " 293742263095SSreekanth Reddy "ioc_status(0x%04x)\n", ioc->name, __func__, ioc_status); 293842263095SSreekanth Reddy goto out; 293942263095SSreekanth Reddy } 294042263095SSreekanth Reddy 294142263095SSreekanth Reddy if (io_unit_pg3->GPIOCount < 25) { 294242263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: iounit_pg3->GPIOCount less than " 294342263095SSreekanth Reddy "25 entries, detected (%d) entries\n", ioc->name, __func__, 294442263095SSreekanth Reddy io_unit_pg3->GPIOCount); 294542263095SSreekanth Reddy goto out; 294642263095SSreekanth Reddy } 294742263095SSreekanth Reddy 294842263095SSreekanth Reddy /* BRM status is in bit zero of GPIOVal[24] */ 294942263095SSreekanth Reddy backup_rail_monitor_status = le16_to_cpu(io_unit_pg3->GPIOVal[24]); 295042263095SSreekanth Reddy rc = snprintf(buf, PAGE_SIZE, "%d\n", (backup_rail_monitor_status & 1)); 295142263095SSreekanth Reddy 295242263095SSreekanth Reddy out: 295342263095SSreekanth Reddy kfree(io_unit_pg3); 295408c4d550SSreekanth Reddy mutex_unlock(&ioc->pci_access_mutex); 295542263095SSreekanth Reddy return rc; 295642263095SSreekanth Reddy } 295742263095SSreekanth Reddy static DEVICE_ATTR(BRM_status, S_IRUGO, _ctl_BRM_status_show, NULL); 295842263095SSreekanth Reddy 2959f92363d1SSreekanth Reddy struct DIAG_BUFFER_START { 2960f92363d1SSreekanth Reddy __le32 Size; 2961f92363d1SSreekanth Reddy __le32 DiagVersion; 2962f92363d1SSreekanth Reddy u8 BufferType; 2963f92363d1SSreekanth Reddy u8 Reserved[3]; 2964f92363d1SSreekanth Reddy __le32 Reserved1; 2965f92363d1SSreekanth Reddy __le32 Reserved2; 2966f92363d1SSreekanth Reddy __le32 Reserved3; 2967f92363d1SSreekanth Reddy }; 2968f92363d1SSreekanth Reddy 2969f92363d1SSreekanth Reddy /** 2970f92363d1SSreekanth Reddy * _ctl_host_trace_buffer_size_show - host buffer size (trace only) 2971f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2972f92363d1SSreekanth Reddy * @buf - the buffer returned 2973f92363d1SSreekanth Reddy * 2974f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2975f92363d1SSreekanth Reddy */ 2976f92363d1SSreekanth Reddy static ssize_t 2977f92363d1SSreekanth Reddy _ctl_host_trace_buffer_size_show(struct device *cdev, 2978f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 2979f92363d1SSreekanth Reddy { 2980f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2981f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2982f92363d1SSreekanth Reddy u32 size = 0; 2983f92363d1SSreekanth Reddy struct DIAG_BUFFER_START *request_data; 2984f92363d1SSreekanth Reddy 2985f92363d1SSreekanth Reddy if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 2986f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2987f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 2988f92363d1SSreekanth Reddy ioc->name, __func__); 2989f92363d1SSreekanth Reddy return 0; 2990f92363d1SSreekanth Reddy } 2991f92363d1SSreekanth Reddy 2992f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2993f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 2994f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2995f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 2996f92363d1SSreekanth Reddy ioc->name, __func__); 2997f92363d1SSreekanth Reddy return 0; 2998f92363d1SSreekanth Reddy } 2999f92363d1SSreekanth Reddy 3000f92363d1SSreekanth Reddy request_data = (struct DIAG_BUFFER_START *) 3001f92363d1SSreekanth Reddy ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]; 3002f92363d1SSreekanth Reddy if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 || 3003f92363d1SSreekanth Reddy le32_to_cpu(request_data->DiagVersion) == 0x01000000 || 3004f92363d1SSreekanth Reddy le32_to_cpu(request_data->DiagVersion) == 0x01010000) && 3005f92363d1SSreekanth Reddy le32_to_cpu(request_data->Reserved3) == 0x4742444c) 3006f92363d1SSreekanth Reddy size = le32_to_cpu(request_data->Size); 3007f92363d1SSreekanth Reddy 3008f92363d1SSreekanth Reddy ioc->ring_buffer_sz = size; 3009f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", size); 3010f92363d1SSreekanth Reddy } 3011f92363d1SSreekanth Reddy static DEVICE_ATTR(host_trace_buffer_size, S_IRUGO, 3012f92363d1SSreekanth Reddy _ctl_host_trace_buffer_size_show, NULL); 3013f92363d1SSreekanth Reddy 3014f92363d1SSreekanth Reddy /** 3015f92363d1SSreekanth Reddy * _ctl_host_trace_buffer_show - firmware ring buffer (trace only) 3016f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3017f92363d1SSreekanth Reddy * @buf - the buffer returned 3018f92363d1SSreekanth Reddy * 3019f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3020f92363d1SSreekanth Reddy * 3021f92363d1SSreekanth Reddy * You will only be able to read 4k bytes of ring buffer at a time. 3022f92363d1SSreekanth Reddy * In order to read beyond 4k bytes, you will have to write out the 3023f92363d1SSreekanth Reddy * offset to the same attribute, it will move the pointer. 3024f92363d1SSreekanth Reddy */ 3025f92363d1SSreekanth Reddy static ssize_t 3026f92363d1SSreekanth Reddy _ctl_host_trace_buffer_show(struct device *cdev, struct device_attribute *attr, 3027f92363d1SSreekanth Reddy char *buf) 3028f92363d1SSreekanth Reddy { 3029f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3030f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3031f92363d1SSreekanth Reddy void *request_data; 3032f92363d1SSreekanth Reddy u32 size; 3033f92363d1SSreekanth Reddy 3034f92363d1SSreekanth Reddy if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 3035f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 3036f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 3037f92363d1SSreekanth Reddy ioc->name, __func__); 3038f92363d1SSreekanth Reddy return 0; 3039f92363d1SSreekanth Reddy } 3040f92363d1SSreekanth Reddy 3041f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3042f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 3043f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 3044f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 3045f92363d1SSreekanth Reddy ioc->name, __func__); 3046f92363d1SSreekanth Reddy return 0; 3047f92363d1SSreekanth Reddy } 3048f92363d1SSreekanth Reddy 3049f92363d1SSreekanth Reddy if (ioc->ring_buffer_offset > ioc->ring_buffer_sz) 3050f92363d1SSreekanth Reddy return 0; 3051f92363d1SSreekanth Reddy 3052f92363d1SSreekanth Reddy size = ioc->ring_buffer_sz - ioc->ring_buffer_offset; 3053f92363d1SSreekanth Reddy size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size; 3054f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset; 3055f92363d1SSreekanth Reddy memcpy(buf, request_data, size); 3056f92363d1SSreekanth Reddy return size; 3057f92363d1SSreekanth Reddy } 3058f92363d1SSreekanth Reddy 3059f92363d1SSreekanth Reddy static ssize_t 3060f92363d1SSreekanth Reddy _ctl_host_trace_buffer_store(struct device *cdev, struct device_attribute *attr, 3061f92363d1SSreekanth Reddy const char *buf, size_t count) 3062f92363d1SSreekanth Reddy { 3063f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3064f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3065f92363d1SSreekanth Reddy int val = 0; 3066f92363d1SSreekanth Reddy 3067f92363d1SSreekanth Reddy if (sscanf(buf, "%d", &val) != 1) 3068f92363d1SSreekanth Reddy return -EINVAL; 3069f92363d1SSreekanth Reddy 3070f92363d1SSreekanth Reddy ioc->ring_buffer_offset = val; 3071f92363d1SSreekanth Reddy return strlen(buf); 3072f92363d1SSreekanth Reddy } 3073f92363d1SSreekanth Reddy static DEVICE_ATTR(host_trace_buffer, S_IRUGO | S_IWUSR, 3074f92363d1SSreekanth Reddy _ctl_host_trace_buffer_show, _ctl_host_trace_buffer_store); 3075f92363d1SSreekanth Reddy 3076f92363d1SSreekanth Reddy 3077f92363d1SSreekanth Reddy /*****************************************/ 3078f92363d1SSreekanth Reddy 3079f92363d1SSreekanth Reddy /** 3080f92363d1SSreekanth Reddy * _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only) 3081f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3082f92363d1SSreekanth Reddy * @buf - the buffer returned 3083f92363d1SSreekanth Reddy * 3084f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3085f92363d1SSreekanth Reddy * 3086f92363d1SSreekanth Reddy * This is a mechnism to post/release host_trace_buffers 3087f92363d1SSreekanth Reddy */ 3088f92363d1SSreekanth Reddy static ssize_t 3089f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_show(struct device *cdev, 3090f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3091f92363d1SSreekanth Reddy { 3092f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3093f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3094f92363d1SSreekanth Reddy 3095f92363d1SSreekanth Reddy if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) || 3096f92363d1SSreekanth Reddy ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3097f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0)) 3098f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "off\n"); 3099f92363d1SSreekanth Reddy else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3100f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 3101f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "release\n"); 3102f92363d1SSreekanth Reddy else 3103f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "post\n"); 3104f92363d1SSreekanth Reddy } 3105f92363d1SSreekanth Reddy 3106f92363d1SSreekanth Reddy static ssize_t 3107f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_store(struct device *cdev, 3108f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3109f92363d1SSreekanth Reddy { 3110f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3111f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3112f92363d1SSreekanth Reddy char str[10] = ""; 3113f92363d1SSreekanth Reddy struct mpt3_diag_register diag_register; 3114f92363d1SSreekanth Reddy u8 issue_reset = 0; 3115f92363d1SSreekanth Reddy 3116f92363d1SSreekanth Reddy /* don't allow post/release occurr while recovery is active */ 3117f92363d1SSreekanth Reddy if (ioc->shost_recovery || ioc->remove_host || 3118f92363d1SSreekanth Reddy ioc->pci_error_recovery || ioc->is_driver_loading) 3119f92363d1SSreekanth Reddy return -EBUSY; 3120f92363d1SSreekanth Reddy 3121f92363d1SSreekanth Reddy if (sscanf(buf, "%9s", str) != 1) 3122f92363d1SSreekanth Reddy return -EINVAL; 3123f92363d1SSreekanth Reddy 3124f92363d1SSreekanth Reddy if (!strcmp(str, "post")) { 3125f92363d1SSreekanth Reddy /* exit out if host buffers are already posted */ 3126f92363d1SSreekanth Reddy if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) && 3127f92363d1SSreekanth Reddy (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3128f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) && 3129f92363d1SSreekanth Reddy ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3130f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) == 0)) 3131f92363d1SSreekanth Reddy goto out; 3132f92363d1SSreekanth Reddy memset(&diag_register, 0, sizeof(struct mpt3_diag_register)); 3133f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "posting host trace buffers\n", 3134f92363d1SSreekanth Reddy ioc->name); 3135f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 3136f92363d1SSreekanth Reddy diag_register.requested_buffer_size = (1024 * 1024); 3137f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075900; 3138f92363d1SSreekanth Reddy ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0; 3139f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 3140f92363d1SSreekanth Reddy } else if (!strcmp(str, "release")) { 3141f92363d1SSreekanth Reddy /* exit out if host buffers are already released */ 3142f92363d1SSreekanth Reddy if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) 3143f92363d1SSreekanth Reddy goto out; 3144f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3145f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) 3146f92363d1SSreekanth Reddy goto out; 3147f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 3148f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 3149f92363d1SSreekanth Reddy goto out; 3150f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "releasing host trace buffer\n", 3151f92363d1SSreekanth Reddy ioc->name); 3152f92363d1SSreekanth Reddy mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, 3153f92363d1SSreekanth Reddy &issue_reset); 3154f92363d1SSreekanth Reddy } 3155f92363d1SSreekanth Reddy 3156f92363d1SSreekanth Reddy out: 3157f92363d1SSreekanth Reddy return strlen(buf); 3158f92363d1SSreekanth Reddy } 3159f92363d1SSreekanth Reddy static DEVICE_ATTR(host_trace_buffer_enable, S_IRUGO | S_IWUSR, 3160f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_show, 3161f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_store); 3162f92363d1SSreekanth Reddy 3163f92363d1SSreekanth Reddy /*********** diagnostic trigger suppport *********************************/ 3164f92363d1SSreekanth Reddy 3165f92363d1SSreekanth Reddy /** 3166f92363d1SSreekanth Reddy * _ctl_diag_trigger_master_show - show the diag_trigger_master attribute 3167f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3168f92363d1SSreekanth Reddy * @buf - the buffer returned 3169f92363d1SSreekanth Reddy * 3170f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3171f92363d1SSreekanth Reddy */ 3172f92363d1SSreekanth Reddy static ssize_t 3173f92363d1SSreekanth Reddy _ctl_diag_trigger_master_show(struct device *cdev, 3174f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3175f92363d1SSreekanth Reddy 3176f92363d1SSreekanth Reddy { 3177f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3178f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3179f92363d1SSreekanth Reddy unsigned long flags; 3180f92363d1SSreekanth Reddy ssize_t rc; 3181f92363d1SSreekanth Reddy 3182f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3183f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_MASTER_TRIGGER_T); 3184f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_master, rc); 3185f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3186f92363d1SSreekanth Reddy return rc; 3187f92363d1SSreekanth Reddy } 3188f92363d1SSreekanth Reddy 3189f92363d1SSreekanth Reddy /** 3190f92363d1SSreekanth Reddy * _ctl_diag_trigger_master_store - store the diag_trigger_master attribute 3191f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3192f92363d1SSreekanth Reddy * @buf - the buffer returned 3193f92363d1SSreekanth Reddy * 3194f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3195f92363d1SSreekanth Reddy */ 3196f92363d1SSreekanth Reddy static ssize_t 3197f92363d1SSreekanth Reddy _ctl_diag_trigger_master_store(struct device *cdev, 3198f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3199f92363d1SSreekanth Reddy 3200f92363d1SSreekanth Reddy { 3201f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3202f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3203f92363d1SSreekanth Reddy unsigned long flags; 3204f92363d1SSreekanth Reddy ssize_t rc; 3205f92363d1SSreekanth Reddy 3206f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3207f92363d1SSreekanth Reddy rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count); 3208f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_master, 0, 3209f92363d1SSreekanth Reddy sizeof(struct SL_WH_MASTER_TRIGGER_T)); 3210f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_master, buf, rc); 3211f92363d1SSreekanth Reddy ioc->diag_trigger_master.MasterData |= 3212f92363d1SSreekanth Reddy (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET); 3213f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3214f92363d1SSreekanth Reddy return rc; 3215f92363d1SSreekanth Reddy } 3216f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_master, S_IRUGO | S_IWUSR, 3217f92363d1SSreekanth Reddy _ctl_diag_trigger_master_show, _ctl_diag_trigger_master_store); 3218f92363d1SSreekanth Reddy 3219f92363d1SSreekanth Reddy 3220f92363d1SSreekanth Reddy /** 3221f92363d1SSreekanth Reddy * _ctl_diag_trigger_event_show - show the diag_trigger_event attribute 3222f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3223f92363d1SSreekanth Reddy * @buf - the buffer returned 3224f92363d1SSreekanth Reddy * 3225f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3226f92363d1SSreekanth Reddy */ 3227f92363d1SSreekanth Reddy static ssize_t 3228f92363d1SSreekanth Reddy _ctl_diag_trigger_event_show(struct device *cdev, 3229f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3230f92363d1SSreekanth Reddy { 3231f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3232f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3233f92363d1SSreekanth Reddy unsigned long flags; 3234f92363d1SSreekanth Reddy ssize_t rc; 3235f92363d1SSreekanth Reddy 3236f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3237f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_EVENT_TRIGGERS_T); 3238f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_event, rc); 3239f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3240f92363d1SSreekanth Reddy return rc; 3241f92363d1SSreekanth Reddy } 3242f92363d1SSreekanth Reddy 3243f92363d1SSreekanth Reddy /** 3244f92363d1SSreekanth Reddy * _ctl_diag_trigger_event_store - store the diag_trigger_event attribute 3245f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3246f92363d1SSreekanth Reddy * @buf - the buffer returned 3247f92363d1SSreekanth Reddy * 3248f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3249f92363d1SSreekanth Reddy */ 3250f92363d1SSreekanth Reddy static ssize_t 3251f92363d1SSreekanth Reddy _ctl_diag_trigger_event_store(struct device *cdev, 3252f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3253f92363d1SSreekanth Reddy 3254f92363d1SSreekanth Reddy { 3255f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3256f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3257f92363d1SSreekanth Reddy unsigned long flags; 3258f92363d1SSreekanth Reddy ssize_t sz; 3259f92363d1SSreekanth Reddy 3260f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3261f92363d1SSreekanth Reddy sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count); 3262f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_event, 0, 3263f92363d1SSreekanth Reddy sizeof(struct SL_WH_EVENT_TRIGGERS_T)); 3264f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_event, buf, sz); 3265f92363d1SSreekanth Reddy if (ioc->diag_trigger_event.ValidEntries > NUM_VALID_ENTRIES) 3266f92363d1SSreekanth Reddy ioc->diag_trigger_event.ValidEntries = NUM_VALID_ENTRIES; 3267f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3268f92363d1SSreekanth Reddy return sz; 3269f92363d1SSreekanth Reddy } 3270f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_event, S_IRUGO | S_IWUSR, 3271f92363d1SSreekanth Reddy _ctl_diag_trigger_event_show, _ctl_diag_trigger_event_store); 3272f92363d1SSreekanth Reddy 3273f92363d1SSreekanth Reddy 3274f92363d1SSreekanth Reddy /** 3275f92363d1SSreekanth Reddy * _ctl_diag_trigger_scsi_show - show the diag_trigger_scsi attribute 3276f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3277f92363d1SSreekanth Reddy * @buf - the buffer returned 3278f92363d1SSreekanth Reddy * 3279f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3280f92363d1SSreekanth Reddy */ 3281f92363d1SSreekanth Reddy static ssize_t 3282f92363d1SSreekanth Reddy _ctl_diag_trigger_scsi_show(struct device *cdev, 3283f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3284f92363d1SSreekanth Reddy { 3285f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3286f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3287f92363d1SSreekanth Reddy unsigned long flags; 3288f92363d1SSreekanth Reddy ssize_t rc; 3289f92363d1SSreekanth Reddy 3290f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3291f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_SCSI_TRIGGERS_T); 3292f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_scsi, rc); 3293f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3294f92363d1SSreekanth Reddy return rc; 3295f92363d1SSreekanth Reddy } 3296f92363d1SSreekanth Reddy 3297f92363d1SSreekanth Reddy /** 3298f92363d1SSreekanth Reddy * _ctl_diag_trigger_scsi_store - store the diag_trigger_scsi attribute 3299f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3300f92363d1SSreekanth Reddy * @buf - the buffer returned 3301f92363d1SSreekanth Reddy * 3302f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3303f92363d1SSreekanth Reddy */ 3304f92363d1SSreekanth Reddy static ssize_t 3305f92363d1SSreekanth Reddy _ctl_diag_trigger_scsi_store(struct device *cdev, 3306f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3307f92363d1SSreekanth Reddy { 3308f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3309f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3310f92363d1SSreekanth Reddy unsigned long flags; 3311f92363d1SSreekanth Reddy ssize_t sz; 3312f92363d1SSreekanth Reddy 3313f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3314f92363d1SSreekanth Reddy sz = min(sizeof(struct SL_WH_SCSI_TRIGGERS_T), count); 3315f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_scsi, 0, 3316f92363d1SSreekanth Reddy sizeof(struct SL_WH_EVENT_TRIGGERS_T)); 3317f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_scsi, buf, sz); 3318f92363d1SSreekanth Reddy if (ioc->diag_trigger_scsi.ValidEntries > NUM_VALID_ENTRIES) 3319f92363d1SSreekanth Reddy ioc->diag_trigger_scsi.ValidEntries = NUM_VALID_ENTRIES; 3320f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3321f92363d1SSreekanth Reddy return sz; 3322f92363d1SSreekanth Reddy } 3323f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_scsi, S_IRUGO | S_IWUSR, 3324f92363d1SSreekanth Reddy _ctl_diag_trigger_scsi_show, _ctl_diag_trigger_scsi_store); 3325f92363d1SSreekanth Reddy 3326f92363d1SSreekanth Reddy 3327f92363d1SSreekanth Reddy /** 3328f92363d1SSreekanth Reddy * _ctl_diag_trigger_scsi_show - show the diag_trigger_mpi attribute 3329f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3330f92363d1SSreekanth Reddy * @buf - the buffer returned 3331f92363d1SSreekanth Reddy * 3332f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3333f92363d1SSreekanth Reddy */ 3334f92363d1SSreekanth Reddy static ssize_t 3335f92363d1SSreekanth Reddy _ctl_diag_trigger_mpi_show(struct device *cdev, 3336f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3337f92363d1SSreekanth Reddy { 3338f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3339f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3340f92363d1SSreekanth Reddy unsigned long flags; 3341f92363d1SSreekanth Reddy ssize_t rc; 3342f92363d1SSreekanth Reddy 3343f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3344f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_MPI_TRIGGERS_T); 3345f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_mpi, rc); 3346f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3347f92363d1SSreekanth Reddy return rc; 3348f92363d1SSreekanth Reddy } 3349f92363d1SSreekanth Reddy 3350f92363d1SSreekanth Reddy /** 3351f92363d1SSreekanth Reddy * _ctl_diag_trigger_mpi_store - store the diag_trigger_mpi attribute 3352f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3353f92363d1SSreekanth Reddy * @buf - the buffer returned 3354f92363d1SSreekanth Reddy * 3355f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3356f92363d1SSreekanth Reddy */ 3357f92363d1SSreekanth Reddy static ssize_t 3358f92363d1SSreekanth Reddy _ctl_diag_trigger_mpi_store(struct device *cdev, 3359f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3360f92363d1SSreekanth Reddy { 3361f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3362f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3363f92363d1SSreekanth Reddy unsigned long flags; 3364f92363d1SSreekanth Reddy ssize_t sz; 3365f92363d1SSreekanth Reddy 3366f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3367f92363d1SSreekanth Reddy sz = min(sizeof(struct SL_WH_MPI_TRIGGERS_T), count); 3368f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_mpi, 0, 336966331e8cSDan Carpenter sizeof(ioc->diag_trigger_mpi)); 3370f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_mpi, buf, sz); 3371f92363d1SSreekanth Reddy if (ioc->diag_trigger_mpi.ValidEntries > NUM_VALID_ENTRIES) 3372f92363d1SSreekanth Reddy ioc->diag_trigger_mpi.ValidEntries = NUM_VALID_ENTRIES; 3373f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3374f92363d1SSreekanth Reddy return sz; 3375f92363d1SSreekanth Reddy } 3376f92363d1SSreekanth Reddy 3377f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_mpi, S_IRUGO | S_IWUSR, 3378f92363d1SSreekanth Reddy _ctl_diag_trigger_mpi_show, _ctl_diag_trigger_mpi_store); 3379f92363d1SSreekanth Reddy 3380f92363d1SSreekanth Reddy /*********** diagnostic trigger suppport *** END ****************************/ 3381f92363d1SSreekanth Reddy 3382f92363d1SSreekanth Reddy /*****************************************/ 3383f92363d1SSreekanth Reddy 3384f92363d1SSreekanth Reddy struct device_attribute *mpt3sas_host_attrs[] = { 3385f92363d1SSreekanth Reddy &dev_attr_version_fw, 3386f92363d1SSreekanth Reddy &dev_attr_version_bios, 3387f92363d1SSreekanth Reddy &dev_attr_version_mpi, 3388f92363d1SSreekanth Reddy &dev_attr_version_product, 3389f92363d1SSreekanth Reddy &dev_attr_version_nvdata_persistent, 3390f92363d1SSreekanth Reddy &dev_attr_version_nvdata_default, 3391f92363d1SSreekanth Reddy &dev_attr_board_name, 3392f92363d1SSreekanth Reddy &dev_attr_board_assembly, 3393f92363d1SSreekanth Reddy &dev_attr_board_tracer, 3394f92363d1SSreekanth Reddy &dev_attr_io_delay, 3395f92363d1SSreekanth Reddy &dev_attr_device_delay, 3396f92363d1SSreekanth Reddy &dev_attr_logging_level, 3397f92363d1SSreekanth Reddy &dev_attr_fwfault_debug, 3398f92363d1SSreekanth Reddy &dev_attr_fw_queue_depth, 3399f92363d1SSreekanth Reddy &dev_attr_host_sas_address, 3400f92363d1SSreekanth Reddy &dev_attr_ioc_reset_count, 3401f92363d1SSreekanth Reddy &dev_attr_host_trace_buffer_size, 3402f92363d1SSreekanth Reddy &dev_attr_host_trace_buffer, 3403f92363d1SSreekanth Reddy &dev_attr_host_trace_buffer_enable, 3404f92363d1SSreekanth Reddy &dev_attr_reply_queue_count, 3405f92363d1SSreekanth Reddy &dev_attr_diag_trigger_master, 3406f92363d1SSreekanth Reddy &dev_attr_diag_trigger_event, 3407f92363d1SSreekanth Reddy &dev_attr_diag_trigger_scsi, 3408f92363d1SSreekanth Reddy &dev_attr_diag_trigger_mpi, 340942263095SSreekanth Reddy &dev_attr_BRM_status, 3410f92363d1SSreekanth Reddy NULL, 3411f92363d1SSreekanth Reddy }; 3412f92363d1SSreekanth Reddy 3413f92363d1SSreekanth Reddy /* device attributes */ 3414f92363d1SSreekanth Reddy 3415f92363d1SSreekanth Reddy /** 3416f92363d1SSreekanth Reddy * _ctl_device_sas_address_show - sas address 3417f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3418f92363d1SSreekanth Reddy * @buf - the buffer returned 3419f92363d1SSreekanth Reddy * 3420f92363d1SSreekanth Reddy * This is the sas address for the target 3421f92363d1SSreekanth Reddy * 3422f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 3423f92363d1SSreekanth Reddy */ 3424f92363d1SSreekanth Reddy static ssize_t 3425f92363d1SSreekanth Reddy _ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr, 3426f92363d1SSreekanth Reddy char *buf) 3427f92363d1SSreekanth Reddy { 3428f92363d1SSreekanth Reddy struct scsi_device *sdev = to_scsi_device(dev); 3429f92363d1SSreekanth Reddy struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3430f92363d1SSreekanth Reddy 3431f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 3432f92363d1SSreekanth Reddy (unsigned long long)sas_device_priv_data->sas_target->sas_address); 3433f92363d1SSreekanth Reddy } 3434f92363d1SSreekanth Reddy static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL); 3435f92363d1SSreekanth Reddy 3436f92363d1SSreekanth Reddy /** 3437f92363d1SSreekanth Reddy * _ctl_device_handle_show - device handle 3438f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3439f92363d1SSreekanth Reddy * @buf - the buffer returned 3440f92363d1SSreekanth Reddy * 3441f92363d1SSreekanth Reddy * This is the firmware assigned device handle 3442f92363d1SSreekanth Reddy * 3443f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 3444f92363d1SSreekanth Reddy */ 3445f92363d1SSreekanth Reddy static ssize_t 3446f92363d1SSreekanth Reddy _ctl_device_handle_show(struct device *dev, struct device_attribute *attr, 3447f92363d1SSreekanth Reddy char *buf) 3448f92363d1SSreekanth Reddy { 3449f92363d1SSreekanth Reddy struct scsi_device *sdev = to_scsi_device(dev); 3450f92363d1SSreekanth Reddy struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3451f92363d1SSreekanth Reddy 3452f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "0x%04x\n", 3453f92363d1SSreekanth Reddy sas_device_priv_data->sas_target->handle); 3454f92363d1SSreekanth Reddy } 3455f92363d1SSreekanth Reddy static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL); 3456f92363d1SSreekanth Reddy 3457307d9075SAdam Manzanares /** 3458307d9075SAdam Manzanares * _ctl_device_ncq_io_prio_show - send prioritized io commands to device 3459307d9075SAdam Manzanares * @dev - pointer to embedded device 3460307d9075SAdam Manzanares * @buf - the buffer returned 3461307d9075SAdam Manzanares * 3462307d9075SAdam Manzanares * A sysfs 'read/write' sdev attribute, only works with SATA 3463307d9075SAdam Manzanares */ 3464307d9075SAdam Manzanares static ssize_t 3465307d9075SAdam Manzanares _ctl_device_ncq_prio_enable_show(struct device *dev, 3466307d9075SAdam Manzanares struct device_attribute *attr, char *buf) 3467307d9075SAdam Manzanares { 3468307d9075SAdam Manzanares struct scsi_device *sdev = to_scsi_device(dev); 3469307d9075SAdam Manzanares struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3470307d9075SAdam Manzanares 3471307d9075SAdam Manzanares return snprintf(buf, PAGE_SIZE, "%d\n", 3472307d9075SAdam Manzanares sas_device_priv_data->ncq_prio_enable); 3473307d9075SAdam Manzanares } 3474307d9075SAdam Manzanares 3475307d9075SAdam Manzanares static ssize_t 3476307d9075SAdam Manzanares _ctl_device_ncq_prio_enable_store(struct device *dev, 3477307d9075SAdam Manzanares struct device_attribute *attr, 3478307d9075SAdam Manzanares const char *buf, size_t count) 3479307d9075SAdam Manzanares { 3480307d9075SAdam Manzanares struct scsi_device *sdev = to_scsi_device(dev); 3481307d9075SAdam Manzanares struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3482307d9075SAdam Manzanares bool ncq_prio_enable = 0; 3483307d9075SAdam Manzanares 3484307d9075SAdam Manzanares if (kstrtobool(buf, &ncq_prio_enable)) 3485307d9075SAdam Manzanares return -EINVAL; 3486307d9075SAdam Manzanares 3487307d9075SAdam Manzanares if (!scsih_ncq_prio_supp(sdev)) 3488307d9075SAdam Manzanares return -EINVAL; 3489307d9075SAdam Manzanares 3490307d9075SAdam Manzanares sas_device_priv_data->ncq_prio_enable = ncq_prio_enable; 3491307d9075SAdam Manzanares return strlen(buf); 3492307d9075SAdam Manzanares } 3493307d9075SAdam Manzanares static DEVICE_ATTR(sas_ncq_prio_enable, S_IRUGO | S_IWUSR, 3494307d9075SAdam Manzanares _ctl_device_ncq_prio_enable_show, 3495307d9075SAdam Manzanares _ctl_device_ncq_prio_enable_store); 3496307d9075SAdam Manzanares 3497f92363d1SSreekanth Reddy struct device_attribute *mpt3sas_dev_attrs[] = { 3498f92363d1SSreekanth Reddy &dev_attr_sas_address, 3499f92363d1SSreekanth Reddy &dev_attr_sas_device_handle, 3500307d9075SAdam Manzanares &dev_attr_sas_ncq_prio_enable, 3501f92363d1SSreekanth Reddy NULL, 3502f92363d1SSreekanth Reddy }; 3503f92363d1SSreekanth Reddy 3504c84b06a4SSreekanth Reddy /* file operations table for mpt3ctl device */ 3505c84b06a4SSreekanth Reddy static const struct file_operations ctl_fops = { 3506c84b06a4SSreekanth Reddy .owner = THIS_MODULE, 3507c84b06a4SSreekanth Reddy .unlocked_ioctl = _ctl_ioctl, 3508c84b06a4SSreekanth Reddy .poll = _ctl_poll, 3509c84b06a4SSreekanth Reddy .fasync = _ctl_fasync, 3510c84b06a4SSreekanth Reddy #ifdef CONFIG_COMPAT 3511c84b06a4SSreekanth Reddy .compat_ioctl = _ctl_ioctl_compat, 3512c84b06a4SSreekanth Reddy #endif 3513c84b06a4SSreekanth Reddy }; 3514c84b06a4SSreekanth Reddy 3515c84b06a4SSreekanth Reddy /* file operations table for mpt2ctl device */ 3516c84b06a4SSreekanth Reddy static const struct file_operations ctl_gen2_fops = { 3517c84b06a4SSreekanth Reddy .owner = THIS_MODULE, 3518c84b06a4SSreekanth Reddy .unlocked_ioctl = _ctl_mpt2_ioctl, 3519c84b06a4SSreekanth Reddy .poll = _ctl_poll, 3520c84b06a4SSreekanth Reddy .fasync = _ctl_fasync, 3521c84b06a4SSreekanth Reddy #ifdef CONFIG_COMPAT 3522c84b06a4SSreekanth Reddy .compat_ioctl = _ctl_mpt2_ioctl_compat, 3523c84b06a4SSreekanth Reddy #endif 3524c84b06a4SSreekanth Reddy }; 3525c84b06a4SSreekanth Reddy 3526c84b06a4SSreekanth Reddy static struct miscdevice ctl_dev = { 3527c84b06a4SSreekanth Reddy .minor = MPT3SAS_MINOR, 3528c84b06a4SSreekanth Reddy .name = MPT3SAS_DEV_NAME, 3529c84b06a4SSreekanth Reddy .fops = &ctl_fops, 3530c84b06a4SSreekanth Reddy }; 3531c84b06a4SSreekanth Reddy 3532c84b06a4SSreekanth Reddy static struct miscdevice gen2_ctl_dev = { 3533c84b06a4SSreekanth Reddy .minor = MPT2SAS_MINOR, 3534c84b06a4SSreekanth Reddy .name = MPT2SAS_DEV_NAME, 3535c84b06a4SSreekanth Reddy .fops = &ctl_gen2_fops, 3536c84b06a4SSreekanth Reddy }; 3537c84b06a4SSreekanth Reddy 3538f92363d1SSreekanth Reddy /** 3539c84b06a4SSreekanth Reddy * mpt3sas_ctl_init - main entry point for ctl. 3540f92363d1SSreekanth Reddy * 3541f92363d1SSreekanth Reddy */ 3542f92363d1SSreekanth Reddy void 3543c84b06a4SSreekanth Reddy mpt3sas_ctl_init(ushort hbas_to_enumerate) 3544f92363d1SSreekanth Reddy { 3545f92363d1SSreekanth Reddy async_queue = NULL; 3546c84b06a4SSreekanth Reddy 3547c84b06a4SSreekanth Reddy /* Don't register mpt3ctl ioctl device if 3548c84b06a4SSreekanth Reddy * hbas_to_enumarate is one. 3549c84b06a4SSreekanth Reddy */ 3550c84b06a4SSreekanth Reddy if (hbas_to_enumerate != 1) 3551c84b06a4SSreekanth Reddy if (misc_register(&ctl_dev) < 0) 3552c84b06a4SSreekanth Reddy pr_err("%s can't register misc device [minor=%d]\n", 3553c84b06a4SSreekanth Reddy MPT3SAS_DRIVER_NAME, MPT3SAS_MINOR); 3554c84b06a4SSreekanth Reddy 3555c84b06a4SSreekanth Reddy /* Don't register mpt3ctl ioctl device if 3556c84b06a4SSreekanth Reddy * hbas_to_enumarate is two. 3557c84b06a4SSreekanth Reddy */ 3558c84b06a4SSreekanth Reddy if (hbas_to_enumerate != 2) 3559c84b06a4SSreekanth Reddy if (misc_register(&gen2_ctl_dev) < 0) 3560c84b06a4SSreekanth Reddy pr_err("%s can't register misc device [minor=%d]\n", 3561c84b06a4SSreekanth Reddy MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR); 3562c84b06a4SSreekanth Reddy 3563f92363d1SSreekanth Reddy init_waitqueue_head(&ctl_poll_wait); 3564f92363d1SSreekanth Reddy } 3565f92363d1SSreekanth Reddy 3566f92363d1SSreekanth Reddy /** 3567c84b06a4SSreekanth Reddy * mpt3sas_ctl_exit - exit point for ctl 3568f92363d1SSreekanth Reddy * 3569f92363d1SSreekanth Reddy */ 3570f92363d1SSreekanth Reddy void 3571c84b06a4SSreekanth Reddy mpt3sas_ctl_exit(ushort hbas_to_enumerate) 3572f92363d1SSreekanth Reddy { 3573f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 3574f92363d1SSreekanth Reddy int i; 3575f92363d1SSreekanth Reddy 3576f92363d1SSreekanth Reddy list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 3577f92363d1SSreekanth Reddy 3578f92363d1SSreekanth Reddy /* free memory associated to diag buffers */ 3579f92363d1SSreekanth Reddy for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 3580f92363d1SSreekanth Reddy if (!ioc->diag_buffer[i]) 3581f92363d1SSreekanth Reddy continue; 3582f92363d1SSreekanth Reddy if (!(ioc->diag_buffer_status[i] & 3583f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED)) 3584f92363d1SSreekanth Reddy continue; 3585f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[i] & 3586f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 3587f92363d1SSreekanth Reddy continue; 3588f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i], 3589f92363d1SSreekanth Reddy ioc->diag_buffer[i], ioc->diag_buffer_dma[i]); 3590f92363d1SSreekanth Reddy ioc->diag_buffer[i] = NULL; 3591f92363d1SSreekanth Reddy ioc->diag_buffer_status[i] = 0; 3592f92363d1SSreekanth Reddy } 3593f92363d1SSreekanth Reddy 3594f92363d1SSreekanth Reddy kfree(ioc->event_log); 3595f92363d1SSreekanth Reddy } 3596c84b06a4SSreekanth Reddy if (hbas_to_enumerate != 1) 3597c84b06a4SSreekanth Reddy misc_deregister(&ctl_dev); 3598c84b06a4SSreekanth Reddy if (hbas_to_enumerate != 2) 3599c84b06a4SSreekanth Reddy misc_deregister(&gen2_ctl_dev); 3600f92363d1SSreekanth Reddy } 3601