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; 275f92363d1SSreekanth Reddy const void *sense_data; 276f92363d1SSreekanth Reddy u32 sz; 277f92363d1SSreekanth Reddy 278f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status == MPT3_CMD_NOT_USED) 279f92363d1SSreekanth Reddy return 1; 280f92363d1SSreekanth Reddy if (ioc->ctl_cmds.smid != smid) 281f92363d1SSreekanth Reddy return 1; 282f92363d1SSreekanth Reddy ioc->ctl_cmds.status |= MPT3_CMD_COMPLETE; 283f92363d1SSreekanth Reddy mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 284f92363d1SSreekanth Reddy if (mpi_reply) { 285f92363d1SSreekanth Reddy memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4); 286f92363d1SSreekanth Reddy ioc->ctl_cmds.status |= MPT3_CMD_REPLY_VALID; 287f92363d1SSreekanth Reddy /* get sense data */ 288f92363d1SSreekanth Reddy if (mpi_reply->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 289f92363d1SSreekanth Reddy mpi_reply->Function == 290f92363d1SSreekanth Reddy MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 291f92363d1SSreekanth Reddy scsiio_reply = (Mpi2SCSIIOReply_t *)mpi_reply; 292f92363d1SSreekanth Reddy if (scsiio_reply->SCSIState & 293f92363d1SSreekanth Reddy MPI2_SCSI_STATE_AUTOSENSE_VALID) { 294f92363d1SSreekanth Reddy sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, 295f92363d1SSreekanth Reddy le32_to_cpu(scsiio_reply->SenseCount)); 296f92363d1SSreekanth Reddy sense_data = mpt3sas_base_get_sense_buffer(ioc, 297f92363d1SSreekanth Reddy smid); 298f92363d1SSreekanth Reddy memcpy(ioc->ctl_cmds.sense, sense_data, sz); 299f92363d1SSreekanth Reddy } 300f92363d1SSreekanth Reddy } 301f92363d1SSreekanth Reddy } 302f92363d1SSreekanth Reddy _ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply); 303f92363d1SSreekanth Reddy ioc->ctl_cmds.status &= ~MPT3_CMD_PENDING; 304f92363d1SSreekanth Reddy complete(&ioc->ctl_cmds.done); 305f92363d1SSreekanth Reddy return 1; 306f92363d1SSreekanth Reddy } 307f92363d1SSreekanth Reddy 308f92363d1SSreekanth Reddy /** 309f92363d1SSreekanth Reddy * _ctl_check_event_type - determines when an event needs logging 310f92363d1SSreekanth Reddy * @ioc: per adapter object 311f92363d1SSreekanth Reddy * @event: firmware event 312f92363d1SSreekanth Reddy * 313f92363d1SSreekanth Reddy * The bitmask in ioc->event_type[] indicates which events should be 314f92363d1SSreekanth Reddy * be saved in the driver event_log. This bitmask is set by application. 315f92363d1SSreekanth Reddy * 316f92363d1SSreekanth Reddy * Returns 1 when event should be captured, or zero means no match. 317f92363d1SSreekanth Reddy */ 318f92363d1SSreekanth Reddy static int 319f92363d1SSreekanth Reddy _ctl_check_event_type(struct MPT3SAS_ADAPTER *ioc, u16 event) 320f92363d1SSreekanth Reddy { 321f92363d1SSreekanth Reddy u16 i; 322f92363d1SSreekanth Reddy u32 desired_event; 323f92363d1SSreekanth Reddy 324f92363d1SSreekanth Reddy if (event >= 128 || !event || !ioc->event_log) 325f92363d1SSreekanth Reddy return 0; 326f92363d1SSreekanth Reddy 327f92363d1SSreekanth Reddy desired_event = (1 << (event % 32)); 328f92363d1SSreekanth Reddy if (!desired_event) 329f92363d1SSreekanth Reddy desired_event = 1; 330f92363d1SSreekanth Reddy i = event / 32; 331f92363d1SSreekanth Reddy return desired_event & ioc->event_type[i]; 332f92363d1SSreekanth Reddy } 333f92363d1SSreekanth Reddy 334f92363d1SSreekanth Reddy /** 335f92363d1SSreekanth Reddy * mpt3sas_ctl_add_to_event_log - add event 336f92363d1SSreekanth Reddy * @ioc: per adapter object 337f92363d1SSreekanth Reddy * @mpi_reply: reply message frame 338f92363d1SSreekanth Reddy * 339f92363d1SSreekanth Reddy * Return nothing. 340f92363d1SSreekanth Reddy */ 341f92363d1SSreekanth Reddy void 342f92363d1SSreekanth Reddy mpt3sas_ctl_add_to_event_log(struct MPT3SAS_ADAPTER *ioc, 343f92363d1SSreekanth Reddy Mpi2EventNotificationReply_t *mpi_reply) 344f92363d1SSreekanth Reddy { 345f92363d1SSreekanth Reddy struct MPT3_IOCTL_EVENTS *event_log; 346f92363d1SSreekanth Reddy u16 event; 347f92363d1SSreekanth Reddy int i; 348f92363d1SSreekanth Reddy u32 sz, event_data_sz; 349f92363d1SSreekanth Reddy u8 send_aen = 0; 350f92363d1SSreekanth Reddy 351f92363d1SSreekanth Reddy if (!ioc->event_log) 352f92363d1SSreekanth Reddy return; 353f92363d1SSreekanth Reddy 354f92363d1SSreekanth Reddy event = le16_to_cpu(mpi_reply->Event); 355f92363d1SSreekanth Reddy 356f92363d1SSreekanth Reddy if (_ctl_check_event_type(ioc, event)) { 357f92363d1SSreekanth Reddy 358f92363d1SSreekanth Reddy /* insert entry into circular event_log */ 359f92363d1SSreekanth Reddy i = ioc->event_context % MPT3SAS_CTL_EVENT_LOG_SIZE; 360f92363d1SSreekanth Reddy event_log = ioc->event_log; 361f92363d1SSreekanth Reddy event_log[i].event = event; 362f92363d1SSreekanth Reddy event_log[i].context = ioc->event_context++; 363f92363d1SSreekanth Reddy 364f92363d1SSreekanth Reddy event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4; 365f92363d1SSreekanth Reddy sz = min_t(u32, event_data_sz, MPT3_EVENT_DATA_SIZE); 366f92363d1SSreekanth Reddy memset(event_log[i].data, 0, MPT3_EVENT_DATA_SIZE); 367f92363d1SSreekanth Reddy memcpy(event_log[i].data, mpi_reply->EventData, sz); 368f92363d1SSreekanth Reddy send_aen = 1; 369f92363d1SSreekanth Reddy } 370f92363d1SSreekanth Reddy 371f92363d1SSreekanth Reddy /* This aen_event_read_flag flag is set until the 372f92363d1SSreekanth Reddy * application has read the event log. 373f92363d1SSreekanth Reddy * For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify. 374f92363d1SSreekanth Reddy */ 375f92363d1SSreekanth Reddy if (event == MPI2_EVENT_LOG_ENTRY_ADDED || 376f92363d1SSreekanth Reddy (send_aen && !ioc->aen_event_read_flag)) { 377f92363d1SSreekanth Reddy ioc->aen_event_read_flag = 1; 378f92363d1SSreekanth Reddy wake_up_interruptible(&ctl_poll_wait); 379f92363d1SSreekanth Reddy if (async_queue) 380f92363d1SSreekanth Reddy kill_fasync(&async_queue, SIGIO, POLL_IN); 381f92363d1SSreekanth Reddy } 382f92363d1SSreekanth Reddy } 383f92363d1SSreekanth Reddy 384f92363d1SSreekanth Reddy /** 385f92363d1SSreekanth Reddy * mpt3sas_ctl_event_callback - firmware event handler (called at ISR time) 386f92363d1SSreekanth Reddy * @ioc: per adapter object 387f92363d1SSreekanth Reddy * @msix_index: MSIX table index supplied by the OS 388f92363d1SSreekanth Reddy * @reply: reply message frame(lower 32bit addr) 389f92363d1SSreekanth Reddy * Context: interrupt. 390f92363d1SSreekanth Reddy * 391f92363d1SSreekanth Reddy * This function merely adds a new work task into ioc->firmware_event_thread. 392f92363d1SSreekanth Reddy * The tasks are worked from _firmware_event_work in user context. 393f92363d1SSreekanth Reddy * 394f92363d1SSreekanth Reddy * Return 1 meaning mf should be freed from _base_interrupt 395f92363d1SSreekanth Reddy * 0 means the mf is freed from this function. 396f92363d1SSreekanth Reddy */ 397f92363d1SSreekanth Reddy u8 398f92363d1SSreekanth Reddy mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index, 399f92363d1SSreekanth Reddy u32 reply) 400f92363d1SSreekanth Reddy { 401f92363d1SSreekanth Reddy Mpi2EventNotificationReply_t *mpi_reply; 402f92363d1SSreekanth Reddy 403f92363d1SSreekanth Reddy mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 404f92363d1SSreekanth Reddy mpt3sas_ctl_add_to_event_log(ioc, mpi_reply); 405f92363d1SSreekanth Reddy return 1; 406f92363d1SSreekanth Reddy } 407f92363d1SSreekanth Reddy 408f92363d1SSreekanth Reddy /** 409f92363d1SSreekanth Reddy * _ctl_verify_adapter - validates ioc_number passed from application 410f92363d1SSreekanth Reddy * @ioc: per adapter object 411f92363d1SSreekanth Reddy * @iocpp: The ioc pointer is returned in this. 412f92363d1SSreekanth Reddy * 413f92363d1SSreekanth Reddy * Return (-1) means error, else ioc_number. 414f92363d1SSreekanth Reddy */ 415f92363d1SSreekanth Reddy static int 416f92363d1SSreekanth Reddy _ctl_verify_adapter(int ioc_number, struct MPT3SAS_ADAPTER **iocpp) 417f92363d1SSreekanth Reddy { 418f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 419f92363d1SSreekanth Reddy 420f92363d1SSreekanth Reddy list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 421f92363d1SSreekanth Reddy if (ioc->id != ioc_number) 422f92363d1SSreekanth Reddy continue; 423f92363d1SSreekanth Reddy *iocpp = ioc; 424f92363d1SSreekanth Reddy return ioc_number; 425f92363d1SSreekanth Reddy } 426f92363d1SSreekanth Reddy *iocpp = NULL; 427f92363d1SSreekanth Reddy return -1; 428f92363d1SSreekanth Reddy } 429f92363d1SSreekanth Reddy 430f92363d1SSreekanth Reddy /** 431f92363d1SSreekanth Reddy * mpt3sas_ctl_reset_handler - reset callback handler (for ctl) 432f92363d1SSreekanth Reddy * @ioc: per adapter object 433f92363d1SSreekanth Reddy * @reset_phase: phase 434f92363d1SSreekanth Reddy * 435f92363d1SSreekanth Reddy * The handler for doing any required cleanup or initialization. 436f92363d1SSreekanth Reddy * 437f92363d1SSreekanth Reddy * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET, 438f92363d1SSreekanth Reddy * MPT3_IOC_DONE_RESET 439f92363d1SSreekanth Reddy */ 440f92363d1SSreekanth Reddy void 441f92363d1SSreekanth Reddy mpt3sas_ctl_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase) 442f92363d1SSreekanth Reddy { 443f92363d1SSreekanth Reddy int i; 444f92363d1SSreekanth Reddy u8 issue_reset; 445f92363d1SSreekanth Reddy 446f92363d1SSreekanth Reddy switch (reset_phase) { 447f92363d1SSreekanth Reddy case MPT3_IOC_PRE_RESET: 448f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 449f92363d1SSreekanth Reddy "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__)); 450f92363d1SSreekanth Reddy for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 451f92363d1SSreekanth Reddy if (!(ioc->diag_buffer_status[i] & 452f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED)) 453f92363d1SSreekanth Reddy continue; 454f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[i] & 455f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 456f92363d1SSreekanth Reddy continue; 457f92363d1SSreekanth Reddy mpt3sas_send_diag_release(ioc, i, &issue_reset); 458f92363d1SSreekanth Reddy } 459f92363d1SSreekanth Reddy break; 460f92363d1SSreekanth Reddy case MPT3_IOC_AFTER_RESET: 461f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 462f92363d1SSreekanth Reddy "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__)); 463f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status & MPT3_CMD_PENDING) { 464f92363d1SSreekanth Reddy ioc->ctl_cmds.status |= MPT3_CMD_RESET; 465f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, ioc->ctl_cmds.smid); 466f92363d1SSreekanth Reddy complete(&ioc->ctl_cmds.done); 467f92363d1SSreekanth Reddy } 468f92363d1SSreekanth Reddy break; 469f92363d1SSreekanth Reddy case MPT3_IOC_DONE_RESET: 470f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 471f92363d1SSreekanth Reddy "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__)); 472f92363d1SSreekanth Reddy 473f92363d1SSreekanth Reddy for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 474f92363d1SSreekanth Reddy if (!(ioc->diag_buffer_status[i] & 475f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED)) 476f92363d1SSreekanth Reddy continue; 477f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[i] & 478f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 479f92363d1SSreekanth Reddy continue; 480f92363d1SSreekanth Reddy ioc->diag_buffer_status[i] |= 481f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_DIAG_RESET; 482f92363d1SSreekanth Reddy } 483f92363d1SSreekanth Reddy break; 484f92363d1SSreekanth Reddy } 485f92363d1SSreekanth Reddy } 486f92363d1SSreekanth Reddy 487f92363d1SSreekanth Reddy /** 4888a7e4c24SSreekanth Reddy * ctl_fasync - 489f92363d1SSreekanth Reddy * @fd - 490f92363d1SSreekanth Reddy * @filep - 491f92363d1SSreekanth Reddy * @mode - 492f92363d1SSreekanth Reddy * 493f92363d1SSreekanth Reddy * Called when application request fasyn callback handler. 494f92363d1SSreekanth Reddy */ 4958a7e4c24SSreekanth Reddy int 4968a7e4c24SSreekanth Reddy ctl_fasync(int fd, struct file *filep, int mode) 497f92363d1SSreekanth Reddy { 498f92363d1SSreekanth Reddy return fasync_helper(fd, filep, mode, &async_queue); 499f92363d1SSreekanth Reddy } 500f92363d1SSreekanth Reddy 501f92363d1SSreekanth Reddy /** 5028a7e4c24SSreekanth Reddy * ctl_poll - 503f92363d1SSreekanth Reddy * @file - 504f92363d1SSreekanth Reddy * @wait - 505f92363d1SSreekanth Reddy * 506f92363d1SSreekanth Reddy */ 5078a7e4c24SSreekanth Reddy unsigned int 5088a7e4c24SSreekanth Reddy ctl_poll(struct file *filep, poll_table *wait) 509f92363d1SSreekanth Reddy { 510f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 511f92363d1SSreekanth Reddy 512f92363d1SSreekanth Reddy poll_wait(filep, &ctl_poll_wait, wait); 513f92363d1SSreekanth Reddy 514f92363d1SSreekanth Reddy list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 515f92363d1SSreekanth Reddy if (ioc->aen_event_read_flag) 516f92363d1SSreekanth Reddy return POLLIN | POLLRDNORM; 517f92363d1SSreekanth Reddy } 518f92363d1SSreekanth Reddy return 0; 519f92363d1SSreekanth Reddy } 520f92363d1SSreekanth Reddy 521f92363d1SSreekanth Reddy /** 522f92363d1SSreekanth Reddy * _ctl_set_task_mid - assign an active smid to tm request 523f92363d1SSreekanth Reddy * @ioc: per adapter object 524f92363d1SSreekanth Reddy * @karg - (struct mpt3_ioctl_command) 525f92363d1SSreekanth Reddy * @tm_request - pointer to mf from user space 526f92363d1SSreekanth Reddy * 527f92363d1SSreekanth Reddy * Returns 0 when an smid if found, else fail. 528f92363d1SSreekanth Reddy * during failure, the reply frame is filled. 529f92363d1SSreekanth Reddy */ 530f92363d1SSreekanth Reddy static int 531f92363d1SSreekanth Reddy _ctl_set_task_mid(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command *karg, 532f92363d1SSreekanth Reddy Mpi2SCSITaskManagementRequest_t *tm_request) 533f92363d1SSreekanth Reddy { 534f92363d1SSreekanth Reddy u8 found = 0; 535f92363d1SSreekanth Reddy u16 i; 536f92363d1SSreekanth Reddy u16 handle; 537f92363d1SSreekanth Reddy struct scsi_cmnd *scmd; 538f92363d1SSreekanth Reddy struct MPT3SAS_DEVICE *priv_data; 539f92363d1SSreekanth Reddy unsigned long flags; 540f92363d1SSreekanth Reddy Mpi2SCSITaskManagementReply_t *tm_reply; 541f92363d1SSreekanth Reddy u32 sz; 542f92363d1SSreekanth Reddy u32 lun; 543f92363d1SSreekanth Reddy char *desc = NULL; 544f92363d1SSreekanth Reddy 545f92363d1SSreekanth Reddy if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK) 546f92363d1SSreekanth Reddy desc = "abort_task"; 547f92363d1SSreekanth Reddy else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) 548f92363d1SSreekanth Reddy desc = "query_task"; 549f92363d1SSreekanth Reddy else 550f92363d1SSreekanth Reddy return 0; 551f92363d1SSreekanth Reddy 552f92363d1SSreekanth Reddy lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN); 553f92363d1SSreekanth Reddy 554f92363d1SSreekanth Reddy handle = le16_to_cpu(tm_request->DevHandle); 555f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 556f92363d1SSreekanth Reddy for (i = ioc->scsiio_depth; i && !found; i--) { 557f92363d1SSreekanth Reddy scmd = ioc->scsi_lookup[i - 1].scmd; 558f92363d1SSreekanth Reddy if (scmd == NULL || scmd->device == NULL || 559f92363d1SSreekanth Reddy scmd->device->hostdata == NULL) 560f92363d1SSreekanth Reddy continue; 561f92363d1SSreekanth Reddy if (lun != scmd->device->lun) 562f92363d1SSreekanth Reddy continue; 563f92363d1SSreekanth Reddy priv_data = scmd->device->hostdata; 564f92363d1SSreekanth Reddy if (priv_data->sas_target == NULL) 565f92363d1SSreekanth Reddy continue; 566f92363d1SSreekanth Reddy if (priv_data->sas_target->handle != handle) 567f92363d1SSreekanth Reddy continue; 568f92363d1SSreekanth Reddy tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid); 569f92363d1SSreekanth Reddy found = 1; 570f92363d1SSreekanth Reddy } 571f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 572f92363d1SSreekanth Reddy 573f92363d1SSreekanth Reddy if (!found) { 574f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 575f92363d1SSreekanth Reddy "%s: handle(0x%04x), lun(%d), no active mid!!\n", 576f92363d1SSreekanth Reddy ioc->name, 577f92363d1SSreekanth Reddy desc, le16_to_cpu(tm_request->DevHandle), lun)); 578f92363d1SSreekanth Reddy tm_reply = ioc->ctl_cmds.reply; 579f92363d1SSreekanth Reddy tm_reply->DevHandle = tm_request->DevHandle; 580f92363d1SSreekanth Reddy tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 581f92363d1SSreekanth Reddy tm_reply->TaskType = tm_request->TaskType; 582f92363d1SSreekanth Reddy tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4; 583f92363d1SSreekanth Reddy tm_reply->VP_ID = tm_request->VP_ID; 584f92363d1SSreekanth Reddy tm_reply->VF_ID = tm_request->VF_ID; 585f92363d1SSreekanth Reddy sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz); 586f92363d1SSreekanth Reddy if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply, 587f92363d1SSreekanth Reddy sz)) 588f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 589f92363d1SSreekanth Reddy __LINE__, __func__); 590f92363d1SSreekanth Reddy return 1; 591f92363d1SSreekanth Reddy } 592f92363d1SSreekanth Reddy 593f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 594f92363d1SSreekanth Reddy "%s: handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name, 595f92363d1SSreekanth Reddy desc, le16_to_cpu(tm_request->DevHandle), lun, 596f92363d1SSreekanth Reddy le16_to_cpu(tm_request->TaskMID))); 597f92363d1SSreekanth Reddy return 0; 598f92363d1SSreekanth Reddy } 599f92363d1SSreekanth Reddy 600f92363d1SSreekanth Reddy /** 601f92363d1SSreekanth Reddy * _ctl_do_mpt_command - main handler for MPT3COMMAND opcode 602f92363d1SSreekanth Reddy * @ioc: per adapter object 603f92363d1SSreekanth Reddy * @karg - (struct mpt3_ioctl_command) 604f92363d1SSreekanth Reddy * @mf - pointer to mf in user space 605f92363d1SSreekanth Reddy */ 606f92363d1SSreekanth Reddy static long 607f92363d1SSreekanth Reddy _ctl_do_mpt_command(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command karg, 608f92363d1SSreekanth Reddy void __user *mf) 609f92363d1SSreekanth Reddy { 610f92363d1SSreekanth Reddy MPI2RequestHeader_t *mpi_request = NULL, *request; 611f92363d1SSreekanth Reddy MPI2DefaultReply_t *mpi_reply; 612f92363d1SSreekanth Reddy u32 ioc_state; 613f92363d1SSreekanth Reddy u16 ioc_status; 614f92363d1SSreekanth Reddy u16 smid; 615f92363d1SSreekanth Reddy unsigned long timeout, timeleft; 616f92363d1SSreekanth Reddy u8 issue_reset; 617f92363d1SSreekanth Reddy u32 sz; 618f92363d1SSreekanth Reddy void *psge; 619f92363d1SSreekanth Reddy void *data_out = NULL; 620f92363d1SSreekanth Reddy dma_addr_t data_out_dma = 0; 621f92363d1SSreekanth Reddy size_t data_out_sz = 0; 622f92363d1SSreekanth Reddy void *data_in = NULL; 623f92363d1SSreekanth Reddy dma_addr_t data_in_dma = 0; 624f92363d1SSreekanth Reddy size_t data_in_sz = 0; 625f92363d1SSreekanth Reddy long ret; 626f92363d1SSreekanth Reddy u16 wait_state_count; 627f92363d1SSreekanth Reddy 628f92363d1SSreekanth Reddy issue_reset = 0; 629f92363d1SSreekanth Reddy 630f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 631f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 632f92363d1SSreekanth Reddy ioc->name, __func__); 633f92363d1SSreekanth Reddy ret = -EAGAIN; 634f92363d1SSreekanth Reddy goto out; 635f92363d1SSreekanth Reddy } 636f92363d1SSreekanth Reddy 637f92363d1SSreekanth Reddy wait_state_count = 0; 638f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 639f92363d1SSreekanth Reddy while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 640f92363d1SSreekanth Reddy if (wait_state_count++ == 10) { 641f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 642f92363d1SSreekanth Reddy "%s: failed due to ioc not operational\n", 643f92363d1SSreekanth Reddy ioc->name, __func__); 644f92363d1SSreekanth Reddy ret = -EFAULT; 645f92363d1SSreekanth Reddy goto out; 646f92363d1SSreekanth Reddy } 647f92363d1SSreekanth Reddy ssleep(1); 648f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 649f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 650f92363d1SSreekanth Reddy "%s: waiting for operational state(count=%d)\n", 651f92363d1SSreekanth Reddy ioc->name, 652f92363d1SSreekanth Reddy __func__, wait_state_count); 653f92363d1SSreekanth Reddy } 654f92363d1SSreekanth Reddy if (wait_state_count) 655f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "%s: ioc is operational\n", 656f92363d1SSreekanth Reddy ioc->name, __func__); 657f92363d1SSreekanth Reddy 658f92363d1SSreekanth Reddy mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL); 659f92363d1SSreekanth Reddy if (!mpi_request) { 660f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 661f92363d1SSreekanth Reddy "%s: failed obtaining a memory for mpi_request\n", 662f92363d1SSreekanth Reddy ioc->name, __func__); 663f92363d1SSreekanth Reddy ret = -ENOMEM; 664f92363d1SSreekanth Reddy goto out; 665f92363d1SSreekanth Reddy } 666f92363d1SSreekanth Reddy 667f92363d1SSreekanth Reddy /* Check for overflow and wraparound */ 668f92363d1SSreekanth Reddy if (karg.data_sge_offset * 4 > ioc->request_sz || 669f92363d1SSreekanth Reddy karg.data_sge_offset > (UINT_MAX / 4)) { 670f92363d1SSreekanth Reddy ret = -EINVAL; 671f92363d1SSreekanth Reddy goto out; 672f92363d1SSreekanth Reddy } 673f92363d1SSreekanth Reddy 674f92363d1SSreekanth Reddy /* copy in request message frame from user */ 675f92363d1SSreekanth Reddy if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) { 676f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__, 677f92363d1SSreekanth Reddy __func__); 678f92363d1SSreekanth Reddy ret = -EFAULT; 679f92363d1SSreekanth Reddy goto out; 680f92363d1SSreekanth Reddy } 681f92363d1SSreekanth Reddy 682f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 683f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx); 684f92363d1SSreekanth Reddy if (!smid) { 685f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 686f92363d1SSreekanth Reddy ioc->name, __func__); 687f92363d1SSreekanth Reddy ret = -EAGAIN; 688f92363d1SSreekanth Reddy goto out; 689f92363d1SSreekanth Reddy } 690f92363d1SSreekanth Reddy } else { 691f92363d1SSreekanth Reddy 692f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->ctl_cb_idx, NULL); 693f92363d1SSreekanth Reddy if (!smid) { 694f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 695f92363d1SSreekanth Reddy ioc->name, __func__); 696f92363d1SSreekanth Reddy ret = -EAGAIN; 697f92363d1SSreekanth Reddy goto out; 698f92363d1SSreekanth Reddy } 699f92363d1SSreekanth Reddy } 700f92363d1SSreekanth Reddy 701f92363d1SSreekanth Reddy ret = 0; 702f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 703f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 704f92363d1SSreekanth Reddy request = mpt3sas_base_get_msg_frame(ioc, smid); 705f92363d1SSreekanth Reddy memcpy(request, mpi_request, karg.data_sge_offset*4); 706f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 707f92363d1SSreekanth Reddy data_out_sz = karg.data_out_size; 708f92363d1SSreekanth Reddy data_in_sz = karg.data_in_size; 709f92363d1SSreekanth Reddy 710f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 711f92363d1SSreekanth Reddy mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) { 712f92363d1SSreekanth Reddy if (!le16_to_cpu(mpi_request->FunctionDependent1) || 713f92363d1SSreekanth Reddy le16_to_cpu(mpi_request->FunctionDependent1) > 714f92363d1SSreekanth Reddy ioc->facts.MaxDevHandle) { 715f92363d1SSreekanth Reddy ret = -EINVAL; 716f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 717f92363d1SSreekanth Reddy goto out; 718f92363d1SSreekanth Reddy } 719f92363d1SSreekanth Reddy } 720f92363d1SSreekanth Reddy 721f92363d1SSreekanth Reddy /* obtain dma-able memory for data transfer */ 722f92363d1SSreekanth Reddy if (data_out_sz) /* WRITE */ { 723f92363d1SSreekanth Reddy data_out = pci_alloc_consistent(ioc->pdev, data_out_sz, 724f92363d1SSreekanth Reddy &data_out_dma); 725f92363d1SSreekanth Reddy if (!data_out) { 726f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 727f92363d1SSreekanth Reddy __LINE__, __func__); 728f92363d1SSreekanth Reddy ret = -ENOMEM; 729f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 730f92363d1SSreekanth Reddy goto out; 731f92363d1SSreekanth Reddy } 732f92363d1SSreekanth Reddy if (copy_from_user(data_out, karg.data_out_buf_ptr, 733f92363d1SSreekanth Reddy data_out_sz)) { 734f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 735f92363d1SSreekanth Reddy __LINE__, __func__); 736f92363d1SSreekanth Reddy ret = -EFAULT; 737f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 738f92363d1SSreekanth Reddy goto out; 739f92363d1SSreekanth Reddy } 740f92363d1SSreekanth Reddy } 741f92363d1SSreekanth Reddy 742f92363d1SSreekanth Reddy if (data_in_sz) /* READ */ { 743f92363d1SSreekanth Reddy data_in = pci_alloc_consistent(ioc->pdev, data_in_sz, 744f92363d1SSreekanth Reddy &data_in_dma); 745f92363d1SSreekanth Reddy if (!data_in) { 746f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 747f92363d1SSreekanth Reddy __LINE__, __func__); 748f92363d1SSreekanth Reddy ret = -ENOMEM; 749f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 750f92363d1SSreekanth Reddy goto out; 751f92363d1SSreekanth Reddy } 752f92363d1SSreekanth Reddy } 753f92363d1SSreekanth Reddy 754f92363d1SSreekanth Reddy psge = (void *)request + (karg.data_sge_offset*4); 755f92363d1SSreekanth Reddy 756f92363d1SSreekanth Reddy /* send command to firmware */ 757f92363d1SSreekanth Reddy _ctl_display_some_debug(ioc, smid, "ctl_request", NULL); 758f92363d1SSreekanth Reddy 759f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 760f92363d1SSreekanth Reddy switch (mpi_request->Function) { 761f92363d1SSreekanth Reddy case MPI2_FUNCTION_SCSI_IO_REQUEST: 762f92363d1SSreekanth Reddy case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH: 763f92363d1SSreekanth Reddy { 764f92363d1SSreekanth Reddy Mpi2SCSIIORequest_t *scsiio_request = 765f92363d1SSreekanth Reddy (Mpi2SCSIIORequest_t *)request; 766f92363d1SSreekanth Reddy scsiio_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 767f92363d1SSreekanth Reddy scsiio_request->SenseBufferLowAddress = 768f92363d1SSreekanth Reddy mpt3sas_base_get_sense_buffer_dma(ioc, smid); 769f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE); 770f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, 771f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 772f92363d1SSreekanth Reddy 773f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST) 774f92363d1SSreekanth Reddy mpt3sas_base_put_smid_scsi_io(ioc, smid, 775f92363d1SSreekanth Reddy le16_to_cpu(mpi_request->FunctionDependent1)); 776f92363d1SSreekanth Reddy else 777f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 778f92363d1SSreekanth Reddy break; 779f92363d1SSreekanth Reddy } 780f92363d1SSreekanth Reddy case MPI2_FUNCTION_SCSI_TASK_MGMT: 781f92363d1SSreekanth Reddy { 782f92363d1SSreekanth Reddy Mpi2SCSITaskManagementRequest_t *tm_request = 783f92363d1SSreekanth Reddy (Mpi2SCSITaskManagementRequest_t *)request; 784f92363d1SSreekanth Reddy 785f92363d1SSreekanth Reddy dtmprintk(ioc, pr_info(MPT3SAS_FMT 786f92363d1SSreekanth Reddy "TASK_MGMT: handle(0x%04x), task_type(0x%02x)\n", 787f92363d1SSreekanth Reddy ioc->name, 788f92363d1SSreekanth Reddy le16_to_cpu(tm_request->DevHandle), tm_request->TaskType)); 789f92363d1SSreekanth Reddy 790f92363d1SSreekanth Reddy if (tm_request->TaskType == 791f92363d1SSreekanth Reddy MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK || 792f92363d1SSreekanth Reddy tm_request->TaskType == 793f92363d1SSreekanth Reddy MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) { 794f92363d1SSreekanth Reddy if (_ctl_set_task_mid(ioc, &karg, tm_request)) { 795f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 796f92363d1SSreekanth Reddy goto out; 797f92363d1SSreekanth Reddy } 798f92363d1SSreekanth Reddy } 799f92363d1SSreekanth Reddy 800f92363d1SSreekanth Reddy mpt3sas_scsih_set_tm_flag(ioc, le16_to_cpu( 801f92363d1SSreekanth Reddy tm_request->DevHandle)); 802f92363d1SSreekanth Reddy ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 803f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 804f92363d1SSreekanth Reddy mpt3sas_base_put_smid_hi_priority(ioc, smid); 805f92363d1SSreekanth Reddy break; 806f92363d1SSreekanth Reddy } 807f92363d1SSreekanth Reddy case MPI2_FUNCTION_SMP_PASSTHROUGH: 808f92363d1SSreekanth Reddy { 809f92363d1SSreekanth Reddy Mpi2SmpPassthroughRequest_t *smp_request = 810f92363d1SSreekanth Reddy (Mpi2SmpPassthroughRequest_t *)mpi_request; 811f92363d1SSreekanth Reddy u8 *data; 812f92363d1SSreekanth Reddy 813f92363d1SSreekanth Reddy /* ioc determines which port to use */ 814f92363d1SSreekanth Reddy smp_request->PhysicalPort = 0xFF; 815f92363d1SSreekanth Reddy if (smp_request->PassthroughFlags & 816f92363d1SSreekanth Reddy MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE) 817f92363d1SSreekanth Reddy data = (u8 *)&smp_request->SGL; 818f92363d1SSreekanth Reddy else { 819f92363d1SSreekanth Reddy if (unlikely(data_out == NULL)) { 820f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 821f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 822f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 823f92363d1SSreekanth Reddy ret = -EINVAL; 824f92363d1SSreekanth Reddy goto out; 825f92363d1SSreekanth Reddy } 826f92363d1SSreekanth Reddy data = data_out; 827f92363d1SSreekanth Reddy } 828f92363d1SSreekanth Reddy 829f92363d1SSreekanth Reddy if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) { 830f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress = 1; 831f92363d1SSreekanth Reddy ioc->ignore_loginfos = 1; 832f92363d1SSreekanth Reddy } 833f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 834f92363d1SSreekanth Reddy data_in_sz); 835f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 836f92363d1SSreekanth Reddy break; 837f92363d1SSreekanth Reddy } 838f92363d1SSreekanth Reddy case MPI2_FUNCTION_SATA_PASSTHROUGH: 839f92363d1SSreekanth Reddy case MPI2_FUNCTION_FW_DOWNLOAD: 840f92363d1SSreekanth Reddy case MPI2_FUNCTION_FW_UPLOAD: 841f92363d1SSreekanth Reddy { 842f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma, 843f92363d1SSreekanth Reddy data_in_sz); 844f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 845f92363d1SSreekanth Reddy break; 846f92363d1SSreekanth Reddy } 847f92363d1SSreekanth Reddy case MPI2_FUNCTION_TOOLBOX: 848f92363d1SSreekanth Reddy { 849f92363d1SSreekanth Reddy Mpi2ToolboxCleanRequest_t *toolbox_request = 850f92363d1SSreekanth Reddy (Mpi2ToolboxCleanRequest_t *)mpi_request; 851f92363d1SSreekanth Reddy 852f92363d1SSreekanth Reddy if (toolbox_request->Tool == MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL) { 853f92363d1SSreekanth Reddy ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, 854f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 855f92363d1SSreekanth Reddy } else { 856f92363d1SSreekanth Reddy ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 857f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 858f92363d1SSreekanth Reddy } 859f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 860f92363d1SSreekanth Reddy break; 861f92363d1SSreekanth Reddy } 862f92363d1SSreekanth Reddy case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL: 863f92363d1SSreekanth Reddy { 864f92363d1SSreekanth Reddy Mpi2SasIoUnitControlRequest_t *sasiounit_request = 865f92363d1SSreekanth Reddy (Mpi2SasIoUnitControlRequest_t *)mpi_request; 866f92363d1SSreekanth Reddy 867f92363d1SSreekanth Reddy if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET 868f92363d1SSreekanth Reddy || sasiounit_request->Operation == 869f92363d1SSreekanth Reddy MPI2_SAS_OP_PHY_LINK_RESET) { 870f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress = 1; 871f92363d1SSreekanth Reddy ioc->ignore_loginfos = 1; 872f92363d1SSreekanth Reddy } 873f92363d1SSreekanth Reddy /* drop to default case for posting the request */ 874f92363d1SSreekanth Reddy } 875f92363d1SSreekanth Reddy default: 876f92363d1SSreekanth Reddy ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz, 877f92363d1SSreekanth Reddy data_in_dma, data_in_sz); 878f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 879f92363d1SSreekanth Reddy break; 880f92363d1SSreekanth Reddy } 881f92363d1SSreekanth Reddy 882f92363d1SSreekanth Reddy if (karg.timeout < MPT3_IOCTL_DEFAULT_TIMEOUT) 883f92363d1SSreekanth Reddy timeout = MPT3_IOCTL_DEFAULT_TIMEOUT; 884f92363d1SSreekanth Reddy else 885f92363d1SSreekanth Reddy timeout = karg.timeout; 886f92363d1SSreekanth Reddy timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 887f92363d1SSreekanth Reddy timeout*HZ); 888f92363d1SSreekanth Reddy if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 889f92363d1SSreekanth Reddy Mpi2SCSITaskManagementRequest_t *tm_request = 890f92363d1SSreekanth Reddy (Mpi2SCSITaskManagementRequest_t *)mpi_request; 891f92363d1SSreekanth Reddy mpt3sas_scsih_clear_tm_flag(ioc, le16_to_cpu( 892f92363d1SSreekanth Reddy tm_request->DevHandle)); 893f92363d1SSreekanth Reddy mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT); 894f92363d1SSreekanth Reddy } else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH || 895f92363d1SSreekanth Reddy mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) && 896f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress) { 897f92363d1SSreekanth Reddy ioc->ioc_link_reset_in_progress = 0; 898f92363d1SSreekanth Reddy ioc->ignore_loginfos = 0; 899f92363d1SSreekanth Reddy } 900f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 901f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 902f92363d1SSreekanth Reddy __func__); 903f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, karg.data_sge_offset); 904f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 905f92363d1SSreekanth Reddy issue_reset = 1; 906f92363d1SSreekanth Reddy goto issue_host_reset; 907f92363d1SSreekanth Reddy } 908f92363d1SSreekanth Reddy 909f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 910f92363d1SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 911f92363d1SSreekanth Reddy 912f92363d1SSreekanth Reddy if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT && 913f92363d1SSreekanth Reddy (ioc->logging_level & MPT_DEBUG_TM)) { 914f92363d1SSreekanth Reddy Mpi2SCSITaskManagementReply_t *tm_reply = 915f92363d1SSreekanth Reddy (Mpi2SCSITaskManagementReply_t *)mpi_reply; 916f92363d1SSreekanth Reddy 917f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "TASK_MGMT: " \ 918f92363d1SSreekanth Reddy "IOCStatus(0x%04x), IOCLogInfo(0x%08x), " 919f92363d1SSreekanth Reddy "TerminationCount(0x%08x)\n", ioc->name, 920f92363d1SSreekanth Reddy le16_to_cpu(tm_reply->IOCStatus), 921f92363d1SSreekanth Reddy le32_to_cpu(tm_reply->IOCLogInfo), 922f92363d1SSreekanth Reddy le32_to_cpu(tm_reply->TerminationCount)); 923f92363d1SSreekanth Reddy } 924af009411SSreekanth Reddy 925f92363d1SSreekanth Reddy /* copy out xdata to user */ 926f92363d1SSreekanth Reddy if (data_in_sz) { 927f92363d1SSreekanth Reddy if (copy_to_user(karg.data_in_buf_ptr, data_in, 928f92363d1SSreekanth Reddy data_in_sz)) { 929f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 930f92363d1SSreekanth Reddy __LINE__, __func__); 931f92363d1SSreekanth Reddy ret = -ENODATA; 932f92363d1SSreekanth Reddy goto out; 933f92363d1SSreekanth Reddy } 934f92363d1SSreekanth Reddy } 935f92363d1SSreekanth Reddy 936f92363d1SSreekanth Reddy /* copy out reply message frame to user */ 937f92363d1SSreekanth Reddy if (karg.max_reply_bytes) { 938f92363d1SSreekanth Reddy sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz); 939f92363d1SSreekanth Reddy if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply, 940f92363d1SSreekanth Reddy sz)) { 941f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 942f92363d1SSreekanth Reddy __LINE__, __func__); 943f92363d1SSreekanth Reddy ret = -ENODATA; 944f92363d1SSreekanth Reddy goto out; 945f92363d1SSreekanth Reddy } 946f92363d1SSreekanth Reddy } 947f92363d1SSreekanth Reddy 948f92363d1SSreekanth Reddy /* copy out sense to user */ 949f92363d1SSreekanth Reddy if (karg.max_sense_bytes && (mpi_request->Function == 950f92363d1SSreekanth Reddy MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function == 951f92363d1SSreekanth Reddy MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) { 952f92363d1SSreekanth Reddy sz = min_t(u32, karg.max_sense_bytes, SCSI_SENSE_BUFFERSIZE); 953f92363d1SSreekanth Reddy if (copy_to_user(karg.sense_data_ptr, ioc->ctl_cmds.sense, 954f92363d1SSreekanth Reddy sz)) { 955f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", __FILE__, 956f92363d1SSreekanth Reddy __LINE__, __func__); 957f92363d1SSreekanth Reddy ret = -ENODATA; 958f92363d1SSreekanth Reddy goto out; 959f92363d1SSreekanth Reddy } 960f92363d1SSreekanth Reddy } 961f92363d1SSreekanth Reddy 962f92363d1SSreekanth Reddy issue_host_reset: 963f92363d1SSreekanth Reddy if (issue_reset) { 964f92363d1SSreekanth Reddy ret = -ENODATA; 965f92363d1SSreekanth Reddy if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST || 966f92363d1SSreekanth Reddy mpi_request->Function == 967f92363d1SSreekanth Reddy MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || 968f92363d1SSreekanth Reddy mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH)) { 969f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "issue target reset: handle = (0x%04x)\n", 970f92363d1SSreekanth Reddy ioc->name, 971f92363d1SSreekanth Reddy le16_to_cpu(mpi_request->FunctionDependent1)); 972f92363d1SSreekanth Reddy mpt3sas_halt_firmware(ioc); 973f92363d1SSreekanth Reddy mpt3sas_scsih_issue_tm(ioc, 974f92363d1SSreekanth Reddy le16_to_cpu(mpi_request->FunctionDependent1), 0, 0, 975f92363d1SSreekanth Reddy 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 30, 976c62e46deSMatthew Wilcox TM_MUTEX_ON); 977f92363d1SSreekanth Reddy } else 978f92363d1SSreekanth Reddy mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 979f92363d1SSreekanth Reddy FORCE_BIG_HAMMER); 980f92363d1SSreekanth Reddy } 981f92363d1SSreekanth Reddy 982f92363d1SSreekanth Reddy out: 983f92363d1SSreekanth Reddy 984f92363d1SSreekanth Reddy /* free memory associated with sg buffers */ 985f92363d1SSreekanth Reddy if (data_in) 986f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, data_in_sz, data_in, 987f92363d1SSreekanth Reddy data_in_dma); 988f92363d1SSreekanth Reddy 989f92363d1SSreekanth Reddy if (data_out) 990f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, data_out_sz, data_out, 991f92363d1SSreekanth Reddy data_out_dma); 992f92363d1SSreekanth Reddy 993f92363d1SSreekanth Reddy kfree(mpi_request); 994f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 995f92363d1SSreekanth Reddy return ret; 996f92363d1SSreekanth Reddy } 997f92363d1SSreekanth Reddy 998f92363d1SSreekanth Reddy /** 999f92363d1SSreekanth Reddy * _ctl_getiocinfo - main handler for MPT3IOCINFO opcode 1000f92363d1SSreekanth Reddy * @ioc: per adapter object 1001f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1002f92363d1SSreekanth Reddy */ 1003f92363d1SSreekanth Reddy static long 1004f92363d1SSreekanth Reddy _ctl_getiocinfo(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1005f92363d1SSreekanth Reddy { 1006f92363d1SSreekanth Reddy struct mpt3_ioctl_iocinfo karg; 1007f92363d1SSreekanth Reddy 1008f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1009f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1010f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1011f92363d1SSreekanth Reddy return -EFAULT; 1012f92363d1SSreekanth Reddy } 1013f92363d1SSreekanth Reddy 1014f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1015f92363d1SSreekanth Reddy __func__)); 1016f92363d1SSreekanth Reddy 1017f92363d1SSreekanth Reddy memset(&karg, 0 , sizeof(karg)); 1018f92363d1SSreekanth Reddy if (ioc->pfacts) 1019f92363d1SSreekanth Reddy karg.port_number = ioc->pfacts[0].PortNumber; 1020f92363d1SSreekanth Reddy karg.hw_rev = ioc->pdev->revision; 1021f92363d1SSreekanth Reddy karg.pci_id = ioc->pdev->device; 1022f92363d1SSreekanth Reddy karg.subsystem_device = ioc->pdev->subsystem_device; 1023f92363d1SSreekanth Reddy karg.subsystem_vendor = ioc->pdev->subsystem_vendor; 1024f92363d1SSreekanth Reddy karg.pci_information.u.bits.bus = ioc->pdev->bus->number; 1025f92363d1SSreekanth Reddy karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn); 1026f92363d1SSreekanth Reddy karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn); 1027f92363d1SSreekanth Reddy karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus); 1028f92363d1SSreekanth Reddy karg.firmware_version = ioc->facts.FWVersion.Word; 1029d357e84dSSreekanth Reddy strcpy(karg.driver_version, driver_name); 1030f92363d1SSreekanth Reddy strcat(karg.driver_version, "-"); 1031d357e84dSSreekanth Reddy switch (ioc->hba_mpi_version_belonged) { 1032d357e84dSSreekanth Reddy case MPI2_VERSION: 10337786ab6aSSreekanth Reddy if (ioc->is_warpdrive) 10347786ab6aSSreekanth Reddy karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2_SSS6200; 10357786ab6aSSreekanth Reddy else 1036d357e84dSSreekanth Reddy karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2; 1037d357e84dSSreekanth Reddy strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION); 1038d357e84dSSreekanth Reddy break; 1039d357e84dSSreekanth Reddy case MPI25_VERSION: 1040d357e84dSSreekanth Reddy karg.adapter_type = MPT3_IOCTL_INTERFACE_SAS3; 1041d357e84dSSreekanth Reddy strcat(karg.driver_version, MPT3SAS_DRIVER_VERSION); 1042d357e84dSSreekanth Reddy break; 1043d357e84dSSreekanth Reddy } 1044d357e84dSSreekanth Reddy if (ioc->hba_mpi_version_belonged == MPI2_VERSION) 1045d357e84dSSreekanth Reddy strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION); 1046d357e84dSSreekanth Reddy else 1047f92363d1SSreekanth Reddy strcat(karg.driver_version, MPT3SAS_DRIVER_VERSION); 1048f92363d1SSreekanth Reddy karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 1049f92363d1SSreekanth Reddy 1050f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(karg))) { 1051f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1052f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1053f92363d1SSreekanth Reddy return -EFAULT; 1054f92363d1SSreekanth Reddy } 1055f92363d1SSreekanth Reddy return 0; 1056f92363d1SSreekanth Reddy } 1057f92363d1SSreekanth Reddy 1058f92363d1SSreekanth Reddy /** 1059f92363d1SSreekanth Reddy * _ctl_eventquery - main handler for MPT3EVENTQUERY opcode 1060f92363d1SSreekanth Reddy * @ioc: per adapter object 1061f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1062f92363d1SSreekanth Reddy */ 1063f92363d1SSreekanth Reddy static long 1064f92363d1SSreekanth Reddy _ctl_eventquery(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1065f92363d1SSreekanth Reddy { 1066f92363d1SSreekanth Reddy struct mpt3_ioctl_eventquery karg; 1067f92363d1SSreekanth Reddy 1068f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1069f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1070f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1071f92363d1SSreekanth Reddy return -EFAULT; 1072f92363d1SSreekanth Reddy } 1073f92363d1SSreekanth Reddy 1074f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1075f92363d1SSreekanth Reddy __func__)); 1076f92363d1SSreekanth Reddy 1077f92363d1SSreekanth Reddy karg.event_entries = MPT3SAS_CTL_EVENT_LOG_SIZE; 1078f92363d1SSreekanth Reddy memcpy(karg.event_types, ioc->event_type, 1079f92363d1SSreekanth Reddy MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1080f92363d1SSreekanth Reddy 1081f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(karg))) { 1082f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1083f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1084f92363d1SSreekanth Reddy return -EFAULT; 1085f92363d1SSreekanth Reddy } 1086f92363d1SSreekanth Reddy return 0; 1087f92363d1SSreekanth Reddy } 1088f92363d1SSreekanth Reddy 1089f92363d1SSreekanth Reddy /** 1090f92363d1SSreekanth Reddy * _ctl_eventenable - main handler for MPT3EVENTENABLE opcode 1091f92363d1SSreekanth Reddy * @ioc: per adapter object 1092f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1093f92363d1SSreekanth Reddy */ 1094f92363d1SSreekanth Reddy static long 1095f92363d1SSreekanth Reddy _ctl_eventenable(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1096f92363d1SSreekanth Reddy { 1097f92363d1SSreekanth Reddy struct mpt3_ioctl_eventenable karg; 1098f92363d1SSreekanth Reddy 1099f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1100f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1101f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1102f92363d1SSreekanth Reddy return -EFAULT; 1103f92363d1SSreekanth Reddy } 1104f92363d1SSreekanth Reddy 1105f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1106f92363d1SSreekanth Reddy __func__)); 1107f92363d1SSreekanth Reddy 1108f92363d1SSreekanth Reddy memcpy(ioc->event_type, karg.event_types, 1109f92363d1SSreekanth Reddy MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32)); 1110f92363d1SSreekanth Reddy mpt3sas_base_validate_event_type(ioc, ioc->event_type); 1111f92363d1SSreekanth Reddy 1112f92363d1SSreekanth Reddy if (ioc->event_log) 1113f92363d1SSreekanth Reddy return 0; 1114f92363d1SSreekanth Reddy /* initialize event_log */ 1115f92363d1SSreekanth Reddy ioc->event_context = 0; 1116f92363d1SSreekanth Reddy ioc->aen_event_read_flag = 0; 1117f92363d1SSreekanth Reddy ioc->event_log = kcalloc(MPT3SAS_CTL_EVENT_LOG_SIZE, 1118f92363d1SSreekanth Reddy sizeof(struct MPT3_IOCTL_EVENTS), GFP_KERNEL); 1119f92363d1SSreekanth Reddy if (!ioc->event_log) { 1120f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1121f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1122f92363d1SSreekanth Reddy return -ENOMEM; 1123f92363d1SSreekanth Reddy } 1124f92363d1SSreekanth Reddy return 0; 1125f92363d1SSreekanth Reddy } 1126f92363d1SSreekanth Reddy 1127f92363d1SSreekanth Reddy /** 1128f92363d1SSreekanth Reddy * _ctl_eventreport - main handler for MPT3EVENTREPORT opcode 1129f92363d1SSreekanth Reddy * @ioc: per adapter object 1130f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1131f92363d1SSreekanth Reddy */ 1132f92363d1SSreekanth Reddy static long 1133f92363d1SSreekanth Reddy _ctl_eventreport(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1134f92363d1SSreekanth Reddy { 1135f92363d1SSreekanth Reddy struct mpt3_ioctl_eventreport karg; 1136f92363d1SSreekanth Reddy u32 number_bytes, max_events, max; 1137f92363d1SSreekanth Reddy struct mpt3_ioctl_eventreport __user *uarg = arg; 1138f92363d1SSreekanth Reddy 1139f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1140f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1141f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1142f92363d1SSreekanth Reddy return -EFAULT; 1143f92363d1SSreekanth Reddy } 1144f92363d1SSreekanth Reddy 1145f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1146f92363d1SSreekanth Reddy __func__)); 1147f92363d1SSreekanth Reddy 1148f92363d1SSreekanth Reddy number_bytes = karg.hdr.max_data_size - 1149f92363d1SSreekanth Reddy sizeof(struct mpt3_ioctl_header); 1150f92363d1SSreekanth Reddy max_events = number_bytes/sizeof(struct MPT3_IOCTL_EVENTS); 1151f92363d1SSreekanth Reddy max = min_t(u32, MPT3SAS_CTL_EVENT_LOG_SIZE, max_events); 1152f92363d1SSreekanth Reddy 1153f92363d1SSreekanth Reddy /* If fewer than 1 event is requested, there must have 1154f92363d1SSreekanth Reddy * been some type of error. 1155f92363d1SSreekanth Reddy */ 1156f92363d1SSreekanth Reddy if (!max || !ioc->event_log) 1157f92363d1SSreekanth Reddy return -ENODATA; 1158f92363d1SSreekanth Reddy 1159f92363d1SSreekanth Reddy number_bytes = max * sizeof(struct MPT3_IOCTL_EVENTS); 1160f92363d1SSreekanth Reddy if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) { 1161f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1162f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1163f92363d1SSreekanth Reddy return -EFAULT; 1164f92363d1SSreekanth Reddy } 1165f92363d1SSreekanth Reddy 1166f92363d1SSreekanth Reddy /* reset flag so SIGIO can restart */ 1167f92363d1SSreekanth Reddy ioc->aen_event_read_flag = 0; 1168f92363d1SSreekanth Reddy return 0; 1169f92363d1SSreekanth Reddy } 1170f92363d1SSreekanth Reddy 1171f92363d1SSreekanth Reddy /** 1172f92363d1SSreekanth Reddy * _ctl_do_reset - main handler for MPT3HARDRESET opcode 1173f92363d1SSreekanth Reddy * @ioc: per adapter object 1174f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1175f92363d1SSreekanth Reddy */ 1176f92363d1SSreekanth Reddy static long 1177f92363d1SSreekanth Reddy _ctl_do_reset(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1178f92363d1SSreekanth Reddy { 1179f92363d1SSreekanth Reddy struct mpt3_ioctl_diag_reset karg; 1180f92363d1SSreekanth Reddy int retval; 1181f92363d1SSreekanth Reddy 1182f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1183f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1184f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1185f92363d1SSreekanth Reddy return -EFAULT; 1186f92363d1SSreekanth Reddy } 1187f92363d1SSreekanth Reddy 1188f92363d1SSreekanth Reddy if (ioc->shost_recovery || ioc->pci_error_recovery || 1189f92363d1SSreekanth Reddy ioc->is_driver_loading) 1190f92363d1SSreekanth Reddy return -EAGAIN; 1191f92363d1SSreekanth Reddy 1192f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: enter\n", ioc->name, 1193f92363d1SSreekanth Reddy __func__)); 1194f92363d1SSreekanth Reddy 1195f92363d1SSreekanth Reddy retval = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 1196f92363d1SSreekanth Reddy FORCE_BIG_HAMMER); 1197f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "host reset: %s\n", 1198f92363d1SSreekanth Reddy ioc->name, ((!retval) ? "SUCCESS" : "FAILED")); 1199f92363d1SSreekanth Reddy return 0; 1200f92363d1SSreekanth Reddy } 1201f92363d1SSreekanth Reddy 1202f92363d1SSreekanth Reddy /** 1203f92363d1SSreekanth Reddy * _ctl_btdh_search_sas_device - searching for sas device 1204f92363d1SSreekanth Reddy * @ioc: per adapter object 1205f92363d1SSreekanth Reddy * @btdh: btdh ioctl payload 1206f92363d1SSreekanth Reddy */ 1207f92363d1SSreekanth Reddy static int 1208f92363d1SSreekanth Reddy _ctl_btdh_search_sas_device(struct MPT3SAS_ADAPTER *ioc, 1209f92363d1SSreekanth Reddy struct mpt3_ioctl_btdh_mapping *btdh) 1210f92363d1SSreekanth Reddy { 1211f92363d1SSreekanth Reddy struct _sas_device *sas_device; 1212f92363d1SSreekanth Reddy unsigned long flags; 1213f92363d1SSreekanth Reddy int rc = 0; 1214f92363d1SSreekanth Reddy 1215f92363d1SSreekanth Reddy if (list_empty(&ioc->sas_device_list)) 1216f92363d1SSreekanth Reddy return rc; 1217f92363d1SSreekanth Reddy 1218f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->sas_device_lock, flags); 1219f92363d1SSreekanth Reddy list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 1220f92363d1SSreekanth Reddy if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1221f92363d1SSreekanth Reddy btdh->handle == sas_device->handle) { 1222f92363d1SSreekanth Reddy btdh->bus = sas_device->channel; 1223f92363d1SSreekanth Reddy btdh->id = sas_device->id; 1224f92363d1SSreekanth Reddy rc = 1; 1225f92363d1SSreekanth Reddy goto out; 1226f92363d1SSreekanth Reddy } else if (btdh->bus == sas_device->channel && btdh->id == 1227f92363d1SSreekanth Reddy sas_device->id && btdh->handle == 0xFFFF) { 1228f92363d1SSreekanth Reddy btdh->handle = sas_device->handle; 1229f92363d1SSreekanth Reddy rc = 1; 1230f92363d1SSreekanth Reddy goto out; 1231f92363d1SSreekanth Reddy } 1232f92363d1SSreekanth Reddy } 1233f92363d1SSreekanth Reddy out: 1234f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1235f92363d1SSreekanth Reddy return rc; 1236f92363d1SSreekanth Reddy } 1237f92363d1SSreekanth Reddy 1238f92363d1SSreekanth Reddy /** 1239f92363d1SSreekanth Reddy * _ctl_btdh_search_raid_device - searching for raid device 1240f92363d1SSreekanth Reddy * @ioc: per adapter object 1241f92363d1SSreekanth Reddy * @btdh: btdh ioctl payload 1242f92363d1SSreekanth Reddy */ 1243f92363d1SSreekanth Reddy static int 1244f92363d1SSreekanth Reddy _ctl_btdh_search_raid_device(struct MPT3SAS_ADAPTER *ioc, 1245f92363d1SSreekanth Reddy struct mpt3_ioctl_btdh_mapping *btdh) 1246f92363d1SSreekanth Reddy { 1247f92363d1SSreekanth Reddy struct _raid_device *raid_device; 1248f92363d1SSreekanth Reddy unsigned long flags; 1249f92363d1SSreekanth Reddy int rc = 0; 1250f92363d1SSreekanth Reddy 1251f92363d1SSreekanth Reddy if (list_empty(&ioc->raid_device_list)) 1252f92363d1SSreekanth Reddy return rc; 1253f92363d1SSreekanth Reddy 1254f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->raid_device_lock, flags); 1255f92363d1SSreekanth Reddy list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 1256f92363d1SSreekanth Reddy if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF && 1257f92363d1SSreekanth Reddy btdh->handle == raid_device->handle) { 1258f92363d1SSreekanth Reddy btdh->bus = raid_device->channel; 1259f92363d1SSreekanth Reddy btdh->id = raid_device->id; 1260f92363d1SSreekanth Reddy rc = 1; 1261f92363d1SSreekanth Reddy goto out; 1262f92363d1SSreekanth Reddy } else if (btdh->bus == raid_device->channel && btdh->id == 1263f92363d1SSreekanth Reddy raid_device->id && btdh->handle == 0xFFFF) { 1264f92363d1SSreekanth Reddy btdh->handle = raid_device->handle; 1265f92363d1SSreekanth Reddy rc = 1; 1266f92363d1SSreekanth Reddy goto out; 1267f92363d1SSreekanth Reddy } 1268f92363d1SSreekanth Reddy } 1269f92363d1SSreekanth Reddy out: 1270f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1271f92363d1SSreekanth Reddy return rc; 1272f92363d1SSreekanth Reddy } 1273f92363d1SSreekanth Reddy 1274f92363d1SSreekanth Reddy /** 1275f92363d1SSreekanth Reddy * _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode 1276f92363d1SSreekanth Reddy * @ioc: per adapter object 1277f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1278f92363d1SSreekanth Reddy */ 1279f92363d1SSreekanth Reddy static long 1280f92363d1SSreekanth Reddy _ctl_btdh_mapping(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1281f92363d1SSreekanth Reddy { 1282f92363d1SSreekanth Reddy struct mpt3_ioctl_btdh_mapping karg; 1283f92363d1SSreekanth Reddy int rc; 1284f92363d1SSreekanth Reddy 1285f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1286f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1287f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1288f92363d1SSreekanth Reddy return -EFAULT; 1289f92363d1SSreekanth Reddy } 1290f92363d1SSreekanth Reddy 1291f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1292f92363d1SSreekanth Reddy __func__)); 1293f92363d1SSreekanth Reddy 1294f92363d1SSreekanth Reddy rc = _ctl_btdh_search_sas_device(ioc, &karg); 1295f92363d1SSreekanth Reddy if (!rc) 1296f92363d1SSreekanth Reddy _ctl_btdh_search_raid_device(ioc, &karg); 1297f92363d1SSreekanth Reddy 1298f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(karg))) { 1299f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1300f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1301f92363d1SSreekanth Reddy return -EFAULT; 1302f92363d1SSreekanth Reddy } 1303f92363d1SSreekanth Reddy return 0; 1304f92363d1SSreekanth Reddy } 1305f92363d1SSreekanth Reddy 1306f92363d1SSreekanth Reddy /** 1307f92363d1SSreekanth Reddy * _ctl_diag_capability - return diag buffer capability 1308f92363d1SSreekanth Reddy * @ioc: per adapter object 1309f92363d1SSreekanth Reddy * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED 1310f92363d1SSreekanth Reddy * 1311f92363d1SSreekanth Reddy * returns 1 when diag buffer support is enabled in firmware 1312f92363d1SSreekanth Reddy */ 1313f92363d1SSreekanth Reddy static u8 1314f92363d1SSreekanth Reddy _ctl_diag_capability(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type) 1315f92363d1SSreekanth Reddy { 1316f92363d1SSreekanth Reddy u8 rc = 0; 1317f92363d1SSreekanth Reddy 1318f92363d1SSreekanth Reddy switch (buffer_type) { 1319f92363d1SSreekanth Reddy case MPI2_DIAG_BUF_TYPE_TRACE: 1320f92363d1SSreekanth Reddy if (ioc->facts.IOCCapabilities & 1321f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER) 1322f92363d1SSreekanth Reddy rc = 1; 1323f92363d1SSreekanth Reddy break; 1324f92363d1SSreekanth Reddy case MPI2_DIAG_BUF_TYPE_SNAPSHOT: 1325f92363d1SSreekanth Reddy if (ioc->facts.IOCCapabilities & 1326f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER) 1327f92363d1SSreekanth Reddy rc = 1; 1328f92363d1SSreekanth Reddy break; 1329f92363d1SSreekanth Reddy case MPI2_DIAG_BUF_TYPE_EXTENDED: 1330f92363d1SSreekanth Reddy if (ioc->facts.IOCCapabilities & 1331f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) 1332f92363d1SSreekanth Reddy rc = 1; 1333f92363d1SSreekanth Reddy } 1334f92363d1SSreekanth Reddy 1335f92363d1SSreekanth Reddy return rc; 1336f92363d1SSreekanth Reddy } 1337f92363d1SSreekanth Reddy 1338f92363d1SSreekanth Reddy 1339f92363d1SSreekanth Reddy /** 1340f92363d1SSreekanth Reddy * _ctl_diag_register_2 - wrapper for registering diag buffer support 1341f92363d1SSreekanth Reddy * @ioc: per adapter object 1342f92363d1SSreekanth Reddy * @diag_register: the diag_register struct passed in from user space 1343f92363d1SSreekanth Reddy * 1344f92363d1SSreekanth Reddy */ 1345f92363d1SSreekanth Reddy static long 1346f92363d1SSreekanth Reddy _ctl_diag_register_2(struct MPT3SAS_ADAPTER *ioc, 1347f92363d1SSreekanth Reddy struct mpt3_diag_register *diag_register) 1348f92363d1SSreekanth Reddy { 1349f92363d1SSreekanth Reddy int rc, i; 1350f92363d1SSreekanth Reddy void *request_data = NULL; 1351f92363d1SSreekanth Reddy dma_addr_t request_data_dma; 1352f92363d1SSreekanth Reddy u32 request_data_sz = 0; 1353f92363d1SSreekanth Reddy Mpi2DiagBufferPostRequest_t *mpi_request; 1354f92363d1SSreekanth Reddy Mpi2DiagBufferPostReply_t *mpi_reply; 1355f92363d1SSreekanth Reddy u8 buffer_type; 1356f92363d1SSreekanth Reddy unsigned long timeleft; 1357f92363d1SSreekanth Reddy u16 smid; 1358f92363d1SSreekanth Reddy u16 ioc_status; 1359f92363d1SSreekanth Reddy u32 ioc_state; 1360f92363d1SSreekanth Reddy u8 issue_reset = 0; 1361f92363d1SSreekanth Reddy 1362f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1363f92363d1SSreekanth Reddy __func__)); 1364f92363d1SSreekanth Reddy 1365f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 1366f92363d1SSreekanth Reddy if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 1367f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1368f92363d1SSreekanth Reddy "%s: failed due to ioc not operational\n", 1369f92363d1SSreekanth Reddy ioc->name, __func__); 1370f92363d1SSreekanth Reddy rc = -EAGAIN; 1371f92363d1SSreekanth Reddy goto out; 1372f92363d1SSreekanth Reddy } 1373f92363d1SSreekanth Reddy 1374f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 1375f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 1376f92363d1SSreekanth Reddy ioc->name, __func__); 1377f92363d1SSreekanth Reddy rc = -EAGAIN; 1378f92363d1SSreekanth Reddy goto out; 1379f92363d1SSreekanth Reddy } 1380f92363d1SSreekanth Reddy 1381f92363d1SSreekanth Reddy buffer_type = diag_register->buffer_type; 1382f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1383f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1384f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1385f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1386f92363d1SSreekanth Reddy return -EPERM; 1387f92363d1SSreekanth Reddy } 1388f92363d1SSreekanth Reddy 1389f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & 1390f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) { 1391f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1392f92363d1SSreekanth Reddy "%s: already has a registered buffer for buffer_type(0x%02x)\n", 1393f92363d1SSreekanth Reddy ioc->name, __func__, 1394f92363d1SSreekanth Reddy buffer_type); 1395f92363d1SSreekanth Reddy return -EINVAL; 1396f92363d1SSreekanth Reddy } 1397f92363d1SSreekanth Reddy 1398f92363d1SSreekanth Reddy if (diag_register->requested_buffer_size % 4) { 1399f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1400f92363d1SSreekanth Reddy "%s: the requested_buffer_size is not 4 byte aligned\n", 1401f92363d1SSreekanth Reddy ioc->name, __func__); 1402f92363d1SSreekanth Reddy return -EINVAL; 1403f92363d1SSreekanth Reddy } 1404f92363d1SSreekanth Reddy 1405f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1406f92363d1SSreekanth Reddy if (!smid) { 1407f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 1408f92363d1SSreekanth Reddy ioc->name, __func__); 1409f92363d1SSreekanth Reddy rc = -EAGAIN; 1410f92363d1SSreekanth Reddy goto out; 1411f92363d1SSreekanth Reddy } 1412f92363d1SSreekanth Reddy 1413f92363d1SSreekanth Reddy rc = 0; 1414f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 1415f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1416f92363d1SSreekanth Reddy mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 1417f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 1418f92363d1SSreekanth Reddy 1419f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 1420f92363d1SSreekanth Reddy request_data_sz = diag_register->requested_buffer_size; 1421f92363d1SSreekanth Reddy ioc->unique_id[buffer_type] = diag_register->unique_id; 1422f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] = 0; 1423f92363d1SSreekanth Reddy memcpy(ioc->product_specific[buffer_type], 1424f92363d1SSreekanth Reddy diag_register->product_specific, MPT3_PRODUCT_SPECIFIC_DWORDS); 1425f92363d1SSreekanth Reddy ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags; 1426f92363d1SSreekanth Reddy 1427f92363d1SSreekanth Reddy if (request_data) { 1428f92363d1SSreekanth Reddy request_data_dma = ioc->diag_buffer_dma[buffer_type]; 1429f92363d1SSreekanth Reddy if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) { 1430f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, 1431f92363d1SSreekanth Reddy ioc->diag_buffer_sz[buffer_type], 1432f92363d1SSreekanth Reddy request_data, request_data_dma); 1433f92363d1SSreekanth Reddy request_data = NULL; 1434f92363d1SSreekanth Reddy } 1435f92363d1SSreekanth Reddy } 1436f92363d1SSreekanth Reddy 1437f92363d1SSreekanth Reddy if (request_data == NULL) { 1438f92363d1SSreekanth Reddy ioc->diag_buffer_sz[buffer_type] = 0; 1439f92363d1SSreekanth Reddy ioc->diag_buffer_dma[buffer_type] = 0; 1440f92363d1SSreekanth Reddy request_data = pci_alloc_consistent( 1441f92363d1SSreekanth Reddy ioc->pdev, request_data_sz, &request_data_dma); 1442f92363d1SSreekanth Reddy if (request_data == NULL) { 1443f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed allocating memory" \ 1444f92363d1SSreekanth Reddy " for diag buffers, requested size(%d)\n", 1445f92363d1SSreekanth Reddy ioc->name, __func__, request_data_sz); 1446f92363d1SSreekanth Reddy mpt3sas_base_free_smid(ioc, smid); 1447f92363d1SSreekanth Reddy return -ENOMEM; 1448f92363d1SSreekanth Reddy } 1449f92363d1SSreekanth Reddy ioc->diag_buffer[buffer_type] = request_data; 1450f92363d1SSreekanth Reddy ioc->diag_buffer_sz[buffer_type] = request_data_sz; 1451f92363d1SSreekanth Reddy ioc->diag_buffer_dma[buffer_type] = request_data_dma; 1452f92363d1SSreekanth Reddy } 1453f92363d1SSreekanth Reddy 1454f92363d1SSreekanth Reddy mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 1455f92363d1SSreekanth Reddy mpi_request->BufferType = diag_register->buffer_type; 1456f92363d1SSreekanth Reddy mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags); 1457f92363d1SSreekanth Reddy mpi_request->BufferAddress = cpu_to_le64(request_data_dma); 1458f92363d1SSreekanth Reddy mpi_request->BufferLength = cpu_to_le32(request_data_sz); 1459f92363d1SSreekanth Reddy mpi_request->VF_ID = 0; /* TODO */ 1460f92363d1SSreekanth Reddy mpi_request->VP_ID = 0; 1461f92363d1SSreekanth Reddy 1462f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 1463f92363d1SSreekanth Reddy "%s: diag_buffer(0x%p), dma(0x%llx), sz(%d)\n", 1464f92363d1SSreekanth Reddy ioc->name, __func__, request_data, 1465f92363d1SSreekanth Reddy (unsigned long long)request_data_dma, 1466f92363d1SSreekanth Reddy le32_to_cpu(mpi_request->BufferLength))); 1467f92363d1SSreekanth Reddy 1468f92363d1SSreekanth Reddy for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 1469f92363d1SSreekanth Reddy mpi_request->ProductSpecific[i] = 1470f92363d1SSreekanth Reddy cpu_to_le32(ioc->product_specific[buffer_type][i]); 1471f92363d1SSreekanth Reddy 1472f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 1473f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 1474f92363d1SSreekanth Reddy timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 1475f92363d1SSreekanth Reddy MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 1476f92363d1SSreekanth Reddy 1477f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 1478f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 1479f92363d1SSreekanth Reddy __func__); 1480f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, 1481f92363d1SSreekanth Reddy sizeof(Mpi2DiagBufferPostRequest_t)/4); 1482f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 1483f92363d1SSreekanth Reddy issue_reset = 1; 1484f92363d1SSreekanth Reddy goto issue_host_reset; 1485f92363d1SSreekanth Reddy } 1486f92363d1SSreekanth Reddy 1487f92363d1SSreekanth Reddy /* process the completed Reply Message Frame */ 1488f92363d1SSreekanth Reddy if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 1489f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: no reply message\n", 1490f92363d1SSreekanth Reddy ioc->name, __func__); 1491f92363d1SSreekanth Reddy rc = -EFAULT; 1492f92363d1SSreekanth Reddy goto out; 1493f92363d1SSreekanth Reddy } 1494f92363d1SSreekanth Reddy 1495f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 1496f92363d1SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1497f92363d1SSreekanth Reddy 1498f92363d1SSreekanth Reddy if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 1499f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 1500f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED; 1501f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n", 1502f92363d1SSreekanth Reddy ioc->name, __func__)); 1503f92363d1SSreekanth Reddy } else { 1504f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 1505f92363d1SSreekanth Reddy "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 1506f92363d1SSreekanth Reddy ioc->name, __func__, 1507f92363d1SSreekanth Reddy ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 1508f92363d1SSreekanth Reddy rc = -EFAULT; 1509f92363d1SSreekanth Reddy } 1510f92363d1SSreekanth Reddy 1511f92363d1SSreekanth Reddy issue_host_reset: 1512f92363d1SSreekanth Reddy if (issue_reset) 1513f92363d1SSreekanth Reddy mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 1514f92363d1SSreekanth Reddy FORCE_BIG_HAMMER); 1515f92363d1SSreekanth Reddy 1516f92363d1SSreekanth Reddy out: 1517f92363d1SSreekanth Reddy 1518f92363d1SSreekanth Reddy if (rc && request_data) 1519f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, request_data_sz, 1520f92363d1SSreekanth Reddy request_data, request_data_dma); 1521f92363d1SSreekanth Reddy 1522f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 1523f92363d1SSreekanth Reddy return rc; 1524f92363d1SSreekanth Reddy } 1525f92363d1SSreekanth Reddy 1526f92363d1SSreekanth Reddy /** 1527f92363d1SSreekanth Reddy * mpt3sas_enable_diag_buffer - enabling diag_buffers support driver load time 1528f92363d1SSreekanth Reddy * @ioc: per adapter object 1529f92363d1SSreekanth Reddy * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1 1530f92363d1SSreekanth Reddy * 1531f92363d1SSreekanth Reddy * This is called when command line option diag_buffer_enable is enabled 1532f92363d1SSreekanth Reddy * at driver load time. 1533f92363d1SSreekanth Reddy */ 1534f92363d1SSreekanth Reddy void 1535f92363d1SSreekanth Reddy mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER *ioc, u8 bits_to_register) 1536f92363d1SSreekanth Reddy { 1537f92363d1SSreekanth Reddy struct mpt3_diag_register diag_register; 1538f92363d1SSreekanth Reddy 1539f92363d1SSreekanth Reddy memset(&diag_register, 0, sizeof(struct mpt3_diag_register)); 1540f92363d1SSreekanth Reddy 1541f92363d1SSreekanth Reddy if (bits_to_register & 1) { 1542f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "registering trace buffer support\n", 1543f92363d1SSreekanth Reddy ioc->name); 1544f92363d1SSreekanth Reddy ioc->diag_trigger_master.MasterData = 1545f92363d1SSreekanth Reddy (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET); 1546f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 1547f92363d1SSreekanth Reddy /* register for 2MB buffers */ 1548f92363d1SSreekanth Reddy diag_register.requested_buffer_size = 2 * (1024 * 1024); 1549f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075900; 1550f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 1551f92363d1SSreekanth Reddy } 1552f92363d1SSreekanth Reddy 1553f92363d1SSreekanth Reddy if (bits_to_register & 2) { 1554f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "registering snapshot buffer support\n", 1555f92363d1SSreekanth Reddy ioc->name); 1556f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT; 1557f92363d1SSreekanth Reddy /* register for 2MB buffers */ 1558f92363d1SSreekanth Reddy diag_register.requested_buffer_size = 2 * (1024 * 1024); 1559f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075901; 1560f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 1561f92363d1SSreekanth Reddy } 1562f92363d1SSreekanth Reddy 1563f92363d1SSreekanth Reddy if (bits_to_register & 4) { 1564f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "registering extended buffer support\n", 1565f92363d1SSreekanth Reddy ioc->name); 1566f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED; 1567f92363d1SSreekanth Reddy /* register for 2MB buffers */ 1568f92363d1SSreekanth Reddy diag_register.requested_buffer_size = 2 * (1024 * 1024); 1569f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075901; 1570f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 1571f92363d1SSreekanth Reddy } 1572f92363d1SSreekanth Reddy } 1573f92363d1SSreekanth Reddy 1574f92363d1SSreekanth Reddy /** 1575f92363d1SSreekanth Reddy * _ctl_diag_register - application register with driver 1576f92363d1SSreekanth Reddy * @ioc: per adapter object 1577f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1578f92363d1SSreekanth Reddy * 1579f92363d1SSreekanth Reddy * This will allow the driver to setup any required buffers that will be 1580f92363d1SSreekanth Reddy * needed by firmware to communicate with the driver. 1581f92363d1SSreekanth Reddy */ 1582f92363d1SSreekanth Reddy static long 1583f92363d1SSreekanth Reddy _ctl_diag_register(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1584f92363d1SSreekanth Reddy { 1585f92363d1SSreekanth Reddy struct mpt3_diag_register karg; 1586f92363d1SSreekanth Reddy long rc; 1587f92363d1SSreekanth Reddy 1588f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1589f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1590f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1591f92363d1SSreekanth Reddy return -EFAULT; 1592f92363d1SSreekanth Reddy } 1593f92363d1SSreekanth Reddy 1594f92363d1SSreekanth Reddy rc = _ctl_diag_register_2(ioc, &karg); 1595f92363d1SSreekanth Reddy return rc; 1596f92363d1SSreekanth Reddy } 1597f92363d1SSreekanth Reddy 1598f92363d1SSreekanth Reddy /** 1599f92363d1SSreekanth Reddy * _ctl_diag_unregister - application unregister with driver 1600f92363d1SSreekanth Reddy * @ioc: per adapter object 1601f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1602f92363d1SSreekanth Reddy * 1603f92363d1SSreekanth Reddy * This will allow the driver to cleanup any memory allocated for diag 1604f92363d1SSreekanth Reddy * messages and to free up any resources. 1605f92363d1SSreekanth Reddy */ 1606f92363d1SSreekanth Reddy static long 1607f92363d1SSreekanth Reddy _ctl_diag_unregister(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1608f92363d1SSreekanth Reddy { 1609f92363d1SSreekanth Reddy struct mpt3_diag_unregister karg; 1610f92363d1SSreekanth Reddy void *request_data; 1611f92363d1SSreekanth Reddy dma_addr_t request_data_dma; 1612f92363d1SSreekanth Reddy u32 request_data_sz; 1613f92363d1SSreekanth Reddy u8 buffer_type; 1614f92363d1SSreekanth Reddy 1615f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1616f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1617f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1618f92363d1SSreekanth Reddy return -EFAULT; 1619f92363d1SSreekanth Reddy } 1620f92363d1SSreekanth Reddy 1621f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1622f92363d1SSreekanth Reddy __func__)); 1623f92363d1SSreekanth Reddy 1624f92363d1SSreekanth Reddy buffer_type = karg.unique_id & 0x000000ff; 1625f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1626f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1627f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1628f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1629f92363d1SSreekanth Reddy return -EPERM; 1630f92363d1SSreekanth Reddy } 1631f92363d1SSreekanth Reddy 1632f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1633f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 1634f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1635f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is not registered\n", 1636f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1637f92363d1SSreekanth Reddy return -EINVAL; 1638f92363d1SSreekanth Reddy } 1639f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1640f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) == 0) { 1641f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1642f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) has not been released\n", 1643f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1644f92363d1SSreekanth Reddy return -EINVAL; 1645f92363d1SSreekanth Reddy } 1646f92363d1SSreekanth Reddy 1647f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 1648f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1649f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 1650f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 1651f92363d1SSreekanth Reddy return -EINVAL; 1652f92363d1SSreekanth Reddy } 1653f92363d1SSreekanth Reddy 1654f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 1655f92363d1SSreekanth Reddy if (!request_data) { 1656f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1657f92363d1SSreekanth Reddy "%s: doesn't have memory allocated for buffer_type(0x%02x)\n", 1658f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1659f92363d1SSreekanth Reddy return -ENOMEM; 1660f92363d1SSreekanth Reddy } 1661f92363d1SSreekanth Reddy 1662f92363d1SSreekanth Reddy request_data_sz = ioc->diag_buffer_sz[buffer_type]; 1663f92363d1SSreekanth Reddy request_data_dma = ioc->diag_buffer_dma[buffer_type]; 1664f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, request_data_sz, 1665f92363d1SSreekanth Reddy request_data, request_data_dma); 1666f92363d1SSreekanth Reddy ioc->diag_buffer[buffer_type] = NULL; 1667f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] = 0; 1668f92363d1SSreekanth Reddy return 0; 1669f92363d1SSreekanth Reddy } 1670f92363d1SSreekanth Reddy 1671f92363d1SSreekanth Reddy /** 1672f92363d1SSreekanth Reddy * _ctl_diag_query - query relevant info associated with diag buffers 1673f92363d1SSreekanth Reddy * @ioc: per adapter object 1674f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1675f92363d1SSreekanth Reddy * 1676f92363d1SSreekanth Reddy * The application will send only buffer_type and unique_id. Driver will 1677f92363d1SSreekanth Reddy * inspect unique_id first, if valid, fill in all the info. If unique_id is 1678f92363d1SSreekanth Reddy * 0x00, the driver will return info specified by Buffer Type. 1679f92363d1SSreekanth Reddy */ 1680f92363d1SSreekanth Reddy static long 1681f92363d1SSreekanth Reddy _ctl_diag_query(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1682f92363d1SSreekanth Reddy { 1683f92363d1SSreekanth Reddy struct mpt3_diag_query karg; 1684f92363d1SSreekanth Reddy void *request_data; 1685f92363d1SSreekanth Reddy int i; 1686f92363d1SSreekanth Reddy u8 buffer_type; 1687f92363d1SSreekanth Reddy 1688f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1689f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1690f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1691f92363d1SSreekanth Reddy return -EFAULT; 1692f92363d1SSreekanth Reddy } 1693f92363d1SSreekanth Reddy 1694f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1695f92363d1SSreekanth Reddy __func__)); 1696f92363d1SSreekanth Reddy 1697f92363d1SSreekanth Reddy karg.application_flags = 0; 1698f92363d1SSreekanth Reddy buffer_type = karg.buffer_type; 1699f92363d1SSreekanth Reddy 1700f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1701f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1702f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1703f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1704f92363d1SSreekanth Reddy return -EPERM; 1705f92363d1SSreekanth Reddy } 1706f92363d1SSreekanth Reddy 1707f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1708f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 1709f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1710f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is not registered\n", 1711f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1712f92363d1SSreekanth Reddy return -EINVAL; 1713f92363d1SSreekanth Reddy } 1714f92363d1SSreekanth Reddy 1715f92363d1SSreekanth Reddy if (karg.unique_id & 0xffffff00) { 1716f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 1717f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1718f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 1719f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 1720f92363d1SSreekanth Reddy return -EINVAL; 1721f92363d1SSreekanth Reddy } 1722f92363d1SSreekanth Reddy } 1723f92363d1SSreekanth Reddy 1724f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 1725f92363d1SSreekanth Reddy if (!request_data) { 1726f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1727f92363d1SSreekanth Reddy "%s: doesn't have buffer for buffer_type(0x%02x)\n", 1728f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1729f92363d1SSreekanth Reddy return -ENOMEM; 1730f92363d1SSreekanth Reddy } 1731f92363d1SSreekanth Reddy 1732f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & MPT3_DIAG_BUFFER_IS_RELEASED) 1733f92363d1SSreekanth Reddy karg.application_flags = (MPT3_APP_FLAGS_APP_OWNED | 1734f92363d1SSreekanth Reddy MPT3_APP_FLAGS_BUFFER_VALID); 1735f92363d1SSreekanth Reddy else 1736f92363d1SSreekanth Reddy karg.application_flags = (MPT3_APP_FLAGS_APP_OWNED | 1737f92363d1SSreekanth Reddy MPT3_APP_FLAGS_BUFFER_VALID | 1738f92363d1SSreekanth Reddy MPT3_APP_FLAGS_FW_BUFFER_ACCESS); 1739f92363d1SSreekanth Reddy 1740f92363d1SSreekanth Reddy for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 1741f92363d1SSreekanth Reddy karg.product_specific[i] = 1742f92363d1SSreekanth Reddy ioc->product_specific[buffer_type][i]; 1743f92363d1SSreekanth Reddy 1744f92363d1SSreekanth Reddy karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type]; 1745f92363d1SSreekanth Reddy karg.driver_added_buffer_size = 0; 1746f92363d1SSreekanth Reddy karg.unique_id = ioc->unique_id[buffer_type]; 1747f92363d1SSreekanth Reddy karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type]; 1748f92363d1SSreekanth Reddy 1749f92363d1SSreekanth Reddy if (copy_to_user(arg, &karg, sizeof(struct mpt3_diag_query))) { 1750f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1751f92363d1SSreekanth Reddy "%s: unable to write mpt3_diag_query data @ %p\n", 1752f92363d1SSreekanth Reddy ioc->name, __func__, arg); 1753f92363d1SSreekanth Reddy return -EFAULT; 1754f92363d1SSreekanth Reddy } 1755f92363d1SSreekanth Reddy return 0; 1756f92363d1SSreekanth Reddy } 1757f92363d1SSreekanth Reddy 1758f92363d1SSreekanth Reddy /** 1759f92363d1SSreekanth Reddy * mpt3sas_send_diag_release - Diag Release Message 1760f92363d1SSreekanth Reddy * @ioc: per adapter object 1761f92363d1SSreekanth Reddy * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED 1762f92363d1SSreekanth Reddy * @issue_reset - specifies whether host reset is required. 1763f92363d1SSreekanth Reddy * 1764f92363d1SSreekanth Reddy */ 1765f92363d1SSreekanth Reddy int 1766f92363d1SSreekanth Reddy mpt3sas_send_diag_release(struct MPT3SAS_ADAPTER *ioc, u8 buffer_type, 1767f92363d1SSreekanth Reddy u8 *issue_reset) 1768f92363d1SSreekanth Reddy { 1769f92363d1SSreekanth Reddy Mpi2DiagReleaseRequest_t *mpi_request; 1770f92363d1SSreekanth Reddy Mpi2DiagReleaseReply_t *mpi_reply; 1771f92363d1SSreekanth Reddy u16 smid; 1772f92363d1SSreekanth Reddy u16 ioc_status; 1773f92363d1SSreekanth Reddy u32 ioc_state; 1774f92363d1SSreekanth Reddy int rc; 1775f92363d1SSreekanth Reddy unsigned long timeleft; 1776f92363d1SSreekanth Reddy 1777f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1778f92363d1SSreekanth Reddy __func__)); 1779f92363d1SSreekanth Reddy 1780f92363d1SSreekanth Reddy rc = 0; 1781f92363d1SSreekanth Reddy *issue_reset = 0; 1782f92363d1SSreekanth Reddy 1783f92363d1SSreekanth Reddy ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 1784f92363d1SSreekanth Reddy if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 1785f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & 1786f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) 1787f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 1788f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED; 1789f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 1790f92363d1SSreekanth Reddy "%s: skipping due to FAULT state\n", ioc->name, 1791f92363d1SSreekanth Reddy __func__)); 1792f92363d1SSreekanth Reddy rc = -EAGAIN; 1793f92363d1SSreekanth Reddy goto out; 1794f92363d1SSreekanth Reddy } 1795f92363d1SSreekanth Reddy 1796f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 1797f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 1798f92363d1SSreekanth Reddy ioc->name, __func__); 1799f92363d1SSreekanth Reddy rc = -EAGAIN; 1800f92363d1SSreekanth Reddy goto out; 1801f92363d1SSreekanth Reddy } 1802f92363d1SSreekanth Reddy 1803f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 1804f92363d1SSreekanth Reddy if (!smid) { 1805f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 1806f92363d1SSreekanth Reddy ioc->name, __func__); 1807f92363d1SSreekanth Reddy rc = -EAGAIN; 1808f92363d1SSreekanth Reddy goto out; 1809f92363d1SSreekanth Reddy } 1810f92363d1SSreekanth Reddy 1811f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 1812f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 1813f92363d1SSreekanth Reddy mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 1814f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 1815f92363d1SSreekanth Reddy 1816f92363d1SSreekanth Reddy mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE; 1817f92363d1SSreekanth Reddy mpi_request->BufferType = buffer_type; 1818f92363d1SSreekanth Reddy mpi_request->VF_ID = 0; /* TODO */ 1819f92363d1SSreekanth Reddy mpi_request->VP_ID = 0; 1820f92363d1SSreekanth Reddy 1821f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 1822f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 1823f92363d1SSreekanth Reddy timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 1824f92363d1SSreekanth Reddy MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 1825f92363d1SSreekanth Reddy 1826f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 1827f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 1828f92363d1SSreekanth Reddy __func__); 1829f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, 1830f92363d1SSreekanth Reddy sizeof(Mpi2DiagReleaseRequest_t)/4); 1831f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 1832f92363d1SSreekanth Reddy *issue_reset = 1; 1833f92363d1SSreekanth Reddy rc = -EFAULT; 1834f92363d1SSreekanth Reddy goto out; 1835f92363d1SSreekanth Reddy } 1836f92363d1SSreekanth Reddy 1837f92363d1SSreekanth Reddy /* process the completed Reply Message Frame */ 1838f92363d1SSreekanth Reddy if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 1839f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: no reply message\n", 1840f92363d1SSreekanth Reddy ioc->name, __func__); 1841f92363d1SSreekanth Reddy rc = -EFAULT; 1842f92363d1SSreekanth Reddy goto out; 1843f92363d1SSreekanth Reddy } 1844f92363d1SSreekanth Reddy 1845f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 1846f92363d1SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1847f92363d1SSreekanth Reddy 1848f92363d1SSreekanth Reddy if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 1849f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 1850f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED; 1851f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n", 1852f92363d1SSreekanth Reddy ioc->name, __func__)); 1853f92363d1SSreekanth Reddy } else { 1854f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 1855f92363d1SSreekanth Reddy "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 1856f92363d1SSreekanth Reddy ioc->name, __func__, 1857f92363d1SSreekanth Reddy ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 1858f92363d1SSreekanth Reddy rc = -EFAULT; 1859f92363d1SSreekanth Reddy } 1860f92363d1SSreekanth Reddy 1861f92363d1SSreekanth Reddy out: 1862f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 1863f92363d1SSreekanth Reddy return rc; 1864f92363d1SSreekanth Reddy } 1865f92363d1SSreekanth Reddy 1866f92363d1SSreekanth Reddy /** 1867f92363d1SSreekanth Reddy * _ctl_diag_release - request to send Diag Release Message to firmware 1868f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1869f92363d1SSreekanth Reddy * 1870f92363d1SSreekanth Reddy * This allows ownership of the specified buffer to returned to the driver, 1871f92363d1SSreekanth Reddy * allowing an application to read the buffer without fear that firmware is 1872f92363d1SSreekanth Reddy * overwritting information in the buffer. 1873f92363d1SSreekanth Reddy */ 1874f92363d1SSreekanth Reddy static long 1875f92363d1SSreekanth Reddy _ctl_diag_release(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1876f92363d1SSreekanth Reddy { 1877f92363d1SSreekanth Reddy struct mpt3_diag_release karg; 1878f92363d1SSreekanth Reddy void *request_data; 1879f92363d1SSreekanth Reddy int rc; 1880f92363d1SSreekanth Reddy u8 buffer_type; 1881f92363d1SSreekanth Reddy u8 issue_reset = 0; 1882f92363d1SSreekanth Reddy 1883f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1884f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1885f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1886f92363d1SSreekanth Reddy return -EFAULT; 1887f92363d1SSreekanth Reddy } 1888f92363d1SSreekanth Reddy 1889f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1890f92363d1SSreekanth Reddy __func__)); 1891f92363d1SSreekanth Reddy 1892f92363d1SSreekanth Reddy buffer_type = karg.unique_id & 0x000000ff; 1893f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1894f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1895f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1896f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1897f92363d1SSreekanth Reddy return -EPERM; 1898f92363d1SSreekanth Reddy } 1899f92363d1SSreekanth Reddy 1900f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1901f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 1902f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1903f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is not registered\n", 1904f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1905f92363d1SSreekanth Reddy return -EINVAL; 1906f92363d1SSreekanth Reddy } 1907f92363d1SSreekanth Reddy 1908f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 1909f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1910f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 1911f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 1912f92363d1SSreekanth Reddy return -EINVAL; 1913f92363d1SSreekanth Reddy } 1914f92363d1SSreekanth Reddy 1915f92363d1SSreekanth Reddy if (ioc->diag_buffer_status[buffer_type] & 1916f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) { 1917f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1918f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is already released\n", 1919f92363d1SSreekanth Reddy ioc->name, __func__, 1920f92363d1SSreekanth Reddy buffer_type); 1921f92363d1SSreekanth Reddy return 0; 1922f92363d1SSreekanth Reddy } 1923f92363d1SSreekanth Reddy 1924f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 1925f92363d1SSreekanth Reddy 1926f92363d1SSreekanth Reddy if (!request_data) { 1927f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1928f92363d1SSreekanth Reddy "%s: doesn't have memory allocated for buffer_type(0x%02x)\n", 1929f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1930f92363d1SSreekanth Reddy return -ENOMEM; 1931f92363d1SSreekanth Reddy } 1932f92363d1SSreekanth Reddy 1933f92363d1SSreekanth Reddy /* buffers were released by due to host reset */ 1934f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 1935f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_DIAG_RESET)) { 1936f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 1937f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED; 1938f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] &= 1939f92363d1SSreekanth Reddy ~MPT3_DIAG_BUFFER_IS_DIAG_RESET; 1940f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1941f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) was released due to host reset\n", 1942f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1943f92363d1SSreekanth Reddy return 0; 1944f92363d1SSreekanth Reddy } 1945f92363d1SSreekanth Reddy 1946f92363d1SSreekanth Reddy rc = mpt3sas_send_diag_release(ioc, buffer_type, &issue_reset); 1947f92363d1SSreekanth Reddy 1948f92363d1SSreekanth Reddy if (issue_reset) 1949f92363d1SSreekanth Reddy mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 1950f92363d1SSreekanth Reddy FORCE_BIG_HAMMER); 1951f92363d1SSreekanth Reddy 1952f92363d1SSreekanth Reddy return rc; 1953f92363d1SSreekanth Reddy } 1954f92363d1SSreekanth Reddy 1955f92363d1SSreekanth Reddy /** 1956f92363d1SSreekanth Reddy * _ctl_diag_read_buffer - request for copy of the diag buffer 1957f92363d1SSreekanth Reddy * @ioc: per adapter object 1958f92363d1SSreekanth Reddy * @arg - user space buffer containing ioctl content 1959f92363d1SSreekanth Reddy */ 1960f92363d1SSreekanth Reddy static long 1961f92363d1SSreekanth Reddy _ctl_diag_read_buffer(struct MPT3SAS_ADAPTER *ioc, void __user *arg) 1962f92363d1SSreekanth Reddy { 1963f92363d1SSreekanth Reddy struct mpt3_diag_read_buffer karg; 1964f92363d1SSreekanth Reddy struct mpt3_diag_read_buffer __user *uarg = arg; 1965f92363d1SSreekanth Reddy void *request_data, *diag_data; 1966f92363d1SSreekanth Reddy Mpi2DiagBufferPostRequest_t *mpi_request; 1967f92363d1SSreekanth Reddy Mpi2DiagBufferPostReply_t *mpi_reply; 1968f92363d1SSreekanth Reddy int rc, i; 1969f92363d1SSreekanth Reddy u8 buffer_type; 1970f92363d1SSreekanth Reddy unsigned long timeleft, request_size, copy_size; 1971f92363d1SSreekanth Reddy u16 smid; 1972f92363d1SSreekanth Reddy u16 ioc_status; 1973f92363d1SSreekanth Reddy u8 issue_reset = 0; 1974f92363d1SSreekanth Reddy 1975f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 1976f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 1977f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 1978f92363d1SSreekanth Reddy return -EFAULT; 1979f92363d1SSreekanth Reddy } 1980f92363d1SSreekanth Reddy 1981f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name, 1982f92363d1SSreekanth Reddy __func__)); 1983f92363d1SSreekanth Reddy 1984f92363d1SSreekanth Reddy buffer_type = karg.unique_id & 0x000000ff; 1985f92363d1SSreekanth Reddy if (!_ctl_diag_capability(ioc, buffer_type)) { 1986f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1987f92363d1SSreekanth Reddy "%s: doesn't have capability for buffer_type(0x%02x)\n", 1988f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 1989f92363d1SSreekanth Reddy return -EPERM; 1990f92363d1SSreekanth Reddy } 1991f92363d1SSreekanth Reddy 1992f92363d1SSreekanth Reddy if (karg.unique_id != ioc->unique_id[buffer_type]) { 1993f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 1994f92363d1SSreekanth Reddy "%s: unique_id(0x%08x) is not registered\n", 1995f92363d1SSreekanth Reddy ioc->name, __func__, karg.unique_id); 1996f92363d1SSreekanth Reddy return -EINVAL; 1997f92363d1SSreekanth Reddy } 1998f92363d1SSreekanth Reddy 1999f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[buffer_type]; 2000f92363d1SSreekanth Reddy if (!request_data) { 2001f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2002f92363d1SSreekanth Reddy "%s: doesn't have buffer for buffer_type(0x%02x)\n", 2003f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type); 2004f92363d1SSreekanth Reddy return -ENOMEM; 2005f92363d1SSreekanth Reddy } 2006f92363d1SSreekanth Reddy 2007f92363d1SSreekanth Reddy request_size = ioc->diag_buffer_sz[buffer_type]; 2008f92363d1SSreekanth Reddy 2009f92363d1SSreekanth Reddy if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) { 2010f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: either the starting_offset " \ 2011f92363d1SSreekanth Reddy "or bytes_to_read are not 4 byte aligned\n", ioc->name, 2012f92363d1SSreekanth Reddy __func__); 2013f92363d1SSreekanth Reddy return -EINVAL; 2014f92363d1SSreekanth Reddy } 2015f92363d1SSreekanth Reddy 2016f92363d1SSreekanth Reddy if (karg.starting_offset > request_size) 2017f92363d1SSreekanth Reddy return -EINVAL; 2018f92363d1SSreekanth Reddy 2019f92363d1SSreekanth Reddy diag_data = (void *)(request_data + karg.starting_offset); 2020f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2021f92363d1SSreekanth Reddy "%s: diag_buffer(%p), offset(%d), sz(%d)\n", 2022f92363d1SSreekanth Reddy ioc->name, __func__, 2023f92363d1SSreekanth Reddy diag_data, karg.starting_offset, karg.bytes_to_read)); 2024f92363d1SSreekanth Reddy 2025f92363d1SSreekanth Reddy /* Truncate data on requests that are too large */ 2026f92363d1SSreekanth Reddy if ((diag_data + karg.bytes_to_read < diag_data) || 2027f92363d1SSreekanth Reddy (diag_data + karg.bytes_to_read > request_data + request_size)) 2028f92363d1SSreekanth Reddy copy_size = request_size - karg.starting_offset; 2029f92363d1SSreekanth Reddy else 2030f92363d1SSreekanth Reddy copy_size = karg.bytes_to_read; 2031f92363d1SSreekanth Reddy 2032f92363d1SSreekanth Reddy if (copy_to_user((void __user *)uarg->diagnostic_data, 2033f92363d1SSreekanth Reddy diag_data, copy_size)) { 2034f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2035f92363d1SSreekanth Reddy "%s: Unable to write mpt_diag_read_buffer_t data @ %p\n", 2036f92363d1SSreekanth Reddy ioc->name, __func__, diag_data); 2037f92363d1SSreekanth Reddy return -EFAULT; 2038f92363d1SSreekanth Reddy } 2039f92363d1SSreekanth Reddy 2040f92363d1SSreekanth Reddy if ((karg.flags & MPT3_FLAGS_REREGISTER) == 0) 2041f92363d1SSreekanth Reddy return 0; 2042f92363d1SSreekanth Reddy 2043f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2044f92363d1SSreekanth Reddy "%s: Reregister buffer_type(0x%02x)\n", 2045f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type)); 2046f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[buffer_type] & 2047f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) == 0) { 2048f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2049f92363d1SSreekanth Reddy "%s: buffer_type(0x%02x) is still registered\n", 2050f92363d1SSreekanth Reddy ioc->name, __func__, buffer_type)); 2051f92363d1SSreekanth Reddy return 0; 2052f92363d1SSreekanth Reddy } 2053f92363d1SSreekanth Reddy /* Get a free request frame and save the message context. 2054f92363d1SSreekanth Reddy */ 2055f92363d1SSreekanth Reddy 2056f92363d1SSreekanth Reddy if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) { 2057f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: ctl_cmd in use\n", 2058f92363d1SSreekanth Reddy ioc->name, __func__); 2059f92363d1SSreekanth Reddy rc = -EAGAIN; 2060f92363d1SSreekanth Reddy goto out; 2061f92363d1SSreekanth Reddy } 2062f92363d1SSreekanth Reddy 2063f92363d1SSreekanth Reddy smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); 2064f92363d1SSreekanth Reddy if (!smid) { 2065f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 2066f92363d1SSreekanth Reddy ioc->name, __func__); 2067f92363d1SSreekanth Reddy rc = -EAGAIN; 2068f92363d1SSreekanth Reddy goto out; 2069f92363d1SSreekanth Reddy } 2070f92363d1SSreekanth Reddy 2071f92363d1SSreekanth Reddy rc = 0; 2072f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_PENDING; 2073f92363d1SSreekanth Reddy memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz); 2074f92363d1SSreekanth Reddy mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 2075f92363d1SSreekanth Reddy ioc->ctl_cmds.smid = smid; 2076f92363d1SSreekanth Reddy 2077f92363d1SSreekanth Reddy mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 2078f92363d1SSreekanth Reddy mpi_request->BufferType = buffer_type; 2079f92363d1SSreekanth Reddy mpi_request->BufferLength = 2080f92363d1SSreekanth Reddy cpu_to_le32(ioc->diag_buffer_sz[buffer_type]); 2081f92363d1SSreekanth Reddy mpi_request->BufferAddress = 2082f92363d1SSreekanth Reddy cpu_to_le64(ioc->diag_buffer_dma[buffer_type]); 2083f92363d1SSreekanth Reddy for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++) 2084f92363d1SSreekanth Reddy mpi_request->ProductSpecific[i] = 2085f92363d1SSreekanth Reddy cpu_to_le32(ioc->product_specific[buffer_type][i]); 2086f92363d1SSreekanth Reddy mpi_request->VF_ID = 0; /* TODO */ 2087f92363d1SSreekanth Reddy mpi_request->VP_ID = 0; 2088f92363d1SSreekanth Reddy 2089f92363d1SSreekanth Reddy init_completion(&ioc->ctl_cmds.done); 2090f92363d1SSreekanth Reddy mpt3sas_base_put_smid_default(ioc, smid); 2091f92363d1SSreekanth Reddy timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done, 2092f92363d1SSreekanth Reddy MPT3_IOCTL_DEFAULT_TIMEOUT*HZ); 2093f92363d1SSreekanth Reddy 2094f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_COMPLETE)) { 2095f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: timeout\n", ioc->name, 2096f92363d1SSreekanth Reddy __func__); 2097f92363d1SSreekanth Reddy _debug_dump_mf(mpi_request, 2098f92363d1SSreekanth Reddy sizeof(Mpi2DiagBufferPostRequest_t)/4); 2099f92363d1SSreekanth Reddy if (!(ioc->ctl_cmds.status & MPT3_CMD_RESET)) 2100f92363d1SSreekanth Reddy issue_reset = 1; 2101f92363d1SSreekanth Reddy goto issue_host_reset; 2102f92363d1SSreekanth Reddy } 2103f92363d1SSreekanth Reddy 2104f92363d1SSreekanth Reddy /* process the completed Reply Message Frame */ 2105f92363d1SSreekanth Reddy if ((ioc->ctl_cmds.status & MPT3_CMD_REPLY_VALID) == 0) { 2106f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: no reply message\n", 2107f92363d1SSreekanth Reddy ioc->name, __func__); 2108f92363d1SSreekanth Reddy rc = -EFAULT; 2109f92363d1SSreekanth Reddy goto out; 2110f92363d1SSreekanth Reddy } 2111f92363d1SSreekanth Reddy 2112f92363d1SSreekanth Reddy mpi_reply = ioc->ctl_cmds.reply; 2113f92363d1SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 2114f92363d1SSreekanth Reddy 2115f92363d1SSreekanth Reddy if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 2116f92363d1SSreekanth Reddy ioc->diag_buffer_status[buffer_type] |= 2117f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED; 2118f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT "%s: success\n", 2119f92363d1SSreekanth Reddy ioc->name, __func__)); 2120f92363d1SSreekanth Reddy } else { 2121f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT 2122f92363d1SSreekanth Reddy "%s: ioc_status(0x%04x) log_info(0x%08x)\n", 2123f92363d1SSreekanth Reddy ioc->name, __func__, 2124f92363d1SSreekanth Reddy ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo)); 2125f92363d1SSreekanth Reddy rc = -EFAULT; 2126f92363d1SSreekanth Reddy } 2127f92363d1SSreekanth Reddy 2128f92363d1SSreekanth Reddy issue_host_reset: 2129f92363d1SSreekanth Reddy if (issue_reset) 2130f92363d1SSreekanth Reddy mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 2131f92363d1SSreekanth Reddy FORCE_BIG_HAMMER); 2132f92363d1SSreekanth Reddy 2133f92363d1SSreekanth Reddy out: 2134f92363d1SSreekanth Reddy 2135f92363d1SSreekanth Reddy ioc->ctl_cmds.status = MPT3_CMD_NOT_USED; 2136f92363d1SSreekanth Reddy return rc; 2137f92363d1SSreekanth Reddy } 2138f92363d1SSreekanth Reddy 2139f92363d1SSreekanth Reddy 2140f92363d1SSreekanth Reddy 2141f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2142f92363d1SSreekanth Reddy /** 2143f92363d1SSreekanth Reddy * _ctl_compat_mpt_command - convert 32bit pointers to 64bit. 2144f92363d1SSreekanth Reddy * @ioc: per adapter object 2145f92363d1SSreekanth Reddy * @cmd - ioctl opcode 2146f92363d1SSreekanth Reddy * @arg - (struct mpt3_ioctl_command32) 2147f92363d1SSreekanth Reddy * 2148f92363d1SSreekanth Reddy * MPT3COMMAND32 - Handle 32bit applications running on 64bit os. 2149f92363d1SSreekanth Reddy */ 2150f92363d1SSreekanth Reddy static long 2151f92363d1SSreekanth Reddy _ctl_compat_mpt_command(struct MPT3SAS_ADAPTER *ioc, unsigned cmd, 2152f92363d1SSreekanth Reddy void __user *arg) 2153f92363d1SSreekanth Reddy { 2154f92363d1SSreekanth Reddy struct mpt3_ioctl_command32 karg32; 2155f92363d1SSreekanth Reddy struct mpt3_ioctl_command32 __user *uarg; 2156f92363d1SSreekanth Reddy struct mpt3_ioctl_command karg; 2157f92363d1SSreekanth Reddy 2158f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) != sizeof(struct mpt3_ioctl_command32)) 2159f92363d1SSreekanth Reddy return -EINVAL; 2160f92363d1SSreekanth Reddy 2161f92363d1SSreekanth Reddy uarg = (struct mpt3_ioctl_command32 __user *) arg; 2162f92363d1SSreekanth Reddy 2163f92363d1SSreekanth Reddy if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) { 2164f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 2165f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 2166f92363d1SSreekanth Reddy return -EFAULT; 2167f92363d1SSreekanth Reddy } 2168f92363d1SSreekanth Reddy 2169f92363d1SSreekanth Reddy memset(&karg, 0, sizeof(struct mpt3_ioctl_command)); 2170f92363d1SSreekanth Reddy karg.hdr.ioc_number = karg32.hdr.ioc_number; 2171f92363d1SSreekanth Reddy karg.hdr.port_number = karg32.hdr.port_number; 2172f92363d1SSreekanth Reddy karg.hdr.max_data_size = karg32.hdr.max_data_size; 2173f92363d1SSreekanth Reddy karg.timeout = karg32.timeout; 2174f92363d1SSreekanth Reddy karg.max_reply_bytes = karg32.max_reply_bytes; 2175f92363d1SSreekanth Reddy karg.data_in_size = karg32.data_in_size; 2176f92363d1SSreekanth Reddy karg.data_out_size = karg32.data_out_size; 2177f92363d1SSreekanth Reddy karg.max_sense_bytes = karg32.max_sense_bytes; 2178f92363d1SSreekanth Reddy karg.data_sge_offset = karg32.data_sge_offset; 2179f92363d1SSreekanth Reddy karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr); 2180f92363d1SSreekanth Reddy karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr); 2181f92363d1SSreekanth Reddy karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr); 2182f92363d1SSreekanth Reddy karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr); 2183f92363d1SSreekanth Reddy return _ctl_do_mpt_command(ioc, karg, &uarg->mf); 2184f92363d1SSreekanth Reddy } 2185f92363d1SSreekanth Reddy #endif 2186f92363d1SSreekanth Reddy 2187f92363d1SSreekanth Reddy /** 2188f92363d1SSreekanth Reddy * _ctl_ioctl_main - main ioctl entry point 2189f92363d1SSreekanth Reddy * @file - (struct file) 2190f92363d1SSreekanth Reddy * @cmd - ioctl opcode 2191f92363d1SSreekanth Reddy * @arg - 2192f92363d1SSreekanth Reddy * compat - handles 32 bit applications in 64bit os 2193f92363d1SSreekanth Reddy */ 2194f92363d1SSreekanth Reddy static long 2195f92363d1SSreekanth Reddy _ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg, 2196f92363d1SSreekanth Reddy u8 compat) 2197f92363d1SSreekanth Reddy { 2198f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 2199f92363d1SSreekanth Reddy struct mpt3_ioctl_header ioctl_header; 2200f92363d1SSreekanth Reddy enum block_state state; 2201f92363d1SSreekanth Reddy long ret = -EINVAL; 2202f92363d1SSreekanth Reddy 2203f92363d1SSreekanth Reddy /* get IOCTL header */ 2204f92363d1SSreekanth Reddy if (copy_from_user(&ioctl_header, (char __user *)arg, 2205f92363d1SSreekanth Reddy sizeof(struct mpt3_ioctl_header))) { 2206f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 2207f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 2208f92363d1SSreekanth Reddy return -EFAULT; 2209f92363d1SSreekanth Reddy } 2210f92363d1SSreekanth Reddy 2211f92363d1SSreekanth Reddy if (_ctl_verify_adapter(ioctl_header.ioc_number, &ioc) == -1 || !ioc) 2212f92363d1SSreekanth Reddy return -ENODEV; 2213f92363d1SSreekanth Reddy 2214f92363d1SSreekanth Reddy if (ioc->shost_recovery || ioc->pci_error_recovery || 2215f92363d1SSreekanth Reddy ioc->is_driver_loading) 2216f92363d1SSreekanth Reddy return -EAGAIN; 2217f92363d1SSreekanth Reddy 2218f92363d1SSreekanth Reddy state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING; 2219f92363d1SSreekanth Reddy if (state == NON_BLOCKING) { 2220f92363d1SSreekanth Reddy if (!mutex_trylock(&ioc->ctl_cmds.mutex)) 2221f92363d1SSreekanth Reddy return -EAGAIN; 2222f92363d1SSreekanth Reddy } else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex)) 2223f92363d1SSreekanth Reddy return -ERESTARTSYS; 2224f92363d1SSreekanth Reddy 2225f92363d1SSreekanth Reddy 2226f92363d1SSreekanth Reddy switch (cmd) { 2227f92363d1SSreekanth Reddy case MPT3IOCINFO: 2228f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_iocinfo)) 2229f92363d1SSreekanth Reddy ret = _ctl_getiocinfo(ioc, arg); 2230f92363d1SSreekanth Reddy break; 2231f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2232f92363d1SSreekanth Reddy case MPT3COMMAND32: 2233f92363d1SSreekanth Reddy #endif 2234f92363d1SSreekanth Reddy case MPT3COMMAND: 2235f92363d1SSreekanth Reddy { 2236f92363d1SSreekanth Reddy struct mpt3_ioctl_command __user *uarg; 2237f92363d1SSreekanth Reddy struct mpt3_ioctl_command karg; 2238f92363d1SSreekanth Reddy 2239f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2240f92363d1SSreekanth Reddy if (compat) { 2241f92363d1SSreekanth Reddy ret = _ctl_compat_mpt_command(ioc, cmd, arg); 2242f92363d1SSreekanth Reddy break; 2243f92363d1SSreekanth Reddy } 2244f92363d1SSreekanth Reddy #endif 2245f92363d1SSreekanth Reddy if (copy_from_user(&karg, arg, sizeof(karg))) { 2246f92363d1SSreekanth Reddy pr_err("failure at %s:%d/%s()!\n", 2247f92363d1SSreekanth Reddy __FILE__, __LINE__, __func__); 2248f92363d1SSreekanth Reddy ret = -EFAULT; 2249f92363d1SSreekanth Reddy break; 2250f92363d1SSreekanth Reddy } 2251f92363d1SSreekanth Reddy 2252f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_command)) { 2253f92363d1SSreekanth Reddy uarg = arg; 2254f92363d1SSreekanth Reddy ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf); 2255f92363d1SSreekanth Reddy } 2256f92363d1SSreekanth Reddy break; 2257f92363d1SSreekanth Reddy } 2258f92363d1SSreekanth Reddy case MPT3EVENTQUERY: 2259f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventquery)) 2260f92363d1SSreekanth Reddy ret = _ctl_eventquery(ioc, arg); 2261f92363d1SSreekanth Reddy break; 2262f92363d1SSreekanth Reddy case MPT3EVENTENABLE: 2263f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_eventenable)) 2264f92363d1SSreekanth Reddy ret = _ctl_eventenable(ioc, arg); 2265f92363d1SSreekanth Reddy break; 2266f92363d1SSreekanth Reddy case MPT3EVENTREPORT: 2267f92363d1SSreekanth Reddy ret = _ctl_eventreport(ioc, arg); 2268f92363d1SSreekanth Reddy break; 2269f92363d1SSreekanth Reddy case MPT3HARDRESET: 2270f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_diag_reset)) 2271f92363d1SSreekanth Reddy ret = _ctl_do_reset(ioc, arg); 2272f92363d1SSreekanth Reddy break; 2273f92363d1SSreekanth Reddy case MPT3BTDHMAPPING: 2274f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_ioctl_btdh_mapping)) 2275f92363d1SSreekanth Reddy ret = _ctl_btdh_mapping(ioc, arg); 2276f92363d1SSreekanth Reddy break; 2277f92363d1SSreekanth Reddy case MPT3DIAGREGISTER: 2278f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_register)) 2279f92363d1SSreekanth Reddy ret = _ctl_diag_register(ioc, arg); 2280f92363d1SSreekanth Reddy break; 2281f92363d1SSreekanth Reddy case MPT3DIAGUNREGISTER: 2282f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_unregister)) 2283f92363d1SSreekanth Reddy ret = _ctl_diag_unregister(ioc, arg); 2284f92363d1SSreekanth Reddy break; 2285f92363d1SSreekanth Reddy case MPT3DIAGQUERY: 2286f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_query)) 2287f92363d1SSreekanth Reddy ret = _ctl_diag_query(ioc, arg); 2288f92363d1SSreekanth Reddy break; 2289f92363d1SSreekanth Reddy case MPT3DIAGRELEASE: 2290f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_release)) 2291f92363d1SSreekanth Reddy ret = _ctl_diag_release(ioc, arg); 2292f92363d1SSreekanth Reddy break; 2293f92363d1SSreekanth Reddy case MPT3DIAGREADBUFFER: 2294f92363d1SSreekanth Reddy if (_IOC_SIZE(cmd) == sizeof(struct mpt3_diag_read_buffer)) 2295f92363d1SSreekanth Reddy ret = _ctl_diag_read_buffer(ioc, arg); 2296f92363d1SSreekanth Reddy break; 2297f92363d1SSreekanth Reddy default: 2298f92363d1SSreekanth Reddy dctlprintk(ioc, pr_info(MPT3SAS_FMT 2299f92363d1SSreekanth Reddy "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd)); 2300f92363d1SSreekanth Reddy break; 2301f92363d1SSreekanth Reddy } 2302f92363d1SSreekanth Reddy 2303f92363d1SSreekanth Reddy mutex_unlock(&ioc->ctl_cmds.mutex); 2304f92363d1SSreekanth Reddy return ret; 2305f92363d1SSreekanth Reddy } 2306f92363d1SSreekanth Reddy 2307f92363d1SSreekanth Reddy /** 23088a7e4c24SSreekanth Reddy * ctl_ioctl - main ioctl entry point (unlocked) 2309f92363d1SSreekanth Reddy * @file - (struct file) 2310f92363d1SSreekanth Reddy * @cmd - ioctl opcode 2311f92363d1SSreekanth Reddy * @arg - 2312f92363d1SSreekanth Reddy */ 23138a7e4c24SSreekanth Reddy long 23148a7e4c24SSreekanth Reddy ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2315f92363d1SSreekanth Reddy { 2316f92363d1SSreekanth Reddy long ret; 2317f92363d1SSreekanth Reddy 2318f92363d1SSreekanth Reddy ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0); 2319f92363d1SSreekanth Reddy return ret; 2320f92363d1SSreekanth Reddy } 2321f92363d1SSreekanth Reddy 2322f92363d1SSreekanth Reddy #ifdef CONFIG_COMPAT 2323f92363d1SSreekanth Reddy /** 23248a7e4c24SSreekanth Reddy * ctl_ioctl_compat - main ioctl entry point (compat) 2325f92363d1SSreekanth Reddy * @file - 2326f92363d1SSreekanth Reddy * @cmd - 2327f92363d1SSreekanth Reddy * @arg - 2328f92363d1SSreekanth Reddy * 2329f92363d1SSreekanth Reddy * This routine handles 32 bit applications in 64bit os. 2330f92363d1SSreekanth Reddy */ 23318a7e4c24SSreekanth Reddy long 23328a7e4c24SSreekanth Reddy ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg) 2333f92363d1SSreekanth Reddy { 2334f92363d1SSreekanth Reddy long ret; 2335f92363d1SSreekanth Reddy 2336f92363d1SSreekanth Reddy ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1); 2337f92363d1SSreekanth Reddy return ret; 2338f92363d1SSreekanth Reddy } 2339f92363d1SSreekanth Reddy #endif 2340f92363d1SSreekanth Reddy 2341f92363d1SSreekanth Reddy /* scsi host attributes */ 2342f92363d1SSreekanth Reddy /** 2343f92363d1SSreekanth Reddy * _ctl_version_fw_show - firmware version 2344f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2345f92363d1SSreekanth Reddy * @buf - the buffer returned 2346f92363d1SSreekanth Reddy * 2347f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2348f92363d1SSreekanth Reddy */ 2349f92363d1SSreekanth Reddy static ssize_t 2350f92363d1SSreekanth Reddy _ctl_version_fw_show(struct device *cdev, struct device_attribute *attr, 2351f92363d1SSreekanth Reddy char *buf) 2352f92363d1SSreekanth Reddy { 2353f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2354f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2355f92363d1SSreekanth Reddy 2356f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2357f92363d1SSreekanth Reddy (ioc->facts.FWVersion.Word & 0xFF000000) >> 24, 2358f92363d1SSreekanth Reddy (ioc->facts.FWVersion.Word & 0x00FF0000) >> 16, 2359f92363d1SSreekanth Reddy (ioc->facts.FWVersion.Word & 0x0000FF00) >> 8, 2360f92363d1SSreekanth Reddy ioc->facts.FWVersion.Word & 0x000000FF); 2361f92363d1SSreekanth Reddy } 2362f92363d1SSreekanth Reddy static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL); 2363f92363d1SSreekanth Reddy 2364f92363d1SSreekanth Reddy /** 2365f92363d1SSreekanth Reddy * _ctl_version_bios_show - bios version 2366f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2367f92363d1SSreekanth Reddy * @buf - the buffer returned 2368f92363d1SSreekanth Reddy * 2369f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2370f92363d1SSreekanth Reddy */ 2371f92363d1SSreekanth Reddy static ssize_t 2372f92363d1SSreekanth Reddy _ctl_version_bios_show(struct device *cdev, struct device_attribute *attr, 2373f92363d1SSreekanth Reddy char *buf) 2374f92363d1SSreekanth Reddy { 2375f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2376f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2377f92363d1SSreekanth Reddy 2378f92363d1SSreekanth Reddy u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion); 2379f92363d1SSreekanth Reddy 2380f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n", 2381f92363d1SSreekanth Reddy (version & 0xFF000000) >> 24, 2382f92363d1SSreekanth Reddy (version & 0x00FF0000) >> 16, 2383f92363d1SSreekanth Reddy (version & 0x0000FF00) >> 8, 2384f92363d1SSreekanth Reddy version & 0x000000FF); 2385f92363d1SSreekanth Reddy } 2386f92363d1SSreekanth Reddy static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL); 2387f92363d1SSreekanth Reddy 2388f92363d1SSreekanth Reddy /** 2389f92363d1SSreekanth Reddy * _ctl_version_mpi_show - MPI (message passing interface) version 2390f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2391f92363d1SSreekanth Reddy * @buf - the buffer returned 2392f92363d1SSreekanth Reddy * 2393f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2394f92363d1SSreekanth Reddy */ 2395f92363d1SSreekanth Reddy static ssize_t 2396f92363d1SSreekanth Reddy _ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr, 2397f92363d1SSreekanth Reddy char *buf) 2398f92363d1SSreekanth Reddy { 2399f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2400f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2401f92363d1SSreekanth Reddy 2402f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%03x.%02x\n", 2403f92363d1SSreekanth Reddy ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8); 2404f92363d1SSreekanth Reddy } 2405f92363d1SSreekanth Reddy static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL); 2406f92363d1SSreekanth Reddy 2407f92363d1SSreekanth Reddy /** 2408f92363d1SSreekanth Reddy * _ctl_version_product_show - product name 2409f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2410f92363d1SSreekanth Reddy * @buf - the buffer returned 2411f92363d1SSreekanth Reddy * 2412f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2413f92363d1SSreekanth Reddy */ 2414f92363d1SSreekanth Reddy static ssize_t 2415f92363d1SSreekanth Reddy _ctl_version_product_show(struct device *cdev, struct device_attribute *attr, 2416f92363d1SSreekanth Reddy char *buf) 2417f92363d1SSreekanth Reddy { 2418f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2419f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2420f92363d1SSreekanth Reddy 2421f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName); 2422f92363d1SSreekanth Reddy } 2423f92363d1SSreekanth Reddy static DEVICE_ATTR(version_product, S_IRUGO, _ctl_version_product_show, NULL); 2424f92363d1SSreekanth Reddy 2425f92363d1SSreekanth Reddy /** 2426f92363d1SSreekanth Reddy * _ctl_version_nvdata_persistent_show - ndvata persistent version 2427f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2428f92363d1SSreekanth Reddy * @buf - the buffer returned 2429f92363d1SSreekanth Reddy * 2430f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2431f92363d1SSreekanth Reddy */ 2432f92363d1SSreekanth Reddy static ssize_t 2433f92363d1SSreekanth Reddy _ctl_version_nvdata_persistent_show(struct device *cdev, 2434f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 2435f92363d1SSreekanth Reddy { 2436f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2437f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2438f92363d1SSreekanth Reddy 2439f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%08xh\n", 2440f92363d1SSreekanth Reddy le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word)); 2441f92363d1SSreekanth Reddy } 2442f92363d1SSreekanth Reddy static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO, 2443f92363d1SSreekanth Reddy _ctl_version_nvdata_persistent_show, NULL); 2444f92363d1SSreekanth Reddy 2445f92363d1SSreekanth Reddy /** 2446f92363d1SSreekanth Reddy * _ctl_version_nvdata_default_show - nvdata default version 2447f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2448f92363d1SSreekanth Reddy * @buf - the buffer returned 2449f92363d1SSreekanth Reddy * 2450f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2451f92363d1SSreekanth Reddy */ 2452f92363d1SSreekanth Reddy static ssize_t 2453f92363d1SSreekanth Reddy _ctl_version_nvdata_default_show(struct device *cdev, struct device_attribute 2454f92363d1SSreekanth Reddy *attr, char *buf) 2455f92363d1SSreekanth Reddy { 2456f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2457f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2458f92363d1SSreekanth Reddy 2459f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%08xh\n", 2460f92363d1SSreekanth Reddy le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word)); 2461f92363d1SSreekanth Reddy } 2462f92363d1SSreekanth Reddy static DEVICE_ATTR(version_nvdata_default, S_IRUGO, 2463f92363d1SSreekanth Reddy _ctl_version_nvdata_default_show, NULL); 2464f92363d1SSreekanth Reddy 2465f92363d1SSreekanth Reddy /** 2466f92363d1SSreekanth Reddy * _ctl_board_name_show - board name 2467f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2468f92363d1SSreekanth Reddy * @buf - the buffer returned 2469f92363d1SSreekanth Reddy * 2470f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2471f92363d1SSreekanth Reddy */ 2472f92363d1SSreekanth Reddy static ssize_t 2473f92363d1SSreekanth Reddy _ctl_board_name_show(struct device *cdev, struct device_attribute *attr, 2474f92363d1SSreekanth Reddy char *buf) 2475f92363d1SSreekanth Reddy { 2476f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2477f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2478f92363d1SSreekanth Reddy 2479f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName); 2480f92363d1SSreekanth Reddy } 2481f92363d1SSreekanth Reddy static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL); 2482f92363d1SSreekanth Reddy 2483f92363d1SSreekanth Reddy /** 2484f92363d1SSreekanth Reddy * _ctl_board_assembly_show - board assembly name 2485f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2486f92363d1SSreekanth Reddy * @buf - the buffer returned 2487f92363d1SSreekanth Reddy * 2488f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2489f92363d1SSreekanth Reddy */ 2490f92363d1SSreekanth Reddy static ssize_t 2491f92363d1SSreekanth Reddy _ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr, 2492f92363d1SSreekanth Reddy char *buf) 2493f92363d1SSreekanth Reddy { 2494f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2495f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2496f92363d1SSreekanth Reddy 2497f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly); 2498f92363d1SSreekanth Reddy } 2499f92363d1SSreekanth Reddy static DEVICE_ATTR(board_assembly, S_IRUGO, _ctl_board_assembly_show, NULL); 2500f92363d1SSreekanth Reddy 2501f92363d1SSreekanth Reddy /** 2502f92363d1SSreekanth Reddy * _ctl_board_tracer_show - board tracer number 2503f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2504f92363d1SSreekanth Reddy * @buf - the buffer returned 2505f92363d1SSreekanth Reddy * 2506f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2507f92363d1SSreekanth Reddy */ 2508f92363d1SSreekanth Reddy static ssize_t 2509f92363d1SSreekanth Reddy _ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr, 2510f92363d1SSreekanth Reddy char *buf) 2511f92363d1SSreekanth Reddy { 2512f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2513f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2514f92363d1SSreekanth Reddy 2515f92363d1SSreekanth Reddy return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber); 2516f92363d1SSreekanth Reddy } 2517f92363d1SSreekanth Reddy static DEVICE_ATTR(board_tracer, S_IRUGO, _ctl_board_tracer_show, NULL); 2518f92363d1SSreekanth Reddy 2519f92363d1SSreekanth Reddy /** 2520f92363d1SSreekanth Reddy * _ctl_io_delay_show - io missing delay 2521f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2522f92363d1SSreekanth Reddy * @buf - the buffer returned 2523f92363d1SSreekanth Reddy * 2524f92363d1SSreekanth Reddy * This is for firmware implemention for deboucing device 2525f92363d1SSreekanth Reddy * removal events. 2526f92363d1SSreekanth Reddy * 2527f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2528f92363d1SSreekanth Reddy */ 2529f92363d1SSreekanth Reddy static ssize_t 2530f92363d1SSreekanth Reddy _ctl_io_delay_show(struct device *cdev, struct device_attribute *attr, 2531f92363d1SSreekanth Reddy char *buf) 2532f92363d1SSreekanth Reddy { 2533f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2534f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2535f92363d1SSreekanth Reddy 2536f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay); 2537f92363d1SSreekanth Reddy } 2538f92363d1SSreekanth Reddy static DEVICE_ATTR(io_delay, S_IRUGO, _ctl_io_delay_show, NULL); 2539f92363d1SSreekanth Reddy 2540f92363d1SSreekanth Reddy /** 2541f92363d1SSreekanth Reddy * _ctl_device_delay_show - device missing delay 2542f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2543f92363d1SSreekanth Reddy * @buf - the buffer returned 2544f92363d1SSreekanth Reddy * 2545f92363d1SSreekanth Reddy * This is for firmware implemention for deboucing device 2546f92363d1SSreekanth Reddy * removal events. 2547f92363d1SSreekanth Reddy * 2548f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2549f92363d1SSreekanth Reddy */ 2550f92363d1SSreekanth Reddy static ssize_t 2551f92363d1SSreekanth Reddy _ctl_device_delay_show(struct device *cdev, struct device_attribute *attr, 2552f92363d1SSreekanth Reddy char *buf) 2553f92363d1SSreekanth Reddy { 2554f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2555f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2556f92363d1SSreekanth Reddy 2557f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay); 2558f92363d1SSreekanth Reddy } 2559f92363d1SSreekanth Reddy static DEVICE_ATTR(device_delay, S_IRUGO, _ctl_device_delay_show, NULL); 2560f92363d1SSreekanth Reddy 2561f92363d1SSreekanth Reddy /** 2562f92363d1SSreekanth Reddy * _ctl_fw_queue_depth_show - global credits 2563f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2564f92363d1SSreekanth Reddy * @buf - the buffer returned 2565f92363d1SSreekanth Reddy * 2566f92363d1SSreekanth Reddy * This is firmware queue depth limit 2567f92363d1SSreekanth Reddy * 2568f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2569f92363d1SSreekanth Reddy */ 2570f92363d1SSreekanth Reddy static ssize_t 2571f92363d1SSreekanth Reddy _ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr, 2572f92363d1SSreekanth Reddy char *buf) 2573f92363d1SSreekanth Reddy { 2574f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2575f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2576f92363d1SSreekanth Reddy 2577f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit); 2578f92363d1SSreekanth Reddy } 2579f92363d1SSreekanth Reddy static DEVICE_ATTR(fw_queue_depth, S_IRUGO, _ctl_fw_queue_depth_show, NULL); 2580f92363d1SSreekanth Reddy 2581f92363d1SSreekanth Reddy /** 2582f92363d1SSreekanth Reddy * _ctl_sas_address_show - sas address 2583f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2584f92363d1SSreekanth Reddy * @buf - the buffer returned 2585f92363d1SSreekanth Reddy * 2586f92363d1SSreekanth Reddy * This is the controller sas address 2587f92363d1SSreekanth Reddy * 2588f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2589f92363d1SSreekanth Reddy */ 2590f92363d1SSreekanth Reddy static ssize_t 2591f92363d1SSreekanth Reddy _ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr, 2592f92363d1SSreekanth Reddy char *buf) 2593f92363d1SSreekanth Reddy 2594f92363d1SSreekanth Reddy { 2595f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2596f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2597f92363d1SSreekanth Reddy 2598f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 2599f92363d1SSreekanth Reddy (unsigned long long)ioc->sas_hba.sas_address); 2600f92363d1SSreekanth Reddy } 2601f92363d1SSreekanth Reddy static DEVICE_ATTR(host_sas_address, S_IRUGO, 2602f92363d1SSreekanth Reddy _ctl_host_sas_address_show, NULL); 2603f92363d1SSreekanth Reddy 2604f92363d1SSreekanth Reddy /** 2605f92363d1SSreekanth Reddy * _ctl_logging_level_show - logging level 2606f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2607f92363d1SSreekanth Reddy * @buf - the buffer returned 2608f92363d1SSreekanth Reddy * 2609f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 2610f92363d1SSreekanth Reddy */ 2611f92363d1SSreekanth Reddy static ssize_t 2612f92363d1SSreekanth Reddy _ctl_logging_level_show(struct device *cdev, struct device_attribute *attr, 2613f92363d1SSreekanth Reddy char *buf) 2614f92363d1SSreekanth Reddy { 2615f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2616f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2617f92363d1SSreekanth Reddy 2618f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level); 2619f92363d1SSreekanth Reddy } 2620f92363d1SSreekanth Reddy static ssize_t 2621f92363d1SSreekanth Reddy _ctl_logging_level_store(struct device *cdev, struct device_attribute *attr, 2622f92363d1SSreekanth Reddy const char *buf, size_t count) 2623f92363d1SSreekanth Reddy { 2624f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2625f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2626f92363d1SSreekanth Reddy int val = 0; 2627f92363d1SSreekanth Reddy 2628f92363d1SSreekanth Reddy if (sscanf(buf, "%x", &val) != 1) 2629f92363d1SSreekanth Reddy return -EINVAL; 2630f92363d1SSreekanth Reddy 2631f92363d1SSreekanth Reddy ioc->logging_level = val; 2632f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "logging_level=%08xh\n", ioc->name, 2633f92363d1SSreekanth Reddy ioc->logging_level); 2634f92363d1SSreekanth Reddy return strlen(buf); 2635f92363d1SSreekanth Reddy } 2636f92363d1SSreekanth Reddy static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR, _ctl_logging_level_show, 2637f92363d1SSreekanth Reddy _ctl_logging_level_store); 2638f92363d1SSreekanth Reddy 2639f92363d1SSreekanth Reddy /** 2640f92363d1SSreekanth Reddy * _ctl_fwfault_debug_show - show/store fwfault_debug 2641f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2642f92363d1SSreekanth Reddy * @buf - the buffer returned 2643f92363d1SSreekanth Reddy * 2644f92363d1SSreekanth Reddy * mpt3sas_fwfault_debug is command line option 2645f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 2646f92363d1SSreekanth Reddy */ 2647f92363d1SSreekanth Reddy static ssize_t 2648f92363d1SSreekanth Reddy _ctl_fwfault_debug_show(struct device *cdev, struct device_attribute *attr, 2649f92363d1SSreekanth Reddy char *buf) 2650f92363d1SSreekanth Reddy { 2651f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2652f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2653f92363d1SSreekanth Reddy 2654f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug); 2655f92363d1SSreekanth Reddy } 2656f92363d1SSreekanth Reddy static ssize_t 2657f92363d1SSreekanth Reddy _ctl_fwfault_debug_store(struct device *cdev, struct device_attribute *attr, 2658f92363d1SSreekanth Reddy const char *buf, size_t count) 2659f92363d1SSreekanth Reddy { 2660f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2661f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2662f92363d1SSreekanth Reddy int val = 0; 2663f92363d1SSreekanth Reddy 2664f92363d1SSreekanth Reddy if (sscanf(buf, "%d", &val) != 1) 2665f92363d1SSreekanth Reddy return -EINVAL; 2666f92363d1SSreekanth Reddy 2667f92363d1SSreekanth Reddy ioc->fwfault_debug = val; 2668f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "fwfault_debug=%d\n", ioc->name, 2669f92363d1SSreekanth Reddy ioc->fwfault_debug); 2670f92363d1SSreekanth Reddy return strlen(buf); 2671f92363d1SSreekanth Reddy } 2672f92363d1SSreekanth Reddy static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR, 2673f92363d1SSreekanth Reddy _ctl_fwfault_debug_show, _ctl_fwfault_debug_store); 2674f92363d1SSreekanth Reddy 2675f92363d1SSreekanth Reddy /** 2676f92363d1SSreekanth Reddy * _ctl_ioc_reset_count_show - ioc reset count 2677f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2678f92363d1SSreekanth Reddy * @buf - the buffer returned 2679f92363d1SSreekanth Reddy * 2680f92363d1SSreekanth Reddy * This is firmware queue depth limit 2681f92363d1SSreekanth Reddy * 2682f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2683f92363d1SSreekanth Reddy */ 2684f92363d1SSreekanth Reddy static ssize_t 2685f92363d1SSreekanth Reddy _ctl_ioc_reset_count_show(struct device *cdev, struct device_attribute *attr, 2686f92363d1SSreekanth Reddy char *buf) 2687f92363d1SSreekanth Reddy { 2688f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2689f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2690f92363d1SSreekanth Reddy 2691f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", ioc->ioc_reset_count); 2692f92363d1SSreekanth Reddy } 2693f92363d1SSreekanth Reddy static DEVICE_ATTR(ioc_reset_count, S_IRUGO, _ctl_ioc_reset_count_show, NULL); 2694f92363d1SSreekanth Reddy 2695f92363d1SSreekanth Reddy /** 2696f92363d1SSreekanth Reddy * _ctl_ioc_reply_queue_count_show - number of reply queues 2697f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2698f92363d1SSreekanth Reddy * @buf - the buffer returned 2699f92363d1SSreekanth Reddy * 2700f92363d1SSreekanth Reddy * This is number of reply queues 2701f92363d1SSreekanth Reddy * 2702f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2703f92363d1SSreekanth Reddy */ 2704f92363d1SSreekanth Reddy static ssize_t 2705f92363d1SSreekanth Reddy _ctl_ioc_reply_queue_count_show(struct device *cdev, 2706f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 2707f92363d1SSreekanth Reddy { 2708f92363d1SSreekanth Reddy u8 reply_queue_count; 2709f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2710f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2711f92363d1SSreekanth Reddy 2712f92363d1SSreekanth Reddy if ((ioc->facts.IOCCapabilities & 2713f92363d1SSreekanth Reddy MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX) && ioc->msix_enable) 2714f92363d1SSreekanth Reddy reply_queue_count = ioc->reply_queue_count; 2715f92363d1SSreekanth Reddy else 2716f92363d1SSreekanth Reddy reply_queue_count = 1; 2717f92363d1SSreekanth Reddy 2718f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", reply_queue_count); 2719f92363d1SSreekanth Reddy } 2720f92363d1SSreekanth Reddy static DEVICE_ATTR(reply_queue_count, S_IRUGO, _ctl_ioc_reply_queue_count_show, 2721f92363d1SSreekanth Reddy NULL); 2722f92363d1SSreekanth Reddy 2723*42263095SSreekanth Reddy #ifdef SCSI_MPT2SAS 2724*42263095SSreekanth Reddy /** 2725*42263095SSreekanth Reddy * _ctl_BRM_status_show - Backup Rail Monitor Status 2726*42263095SSreekanth Reddy * @cdev - pointer to embedded class device 2727*42263095SSreekanth Reddy * @buf - the buffer returned 2728*42263095SSreekanth Reddy * 2729*42263095SSreekanth Reddy * This is number of reply queues 2730*42263095SSreekanth Reddy * 2731*42263095SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2732*42263095SSreekanth Reddy */ 2733*42263095SSreekanth Reddy static ssize_t 2734*42263095SSreekanth Reddy _ctl_BRM_status_show(struct device *cdev, struct device_attribute *attr, 2735*42263095SSreekanth Reddy char *buf) 2736*42263095SSreekanth Reddy { 2737*42263095SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2738*42263095SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2739*42263095SSreekanth Reddy Mpi2IOUnitPage3_t *io_unit_pg3 = NULL; 2740*42263095SSreekanth Reddy Mpi2ConfigReply_t mpi_reply; 2741*42263095SSreekanth Reddy u16 backup_rail_monitor_status = 0; 2742*42263095SSreekanth Reddy u16 ioc_status; 2743*42263095SSreekanth Reddy int sz; 2744*42263095SSreekanth Reddy ssize_t rc = 0; 2745*42263095SSreekanth Reddy 2746*42263095SSreekanth Reddy if (!ioc->is_warpdrive) { 2747*42263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: BRM attribute is only for" 2748*42263095SSreekanth Reddy " warpdrive\n", ioc->name, __func__); 2749*42263095SSreekanth Reddy goto out; 2750*42263095SSreekanth Reddy } 2751*42263095SSreekanth Reddy 2752*42263095SSreekanth Reddy /* allocate upto GPIOVal 36 entries */ 2753*42263095SSreekanth Reddy sz = offsetof(Mpi2IOUnitPage3_t, GPIOVal) + (sizeof(u16) * 36); 2754*42263095SSreekanth Reddy io_unit_pg3 = kzalloc(sz, GFP_KERNEL); 2755*42263095SSreekanth Reddy if (!io_unit_pg3) { 2756*42263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: failed allocating memory " 2757*42263095SSreekanth Reddy "for iounit_pg3: (%d) bytes\n", ioc->name, __func__, sz); 2758*42263095SSreekanth Reddy goto out; 2759*42263095SSreekanth Reddy } 2760*42263095SSreekanth Reddy 2761*42263095SSreekanth Reddy if (mpt3sas_config_get_iounit_pg3(ioc, &mpi_reply, io_unit_pg3, sz) != 2762*42263095SSreekanth Reddy 0) { 2763*42263095SSreekanth Reddy pr_err(MPT3SAS_FMT 2764*42263095SSreekanth Reddy "%s: failed reading iounit_pg3\n", ioc->name, 2765*42263095SSreekanth Reddy __func__); 2766*42263095SSreekanth Reddy goto out; 2767*42263095SSreekanth Reddy } 2768*42263095SSreekanth Reddy 2769*42263095SSreekanth Reddy ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 2770*42263095SSreekanth Reddy if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 2771*42263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: iounit_pg3 failed with " 2772*42263095SSreekanth Reddy "ioc_status(0x%04x)\n", ioc->name, __func__, ioc_status); 2773*42263095SSreekanth Reddy goto out; 2774*42263095SSreekanth Reddy } 2775*42263095SSreekanth Reddy 2776*42263095SSreekanth Reddy if (io_unit_pg3->GPIOCount < 25) { 2777*42263095SSreekanth Reddy pr_err(MPT3SAS_FMT "%s: iounit_pg3->GPIOCount less than " 2778*42263095SSreekanth Reddy "25 entries, detected (%d) entries\n", ioc->name, __func__, 2779*42263095SSreekanth Reddy io_unit_pg3->GPIOCount); 2780*42263095SSreekanth Reddy goto out; 2781*42263095SSreekanth Reddy } 2782*42263095SSreekanth Reddy 2783*42263095SSreekanth Reddy /* BRM status is in bit zero of GPIOVal[24] */ 2784*42263095SSreekanth Reddy backup_rail_monitor_status = le16_to_cpu(io_unit_pg3->GPIOVal[24]); 2785*42263095SSreekanth Reddy rc = snprintf(buf, PAGE_SIZE, "%d\n", (backup_rail_monitor_status & 1)); 2786*42263095SSreekanth Reddy 2787*42263095SSreekanth Reddy out: 2788*42263095SSreekanth Reddy kfree(io_unit_pg3); 2789*42263095SSreekanth Reddy return rc; 2790*42263095SSreekanth Reddy } 2791*42263095SSreekanth Reddy static DEVICE_ATTR(BRM_status, S_IRUGO, _ctl_BRM_status_show, NULL); 2792*42263095SSreekanth Reddy #endif 2793*42263095SSreekanth Reddy 2794f92363d1SSreekanth Reddy struct DIAG_BUFFER_START { 2795f92363d1SSreekanth Reddy __le32 Size; 2796f92363d1SSreekanth Reddy __le32 DiagVersion; 2797f92363d1SSreekanth Reddy u8 BufferType; 2798f92363d1SSreekanth Reddy u8 Reserved[3]; 2799f92363d1SSreekanth Reddy __le32 Reserved1; 2800f92363d1SSreekanth Reddy __le32 Reserved2; 2801f92363d1SSreekanth Reddy __le32 Reserved3; 2802f92363d1SSreekanth Reddy }; 2803f92363d1SSreekanth Reddy 2804f92363d1SSreekanth Reddy /** 2805f92363d1SSreekanth Reddy * _ctl_host_trace_buffer_size_show - host buffer size (trace only) 2806f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2807f92363d1SSreekanth Reddy * @buf - the buffer returned 2808f92363d1SSreekanth Reddy * 2809f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 2810f92363d1SSreekanth Reddy */ 2811f92363d1SSreekanth Reddy static ssize_t 2812f92363d1SSreekanth Reddy _ctl_host_trace_buffer_size_show(struct device *cdev, 2813f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 2814f92363d1SSreekanth Reddy { 2815f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2816f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2817f92363d1SSreekanth Reddy u32 size = 0; 2818f92363d1SSreekanth Reddy struct DIAG_BUFFER_START *request_data; 2819f92363d1SSreekanth Reddy 2820f92363d1SSreekanth Reddy if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 2821f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2822f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 2823f92363d1SSreekanth Reddy ioc->name, __func__); 2824f92363d1SSreekanth Reddy return 0; 2825f92363d1SSreekanth Reddy } 2826f92363d1SSreekanth Reddy 2827f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2828f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 2829f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2830f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 2831f92363d1SSreekanth Reddy ioc->name, __func__); 2832f92363d1SSreekanth Reddy return 0; 2833f92363d1SSreekanth Reddy } 2834f92363d1SSreekanth Reddy 2835f92363d1SSreekanth Reddy request_data = (struct DIAG_BUFFER_START *) 2836f92363d1SSreekanth Reddy ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]; 2837f92363d1SSreekanth Reddy if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 || 2838f92363d1SSreekanth Reddy le32_to_cpu(request_data->DiagVersion) == 0x01000000 || 2839f92363d1SSreekanth Reddy le32_to_cpu(request_data->DiagVersion) == 0x01010000) && 2840f92363d1SSreekanth Reddy le32_to_cpu(request_data->Reserved3) == 0x4742444c) 2841f92363d1SSreekanth Reddy size = le32_to_cpu(request_data->Size); 2842f92363d1SSreekanth Reddy 2843f92363d1SSreekanth Reddy ioc->ring_buffer_sz = size; 2844f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "%d\n", size); 2845f92363d1SSreekanth Reddy } 2846f92363d1SSreekanth Reddy static DEVICE_ATTR(host_trace_buffer_size, S_IRUGO, 2847f92363d1SSreekanth Reddy _ctl_host_trace_buffer_size_show, NULL); 2848f92363d1SSreekanth Reddy 2849f92363d1SSreekanth Reddy /** 2850f92363d1SSreekanth Reddy * _ctl_host_trace_buffer_show - firmware ring buffer (trace only) 2851f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2852f92363d1SSreekanth Reddy * @buf - the buffer returned 2853f92363d1SSreekanth Reddy * 2854f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 2855f92363d1SSreekanth Reddy * 2856f92363d1SSreekanth Reddy * You will only be able to read 4k bytes of ring buffer at a time. 2857f92363d1SSreekanth Reddy * In order to read beyond 4k bytes, you will have to write out the 2858f92363d1SSreekanth Reddy * offset to the same attribute, it will move the pointer. 2859f92363d1SSreekanth Reddy */ 2860f92363d1SSreekanth Reddy static ssize_t 2861f92363d1SSreekanth Reddy _ctl_host_trace_buffer_show(struct device *cdev, struct device_attribute *attr, 2862f92363d1SSreekanth Reddy char *buf) 2863f92363d1SSreekanth Reddy { 2864f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2865f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2866f92363d1SSreekanth Reddy void *request_data; 2867f92363d1SSreekanth Reddy u32 size; 2868f92363d1SSreekanth Reddy 2869f92363d1SSreekanth Reddy if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) { 2870f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2871f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 2872f92363d1SSreekanth Reddy ioc->name, __func__); 2873f92363d1SSreekanth Reddy return 0; 2874f92363d1SSreekanth Reddy } 2875f92363d1SSreekanth Reddy 2876f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2877f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) { 2878f92363d1SSreekanth Reddy pr_err(MPT3SAS_FMT 2879f92363d1SSreekanth Reddy "%s: host_trace_buffer is not registered\n", 2880f92363d1SSreekanth Reddy ioc->name, __func__); 2881f92363d1SSreekanth Reddy return 0; 2882f92363d1SSreekanth Reddy } 2883f92363d1SSreekanth Reddy 2884f92363d1SSreekanth Reddy if (ioc->ring_buffer_offset > ioc->ring_buffer_sz) 2885f92363d1SSreekanth Reddy return 0; 2886f92363d1SSreekanth Reddy 2887f92363d1SSreekanth Reddy size = ioc->ring_buffer_sz - ioc->ring_buffer_offset; 2888f92363d1SSreekanth Reddy size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size; 2889f92363d1SSreekanth Reddy request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset; 2890f92363d1SSreekanth Reddy memcpy(buf, request_data, size); 2891f92363d1SSreekanth Reddy return size; 2892f92363d1SSreekanth Reddy } 2893f92363d1SSreekanth Reddy 2894f92363d1SSreekanth Reddy static ssize_t 2895f92363d1SSreekanth Reddy _ctl_host_trace_buffer_store(struct device *cdev, struct device_attribute *attr, 2896f92363d1SSreekanth Reddy const char *buf, size_t count) 2897f92363d1SSreekanth Reddy { 2898f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2899f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2900f92363d1SSreekanth Reddy int val = 0; 2901f92363d1SSreekanth Reddy 2902f92363d1SSreekanth Reddy if (sscanf(buf, "%d", &val) != 1) 2903f92363d1SSreekanth Reddy return -EINVAL; 2904f92363d1SSreekanth Reddy 2905f92363d1SSreekanth Reddy ioc->ring_buffer_offset = val; 2906f92363d1SSreekanth Reddy return strlen(buf); 2907f92363d1SSreekanth Reddy } 2908f92363d1SSreekanth Reddy static DEVICE_ATTR(host_trace_buffer, S_IRUGO | S_IWUSR, 2909f92363d1SSreekanth Reddy _ctl_host_trace_buffer_show, _ctl_host_trace_buffer_store); 2910f92363d1SSreekanth Reddy 2911f92363d1SSreekanth Reddy 2912f92363d1SSreekanth Reddy /*****************************************/ 2913f92363d1SSreekanth Reddy 2914f92363d1SSreekanth Reddy /** 2915f92363d1SSreekanth Reddy * _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only) 2916f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 2917f92363d1SSreekanth Reddy * @buf - the buffer returned 2918f92363d1SSreekanth Reddy * 2919f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 2920f92363d1SSreekanth Reddy * 2921f92363d1SSreekanth Reddy * This is a mechnism to post/release host_trace_buffers 2922f92363d1SSreekanth Reddy */ 2923f92363d1SSreekanth Reddy static ssize_t 2924f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_show(struct device *cdev, 2925f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 2926f92363d1SSreekanth Reddy { 2927f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2928f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2929f92363d1SSreekanth Reddy 2930f92363d1SSreekanth Reddy if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) || 2931f92363d1SSreekanth Reddy ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2932f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0)) 2933f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "off\n"); 2934f92363d1SSreekanth Reddy else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2935f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 2936f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "release\n"); 2937f92363d1SSreekanth Reddy else 2938f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "post\n"); 2939f92363d1SSreekanth Reddy } 2940f92363d1SSreekanth Reddy 2941f92363d1SSreekanth Reddy static ssize_t 2942f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_store(struct device *cdev, 2943f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 2944f92363d1SSreekanth Reddy { 2945f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 2946f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2947f92363d1SSreekanth Reddy char str[10] = ""; 2948f92363d1SSreekanth Reddy struct mpt3_diag_register diag_register; 2949f92363d1SSreekanth Reddy u8 issue_reset = 0; 2950f92363d1SSreekanth Reddy 2951f92363d1SSreekanth Reddy /* don't allow post/release occurr while recovery is active */ 2952f92363d1SSreekanth Reddy if (ioc->shost_recovery || ioc->remove_host || 2953f92363d1SSreekanth Reddy ioc->pci_error_recovery || ioc->is_driver_loading) 2954f92363d1SSreekanth Reddy return -EBUSY; 2955f92363d1SSreekanth Reddy 2956f92363d1SSreekanth Reddy if (sscanf(buf, "%9s", str) != 1) 2957f92363d1SSreekanth Reddy return -EINVAL; 2958f92363d1SSreekanth Reddy 2959f92363d1SSreekanth Reddy if (!strcmp(str, "post")) { 2960f92363d1SSreekanth Reddy /* exit out if host buffers are already posted */ 2961f92363d1SSreekanth Reddy if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) && 2962f92363d1SSreekanth Reddy (ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2963f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) && 2964f92363d1SSreekanth Reddy ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2965f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED) == 0)) 2966f92363d1SSreekanth Reddy goto out; 2967f92363d1SSreekanth Reddy memset(&diag_register, 0, sizeof(struct mpt3_diag_register)); 2968f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "posting host trace buffers\n", 2969f92363d1SSreekanth Reddy ioc->name); 2970f92363d1SSreekanth Reddy diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE; 2971f92363d1SSreekanth Reddy diag_register.requested_buffer_size = (1024 * 1024); 2972f92363d1SSreekanth Reddy diag_register.unique_id = 0x7075900; 2973f92363d1SSreekanth Reddy ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0; 2974f92363d1SSreekanth Reddy _ctl_diag_register_2(ioc, &diag_register); 2975f92363d1SSreekanth Reddy } else if (!strcmp(str, "release")) { 2976f92363d1SSreekanth Reddy /* exit out if host buffers are already released */ 2977f92363d1SSreekanth Reddy if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) 2978f92363d1SSreekanth Reddy goto out; 2979f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2980f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) 2981f92363d1SSreekanth Reddy goto out; 2982f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] & 2983f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 2984f92363d1SSreekanth Reddy goto out; 2985f92363d1SSreekanth Reddy pr_info(MPT3SAS_FMT "releasing host trace buffer\n", 2986f92363d1SSreekanth Reddy ioc->name); 2987f92363d1SSreekanth Reddy mpt3sas_send_diag_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, 2988f92363d1SSreekanth Reddy &issue_reset); 2989f92363d1SSreekanth Reddy } 2990f92363d1SSreekanth Reddy 2991f92363d1SSreekanth Reddy out: 2992f92363d1SSreekanth Reddy return strlen(buf); 2993f92363d1SSreekanth Reddy } 2994f92363d1SSreekanth Reddy static DEVICE_ATTR(host_trace_buffer_enable, S_IRUGO | S_IWUSR, 2995f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_show, 2996f92363d1SSreekanth Reddy _ctl_host_trace_buffer_enable_store); 2997f92363d1SSreekanth Reddy 2998f92363d1SSreekanth Reddy /*********** diagnostic trigger suppport *********************************/ 2999f92363d1SSreekanth Reddy 3000f92363d1SSreekanth Reddy /** 3001f92363d1SSreekanth Reddy * _ctl_diag_trigger_master_show - show the diag_trigger_master attribute 3002f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3003f92363d1SSreekanth Reddy * @buf - the buffer returned 3004f92363d1SSreekanth Reddy * 3005f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3006f92363d1SSreekanth Reddy */ 3007f92363d1SSreekanth Reddy static ssize_t 3008f92363d1SSreekanth Reddy _ctl_diag_trigger_master_show(struct device *cdev, 3009f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3010f92363d1SSreekanth Reddy 3011f92363d1SSreekanth Reddy { 3012f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3013f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3014f92363d1SSreekanth Reddy unsigned long flags; 3015f92363d1SSreekanth Reddy ssize_t rc; 3016f92363d1SSreekanth Reddy 3017f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3018f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_MASTER_TRIGGER_T); 3019f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_master, rc); 3020f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3021f92363d1SSreekanth Reddy return rc; 3022f92363d1SSreekanth Reddy } 3023f92363d1SSreekanth Reddy 3024f92363d1SSreekanth Reddy /** 3025f92363d1SSreekanth Reddy * _ctl_diag_trigger_master_store - store the diag_trigger_master attribute 3026f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3027f92363d1SSreekanth Reddy * @buf - the buffer returned 3028f92363d1SSreekanth Reddy * 3029f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3030f92363d1SSreekanth Reddy */ 3031f92363d1SSreekanth Reddy static ssize_t 3032f92363d1SSreekanth Reddy _ctl_diag_trigger_master_store(struct device *cdev, 3033f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3034f92363d1SSreekanth Reddy 3035f92363d1SSreekanth Reddy { 3036f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3037f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3038f92363d1SSreekanth Reddy unsigned long flags; 3039f92363d1SSreekanth Reddy ssize_t rc; 3040f92363d1SSreekanth Reddy 3041f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3042f92363d1SSreekanth Reddy rc = min(sizeof(struct SL_WH_MASTER_TRIGGER_T), count); 3043f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_master, 0, 3044f92363d1SSreekanth Reddy sizeof(struct SL_WH_MASTER_TRIGGER_T)); 3045f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_master, buf, rc); 3046f92363d1SSreekanth Reddy ioc->diag_trigger_master.MasterData |= 3047f92363d1SSreekanth Reddy (MASTER_TRIGGER_FW_FAULT + MASTER_TRIGGER_ADAPTER_RESET); 3048f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3049f92363d1SSreekanth Reddy return rc; 3050f92363d1SSreekanth Reddy } 3051f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_master, S_IRUGO | S_IWUSR, 3052f92363d1SSreekanth Reddy _ctl_diag_trigger_master_show, _ctl_diag_trigger_master_store); 3053f92363d1SSreekanth Reddy 3054f92363d1SSreekanth Reddy 3055f92363d1SSreekanth Reddy /** 3056f92363d1SSreekanth Reddy * _ctl_diag_trigger_event_show - show the diag_trigger_event attribute 3057f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3058f92363d1SSreekanth Reddy * @buf - the buffer returned 3059f92363d1SSreekanth Reddy * 3060f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3061f92363d1SSreekanth Reddy */ 3062f92363d1SSreekanth Reddy static ssize_t 3063f92363d1SSreekanth Reddy _ctl_diag_trigger_event_show(struct device *cdev, 3064f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3065f92363d1SSreekanth Reddy { 3066f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3067f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3068f92363d1SSreekanth Reddy unsigned long flags; 3069f92363d1SSreekanth Reddy ssize_t rc; 3070f92363d1SSreekanth Reddy 3071f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3072f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_EVENT_TRIGGERS_T); 3073f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_event, rc); 3074f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3075f92363d1SSreekanth Reddy return rc; 3076f92363d1SSreekanth Reddy } 3077f92363d1SSreekanth Reddy 3078f92363d1SSreekanth Reddy /** 3079f92363d1SSreekanth Reddy * _ctl_diag_trigger_event_store - store the diag_trigger_event attribute 3080f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3081f92363d1SSreekanth Reddy * @buf - the buffer returned 3082f92363d1SSreekanth Reddy * 3083f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3084f92363d1SSreekanth Reddy */ 3085f92363d1SSreekanth Reddy static ssize_t 3086f92363d1SSreekanth Reddy _ctl_diag_trigger_event_store(struct device *cdev, 3087f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3088f92363d1SSreekanth Reddy 3089f92363d1SSreekanth Reddy { 3090f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3091f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3092f92363d1SSreekanth Reddy unsigned long flags; 3093f92363d1SSreekanth Reddy ssize_t sz; 3094f92363d1SSreekanth Reddy 3095f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3096f92363d1SSreekanth Reddy sz = min(sizeof(struct SL_WH_EVENT_TRIGGERS_T), count); 3097f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_event, 0, 3098f92363d1SSreekanth Reddy sizeof(struct SL_WH_EVENT_TRIGGERS_T)); 3099f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_event, buf, sz); 3100f92363d1SSreekanth Reddy if (ioc->diag_trigger_event.ValidEntries > NUM_VALID_ENTRIES) 3101f92363d1SSreekanth Reddy ioc->diag_trigger_event.ValidEntries = NUM_VALID_ENTRIES; 3102f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3103f92363d1SSreekanth Reddy return sz; 3104f92363d1SSreekanth Reddy } 3105f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_event, S_IRUGO | S_IWUSR, 3106f92363d1SSreekanth Reddy _ctl_diag_trigger_event_show, _ctl_diag_trigger_event_store); 3107f92363d1SSreekanth Reddy 3108f92363d1SSreekanth Reddy 3109f92363d1SSreekanth Reddy /** 3110f92363d1SSreekanth Reddy * _ctl_diag_trigger_scsi_show - show the diag_trigger_scsi attribute 3111f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3112f92363d1SSreekanth Reddy * @buf - the buffer returned 3113f92363d1SSreekanth Reddy * 3114f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3115f92363d1SSreekanth Reddy */ 3116f92363d1SSreekanth Reddy static ssize_t 3117f92363d1SSreekanth Reddy _ctl_diag_trigger_scsi_show(struct device *cdev, 3118f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3119f92363d1SSreekanth Reddy { 3120f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3121f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3122f92363d1SSreekanth Reddy unsigned long flags; 3123f92363d1SSreekanth Reddy ssize_t rc; 3124f92363d1SSreekanth Reddy 3125f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3126f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_SCSI_TRIGGERS_T); 3127f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_scsi, rc); 3128f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3129f92363d1SSreekanth Reddy return rc; 3130f92363d1SSreekanth Reddy } 3131f92363d1SSreekanth Reddy 3132f92363d1SSreekanth Reddy /** 3133f92363d1SSreekanth Reddy * _ctl_diag_trigger_scsi_store - store the diag_trigger_scsi attribute 3134f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3135f92363d1SSreekanth Reddy * @buf - the buffer returned 3136f92363d1SSreekanth Reddy * 3137f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3138f92363d1SSreekanth Reddy */ 3139f92363d1SSreekanth Reddy static ssize_t 3140f92363d1SSreekanth Reddy _ctl_diag_trigger_scsi_store(struct device *cdev, 3141f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3142f92363d1SSreekanth Reddy { 3143f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3144f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3145f92363d1SSreekanth Reddy unsigned long flags; 3146f92363d1SSreekanth Reddy ssize_t sz; 3147f92363d1SSreekanth Reddy 3148f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3149f92363d1SSreekanth Reddy sz = min(sizeof(struct SL_WH_SCSI_TRIGGERS_T), count); 3150f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_scsi, 0, 3151f92363d1SSreekanth Reddy sizeof(struct SL_WH_EVENT_TRIGGERS_T)); 3152f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_scsi, buf, sz); 3153f92363d1SSreekanth Reddy if (ioc->diag_trigger_scsi.ValidEntries > NUM_VALID_ENTRIES) 3154f92363d1SSreekanth Reddy ioc->diag_trigger_scsi.ValidEntries = NUM_VALID_ENTRIES; 3155f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3156f92363d1SSreekanth Reddy return sz; 3157f92363d1SSreekanth Reddy } 3158f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_scsi, S_IRUGO | S_IWUSR, 3159f92363d1SSreekanth Reddy _ctl_diag_trigger_scsi_show, _ctl_diag_trigger_scsi_store); 3160f92363d1SSreekanth Reddy 3161f92363d1SSreekanth Reddy 3162f92363d1SSreekanth Reddy /** 3163f92363d1SSreekanth Reddy * _ctl_diag_trigger_scsi_show - show the diag_trigger_mpi attribute 3164f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3165f92363d1SSreekanth Reddy * @buf - the buffer returned 3166f92363d1SSreekanth Reddy * 3167f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3168f92363d1SSreekanth Reddy */ 3169f92363d1SSreekanth Reddy static ssize_t 3170f92363d1SSreekanth Reddy _ctl_diag_trigger_mpi_show(struct device *cdev, 3171f92363d1SSreekanth Reddy struct device_attribute *attr, char *buf) 3172f92363d1SSreekanth Reddy { 3173f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3174f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3175f92363d1SSreekanth Reddy unsigned long flags; 3176f92363d1SSreekanth Reddy ssize_t rc; 3177f92363d1SSreekanth Reddy 3178f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3179f92363d1SSreekanth Reddy rc = sizeof(struct SL_WH_MPI_TRIGGERS_T); 3180f92363d1SSreekanth Reddy memcpy(buf, &ioc->diag_trigger_mpi, rc); 3181f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3182f92363d1SSreekanth Reddy return rc; 3183f92363d1SSreekanth Reddy } 3184f92363d1SSreekanth Reddy 3185f92363d1SSreekanth Reddy /** 3186f92363d1SSreekanth Reddy * _ctl_diag_trigger_mpi_store - store the diag_trigger_mpi attribute 3187f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3188f92363d1SSreekanth Reddy * @buf - the buffer returned 3189f92363d1SSreekanth Reddy * 3190f92363d1SSreekanth Reddy * A sysfs 'read/write' shost attribute. 3191f92363d1SSreekanth Reddy */ 3192f92363d1SSreekanth Reddy static ssize_t 3193f92363d1SSreekanth Reddy _ctl_diag_trigger_mpi_store(struct device *cdev, 3194f92363d1SSreekanth Reddy struct device_attribute *attr, const char *buf, size_t count) 3195f92363d1SSreekanth Reddy { 3196f92363d1SSreekanth Reddy struct Scsi_Host *shost = class_to_shost(cdev); 3197f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 3198f92363d1SSreekanth Reddy unsigned long flags; 3199f92363d1SSreekanth Reddy ssize_t sz; 3200f92363d1SSreekanth Reddy 3201f92363d1SSreekanth Reddy spin_lock_irqsave(&ioc->diag_trigger_lock, flags); 3202f92363d1SSreekanth Reddy sz = min(sizeof(struct SL_WH_MPI_TRIGGERS_T), count); 3203f92363d1SSreekanth Reddy memset(&ioc->diag_trigger_mpi, 0, 320466331e8cSDan Carpenter sizeof(ioc->diag_trigger_mpi)); 3205f92363d1SSreekanth Reddy memcpy(&ioc->diag_trigger_mpi, buf, sz); 3206f92363d1SSreekanth Reddy if (ioc->diag_trigger_mpi.ValidEntries > NUM_VALID_ENTRIES) 3207f92363d1SSreekanth Reddy ioc->diag_trigger_mpi.ValidEntries = NUM_VALID_ENTRIES; 3208f92363d1SSreekanth Reddy spin_unlock_irqrestore(&ioc->diag_trigger_lock, flags); 3209f92363d1SSreekanth Reddy return sz; 3210f92363d1SSreekanth Reddy } 3211f92363d1SSreekanth Reddy 3212f92363d1SSreekanth Reddy static DEVICE_ATTR(diag_trigger_mpi, S_IRUGO | S_IWUSR, 3213f92363d1SSreekanth Reddy _ctl_diag_trigger_mpi_show, _ctl_diag_trigger_mpi_store); 3214f92363d1SSreekanth Reddy 3215f92363d1SSreekanth Reddy /*********** diagnostic trigger suppport *** END ****************************/ 3216f92363d1SSreekanth Reddy 3217f92363d1SSreekanth Reddy 3218f92363d1SSreekanth Reddy 3219f92363d1SSreekanth Reddy /*****************************************/ 3220f92363d1SSreekanth Reddy 3221f92363d1SSreekanth Reddy struct device_attribute *mpt3sas_host_attrs[] = { 3222f92363d1SSreekanth Reddy &dev_attr_version_fw, 3223f92363d1SSreekanth Reddy &dev_attr_version_bios, 3224f92363d1SSreekanth Reddy &dev_attr_version_mpi, 3225f92363d1SSreekanth Reddy &dev_attr_version_product, 3226f92363d1SSreekanth Reddy &dev_attr_version_nvdata_persistent, 3227f92363d1SSreekanth Reddy &dev_attr_version_nvdata_default, 3228f92363d1SSreekanth Reddy &dev_attr_board_name, 3229f92363d1SSreekanth Reddy &dev_attr_board_assembly, 3230f92363d1SSreekanth Reddy &dev_attr_board_tracer, 3231f92363d1SSreekanth Reddy &dev_attr_io_delay, 3232f92363d1SSreekanth Reddy &dev_attr_device_delay, 3233f92363d1SSreekanth Reddy &dev_attr_logging_level, 3234f92363d1SSreekanth Reddy &dev_attr_fwfault_debug, 3235f92363d1SSreekanth Reddy &dev_attr_fw_queue_depth, 3236f92363d1SSreekanth Reddy &dev_attr_host_sas_address, 3237f92363d1SSreekanth Reddy &dev_attr_ioc_reset_count, 3238f92363d1SSreekanth Reddy &dev_attr_host_trace_buffer_size, 3239f92363d1SSreekanth Reddy &dev_attr_host_trace_buffer, 3240f92363d1SSreekanth Reddy &dev_attr_host_trace_buffer_enable, 3241f92363d1SSreekanth Reddy &dev_attr_reply_queue_count, 3242f92363d1SSreekanth Reddy &dev_attr_diag_trigger_master, 3243f92363d1SSreekanth Reddy &dev_attr_diag_trigger_event, 3244f92363d1SSreekanth Reddy &dev_attr_diag_trigger_scsi, 3245f92363d1SSreekanth Reddy &dev_attr_diag_trigger_mpi, 3246*42263095SSreekanth Reddy #ifdef SCSI_MPT2SAS 3247*42263095SSreekanth Reddy &dev_attr_BRM_status, 3248*42263095SSreekanth Reddy #endif 3249f92363d1SSreekanth Reddy NULL, 3250f92363d1SSreekanth Reddy }; 3251f92363d1SSreekanth Reddy 3252f92363d1SSreekanth Reddy /* device attributes */ 3253f92363d1SSreekanth Reddy 3254f92363d1SSreekanth Reddy /** 3255f92363d1SSreekanth Reddy * _ctl_device_sas_address_show - sas address 3256f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3257f92363d1SSreekanth Reddy * @buf - the buffer returned 3258f92363d1SSreekanth Reddy * 3259f92363d1SSreekanth Reddy * This is the sas address for the target 3260f92363d1SSreekanth Reddy * 3261f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 3262f92363d1SSreekanth Reddy */ 3263f92363d1SSreekanth Reddy static ssize_t 3264f92363d1SSreekanth Reddy _ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr, 3265f92363d1SSreekanth Reddy char *buf) 3266f92363d1SSreekanth Reddy { 3267f92363d1SSreekanth Reddy struct scsi_device *sdev = to_scsi_device(dev); 3268f92363d1SSreekanth Reddy struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3269f92363d1SSreekanth Reddy 3270f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "0x%016llx\n", 3271f92363d1SSreekanth Reddy (unsigned long long)sas_device_priv_data->sas_target->sas_address); 3272f92363d1SSreekanth Reddy } 3273f92363d1SSreekanth Reddy static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL); 3274f92363d1SSreekanth Reddy 3275f92363d1SSreekanth Reddy /** 3276f92363d1SSreekanth Reddy * _ctl_device_handle_show - device handle 3277f92363d1SSreekanth Reddy * @cdev - pointer to embedded class device 3278f92363d1SSreekanth Reddy * @buf - the buffer returned 3279f92363d1SSreekanth Reddy * 3280f92363d1SSreekanth Reddy * This is the firmware assigned device handle 3281f92363d1SSreekanth Reddy * 3282f92363d1SSreekanth Reddy * A sysfs 'read-only' shost attribute. 3283f92363d1SSreekanth Reddy */ 3284f92363d1SSreekanth Reddy static ssize_t 3285f92363d1SSreekanth Reddy _ctl_device_handle_show(struct device *dev, struct device_attribute *attr, 3286f92363d1SSreekanth Reddy char *buf) 3287f92363d1SSreekanth Reddy { 3288f92363d1SSreekanth Reddy struct scsi_device *sdev = to_scsi_device(dev); 3289f92363d1SSreekanth Reddy struct MPT3SAS_DEVICE *sas_device_priv_data = sdev->hostdata; 3290f92363d1SSreekanth Reddy 3291f92363d1SSreekanth Reddy return snprintf(buf, PAGE_SIZE, "0x%04x\n", 3292f92363d1SSreekanth Reddy sas_device_priv_data->sas_target->handle); 3293f92363d1SSreekanth Reddy } 3294f92363d1SSreekanth Reddy static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL); 3295f92363d1SSreekanth Reddy 3296f92363d1SSreekanth Reddy struct device_attribute *mpt3sas_dev_attrs[] = { 3297f92363d1SSreekanth Reddy &dev_attr_sas_address, 3298f92363d1SSreekanth Reddy &dev_attr_sas_device_handle, 3299f92363d1SSreekanth Reddy NULL, 3300f92363d1SSreekanth Reddy }; 3301f92363d1SSreekanth Reddy 3302f92363d1SSreekanth Reddy /** 33038a7e4c24SSreekanth Reddy * ctl_init - main entry point for ctl. 3304f92363d1SSreekanth Reddy * 3305f92363d1SSreekanth Reddy */ 3306f92363d1SSreekanth Reddy void 33078a7e4c24SSreekanth Reddy ctl_init(void) 3308f92363d1SSreekanth Reddy { 3309f92363d1SSreekanth Reddy async_queue = NULL; 3310f92363d1SSreekanth Reddy init_waitqueue_head(&ctl_poll_wait); 3311f92363d1SSreekanth Reddy } 3312f92363d1SSreekanth Reddy 3313f92363d1SSreekanth Reddy /** 33148a7e4c24SSreekanth Reddy * ctl_exit - exit point for ctl 3315f92363d1SSreekanth Reddy * 3316f92363d1SSreekanth Reddy */ 3317f92363d1SSreekanth Reddy void 33188a7e4c24SSreekanth Reddy ctl_exit(void) 3319f92363d1SSreekanth Reddy { 3320f92363d1SSreekanth Reddy struct MPT3SAS_ADAPTER *ioc; 3321f92363d1SSreekanth Reddy int i; 3322f92363d1SSreekanth Reddy 3323f92363d1SSreekanth Reddy list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { 3324f92363d1SSreekanth Reddy 3325f92363d1SSreekanth Reddy /* free memory associated to diag buffers */ 3326f92363d1SSreekanth Reddy for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { 3327f92363d1SSreekanth Reddy if (!ioc->diag_buffer[i]) 3328f92363d1SSreekanth Reddy continue; 3329f92363d1SSreekanth Reddy if (!(ioc->diag_buffer_status[i] & 3330f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_REGISTERED)) 3331f92363d1SSreekanth Reddy continue; 3332f92363d1SSreekanth Reddy if ((ioc->diag_buffer_status[i] & 3333f92363d1SSreekanth Reddy MPT3_DIAG_BUFFER_IS_RELEASED)) 3334f92363d1SSreekanth Reddy continue; 3335f92363d1SSreekanth Reddy pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i], 3336f92363d1SSreekanth Reddy ioc->diag_buffer[i], ioc->diag_buffer_dma[i]); 3337f92363d1SSreekanth Reddy ioc->diag_buffer[i] = NULL; 3338f92363d1SSreekanth Reddy ioc->diag_buffer_status[i] = 0; 3339f92363d1SSreekanth Reddy } 3340f92363d1SSreekanth Reddy 3341f92363d1SSreekanth Reddy kfree(ioc->event_log); 3342f92363d1SSreekanth Reddy } 3343f92363d1SSreekanth Reddy } 3344