mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 10:32:35 +00:00
3cb5469a2a
fixes surrounding PCIe enhanced error handling: (1) We need to reject all request generated internaly inside the driver as well as request arriving from the scsi mid layer when PCIe EEH is active. The fix is to add a per adapter flag called pci_error_recovery which is checked thru out the driver when request are generated. (2) We don't need to call the pci_driver->remove directly from the PCIe callbacks becuase its already called from the PCIe EEH code. In its place we are shutting down the watchdog timer, and flushing back all pending IO. (3) We need to save and restore the pci state across PCIe EEH handling. Signed-off-by: Eric Moore <eric.moore@lsi.com> Signed-off-by: James Bottomley <James.Bottomley@suse.de>
3005 lines
85 KiB
C
3005 lines
85 KiB
C
/*
|
|
* Management Module Support for MPT (Message Passing Technology) based
|
|
* controllers
|
|
*
|
|
* This code is based on drivers/scsi/mpt2sas/mpt2_ctl.c
|
|
* Copyright (C) 2007-2010 LSI Corporation
|
|
* (mailto:DL-MPTFusionLinux@lsi.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* NO WARRANTY
|
|
* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
|
|
* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
|
|
* solely responsible for determining the appropriateness of using and
|
|
* distributing the Program and assumes all risks associated with its
|
|
* exercise of rights under this Agreement, including but not limited to
|
|
* the risks and costs of program errors, damage to or loss of data,
|
|
* programs or equipment, and unavailability or interruption of operations.
|
|
|
|
* DISCLAIMER OF LIABILITY
|
|
* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
|
|
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
|
|
* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
|
|
* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
* USA.
|
|
*/
|
|
|
|
#include <linux/version.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/types.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/compat.h>
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/io.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
#include "mpt2sas_base.h"
|
|
#include "mpt2sas_ctl.h"
|
|
|
|
static struct fasync_struct *async_queue;
|
|
static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait);
|
|
|
|
static int _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type,
|
|
u8 *issue_reset);
|
|
|
|
/**
|
|
* enum block_state - blocking state
|
|
* @NON_BLOCKING: non blocking
|
|
* @BLOCKING: blocking
|
|
*
|
|
* These states are for ioctls that need to wait for a response
|
|
* from firmware, so they probably require sleep.
|
|
*/
|
|
enum block_state {
|
|
NON_BLOCKING,
|
|
BLOCKING,
|
|
};
|
|
|
|
/**
|
|
* _ctl_sas_device_find_by_handle - sas device search
|
|
* @ioc: per adapter object
|
|
* @handle: sas device handle (assigned by firmware)
|
|
* Context: Calling function should acquire ioc->sas_device_lock
|
|
*
|
|
* This searches for sas_device based on sas_address, then return sas_device
|
|
* object.
|
|
*/
|
|
static struct _sas_device *
|
|
_ctl_sas_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
|
|
{
|
|
struct _sas_device *sas_device, *r;
|
|
|
|
r = NULL;
|
|
list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
|
|
if (sas_device->handle != handle)
|
|
continue;
|
|
r = sas_device;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
return r;
|
|
}
|
|
|
|
#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
|
|
/**
|
|
* _ctl_display_some_debug - debug routine
|
|
* @ioc: per adapter object
|
|
* @smid: system request message index
|
|
* @calling_function_name: string pass from calling function
|
|
* @mpi_reply: reply message frame
|
|
* Context: none.
|
|
*
|
|
* Function for displaying debug info helpfull when debugging issues
|
|
* in this module.
|
|
*/
|
|
static void
|
|
_ctl_display_some_debug(struct MPT2SAS_ADAPTER *ioc, u16 smid,
|
|
char *calling_function_name, MPI2DefaultReply_t *mpi_reply)
|
|
{
|
|
Mpi2ConfigRequest_t *mpi_request;
|
|
char *desc = NULL;
|
|
|
|
if (!(ioc->logging_level & MPT_DEBUG_IOCTL))
|
|
return;
|
|
|
|
mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
|
|
switch (mpi_request->Function) {
|
|
case MPI2_FUNCTION_SCSI_IO_REQUEST:
|
|
{
|
|
Mpi2SCSIIORequest_t *scsi_request =
|
|
(Mpi2SCSIIORequest_t *)mpi_request;
|
|
|
|
snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
|
|
"scsi_io, cmd(0x%02x), cdb_len(%d)",
|
|
scsi_request->CDB.CDB32[0],
|
|
le16_to_cpu(scsi_request->IoFlags) & 0xF);
|
|
desc = ioc->tmp_string;
|
|
break;
|
|
}
|
|
case MPI2_FUNCTION_SCSI_TASK_MGMT:
|
|
desc = "task_mgmt";
|
|
break;
|
|
case MPI2_FUNCTION_IOC_INIT:
|
|
desc = "ioc_init";
|
|
break;
|
|
case MPI2_FUNCTION_IOC_FACTS:
|
|
desc = "ioc_facts";
|
|
break;
|
|
case MPI2_FUNCTION_CONFIG:
|
|
{
|
|
Mpi2ConfigRequest_t *config_request =
|
|
(Mpi2ConfigRequest_t *)mpi_request;
|
|
|
|
snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
|
|
"config, type(0x%02x), ext_type(0x%02x), number(%d)",
|
|
(config_request->Header.PageType &
|
|
MPI2_CONFIG_PAGETYPE_MASK), config_request->ExtPageType,
|
|
config_request->Header.PageNumber);
|
|
desc = ioc->tmp_string;
|
|
break;
|
|
}
|
|
case MPI2_FUNCTION_PORT_FACTS:
|
|
desc = "port_facts";
|
|
break;
|
|
case MPI2_FUNCTION_PORT_ENABLE:
|
|
desc = "port_enable";
|
|
break;
|
|
case MPI2_FUNCTION_EVENT_NOTIFICATION:
|
|
desc = "event_notification";
|
|
break;
|
|
case MPI2_FUNCTION_FW_DOWNLOAD:
|
|
desc = "fw_download";
|
|
break;
|
|
case MPI2_FUNCTION_FW_UPLOAD:
|
|
desc = "fw_upload";
|
|
break;
|
|
case MPI2_FUNCTION_RAID_ACTION:
|
|
desc = "raid_action";
|
|
break;
|
|
case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
|
|
{
|
|
Mpi2SCSIIORequest_t *scsi_request =
|
|
(Mpi2SCSIIORequest_t *)mpi_request;
|
|
|
|
snprintf(ioc->tmp_string, MPT_STRING_LENGTH,
|
|
"raid_pass, cmd(0x%02x), cdb_len(%d)",
|
|
scsi_request->CDB.CDB32[0],
|
|
le16_to_cpu(scsi_request->IoFlags) & 0xF);
|
|
desc = ioc->tmp_string;
|
|
break;
|
|
}
|
|
case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
|
|
desc = "sas_iounit_cntl";
|
|
break;
|
|
case MPI2_FUNCTION_SATA_PASSTHROUGH:
|
|
desc = "sata_pass";
|
|
break;
|
|
case MPI2_FUNCTION_DIAG_BUFFER_POST:
|
|
desc = "diag_buffer_post";
|
|
break;
|
|
case MPI2_FUNCTION_DIAG_RELEASE:
|
|
desc = "diag_release";
|
|
break;
|
|
case MPI2_FUNCTION_SMP_PASSTHROUGH:
|
|
desc = "smp_passthrough";
|
|
break;
|
|
}
|
|
|
|
if (!desc)
|
|
return;
|
|
|
|
printk(MPT2SAS_INFO_FMT "%s: %s, smid(%d)\n",
|
|
ioc->name, calling_function_name, desc, smid);
|
|
|
|
if (!mpi_reply)
|
|
return;
|
|
|
|
if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
|
|
printk(MPT2SAS_INFO_FMT
|
|
"\tiocstatus(0x%04x), loginfo(0x%08x)\n",
|
|
ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
|
|
le32_to_cpu(mpi_reply->IOCLogInfo));
|
|
|
|
if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
|
|
mpi_request->Function ==
|
|
MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
|
|
Mpi2SCSIIOReply_t *scsi_reply =
|
|
(Mpi2SCSIIOReply_t *)mpi_reply;
|
|
struct _sas_device *sas_device = NULL;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&ioc->sas_device_lock, flags);
|
|
sas_device = _ctl_sas_device_find_by_handle(ioc,
|
|
le16_to_cpu(scsi_reply->DevHandle));
|
|
if (sas_device) {
|
|
printk(MPT2SAS_WARN_FMT "\tsas_address(0x%016llx), "
|
|
"phy(%d)\n", ioc->name, (unsigned long long)
|
|
sas_device->sas_address, sas_device->phy);
|
|
printk(MPT2SAS_WARN_FMT
|
|
"\tenclosure_logical_id(0x%016llx), slot(%d)\n",
|
|
ioc->name, sas_device->enclosure_logical_id,
|
|
sas_device->slot);
|
|
}
|
|
spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
|
|
if (scsi_reply->SCSIState || scsi_reply->SCSIStatus)
|
|
printk(MPT2SAS_INFO_FMT
|
|
"\tscsi_state(0x%02x), scsi_status"
|
|
"(0x%02x)\n", ioc->name,
|
|
scsi_reply->SCSIState,
|
|
scsi_reply->SCSIStatus);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* mpt2sas_ctl_done - ctl module completion routine
|
|
* @ioc: per adapter object
|
|
* @smid: system request message index
|
|
* @msix_index: MSIX table index supplied by the OS
|
|
* @reply: reply message frame(lower 32bit addr)
|
|
* Context: none.
|
|
*
|
|
* The callback handler when using ioc->ctl_cb_idx.
|
|
*
|
|
* Return 1 meaning mf should be freed from _base_interrupt
|
|
* 0 means the mf is freed from this function.
|
|
*/
|
|
u8
|
|
mpt2sas_ctl_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
|
|
u32 reply)
|
|
{
|
|
MPI2DefaultReply_t *mpi_reply;
|
|
Mpi2SCSIIOReply_t *scsiio_reply;
|
|
const void *sense_data;
|
|
u32 sz;
|
|
|
|
if (ioc->ctl_cmds.status == MPT2_CMD_NOT_USED)
|
|
return 1;
|
|
if (ioc->ctl_cmds.smid != smid)
|
|
return 1;
|
|
ioc->ctl_cmds.status |= MPT2_CMD_COMPLETE;
|
|
mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
|
|
if (mpi_reply) {
|
|
memcpy(ioc->ctl_cmds.reply, mpi_reply, mpi_reply->MsgLength*4);
|
|
ioc->ctl_cmds.status |= MPT2_CMD_REPLY_VALID;
|
|
/* get sense data */
|
|
if (mpi_reply->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
|
|
mpi_reply->Function ==
|
|
MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
|
|
scsiio_reply = (Mpi2SCSIIOReply_t *)mpi_reply;
|
|
if (scsiio_reply->SCSIState &
|
|
MPI2_SCSI_STATE_AUTOSENSE_VALID) {
|
|
sz = min_t(u32, SCSI_SENSE_BUFFERSIZE,
|
|
le32_to_cpu(scsiio_reply->SenseCount));
|
|
sense_data = mpt2sas_base_get_sense_buffer(ioc,
|
|
smid);
|
|
memcpy(ioc->ctl_cmds.sense, sense_data, sz);
|
|
}
|
|
}
|
|
}
|
|
#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
|
|
_ctl_display_some_debug(ioc, smid, "ctl_done", mpi_reply);
|
|
#endif
|
|
ioc->ctl_cmds.status &= ~MPT2_CMD_PENDING;
|
|
complete(&ioc->ctl_cmds.done);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* _ctl_check_event_type - determines when an event needs logging
|
|
* @ioc: per adapter object
|
|
* @event: firmware event
|
|
*
|
|
* The bitmask in ioc->event_type[] indicates which events should be
|
|
* be saved in the driver event_log. This bitmask is set by application.
|
|
*
|
|
* Returns 1 when event should be captured, or zero means no match.
|
|
*/
|
|
static int
|
|
_ctl_check_event_type(struct MPT2SAS_ADAPTER *ioc, u16 event)
|
|
{
|
|
u16 i;
|
|
u32 desired_event;
|
|
|
|
if (event >= 128 || !event || !ioc->event_log)
|
|
return 0;
|
|
|
|
desired_event = (1 << (event % 32));
|
|
if (!desired_event)
|
|
desired_event = 1;
|
|
i = event / 32;
|
|
return desired_event & ioc->event_type[i];
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_ctl_add_to_event_log - add event
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply message frame
|
|
*
|
|
* Return nothing.
|
|
*/
|
|
void
|
|
mpt2sas_ctl_add_to_event_log(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2EventNotificationReply_t *mpi_reply)
|
|
{
|
|
struct MPT2_IOCTL_EVENTS *event_log;
|
|
u16 event;
|
|
int i;
|
|
u32 sz, event_data_sz;
|
|
u8 send_aen = 0;
|
|
|
|
if (!ioc->event_log)
|
|
return;
|
|
|
|
event = le16_to_cpu(mpi_reply->Event);
|
|
|
|
if (_ctl_check_event_type(ioc, event)) {
|
|
|
|
/* insert entry into circular event_log */
|
|
i = ioc->event_context % MPT2SAS_CTL_EVENT_LOG_SIZE;
|
|
event_log = ioc->event_log;
|
|
event_log[i].event = event;
|
|
event_log[i].context = ioc->event_context++;
|
|
|
|
event_data_sz = le16_to_cpu(mpi_reply->EventDataLength)*4;
|
|
sz = min_t(u32, event_data_sz, MPT2_EVENT_DATA_SIZE);
|
|
memset(event_log[i].data, 0, MPT2_EVENT_DATA_SIZE);
|
|
memcpy(event_log[i].data, mpi_reply->EventData, sz);
|
|
send_aen = 1;
|
|
}
|
|
|
|
/* This aen_event_read_flag flag is set until the
|
|
* application has read the event log.
|
|
* For MPI2_EVENT_LOG_ENTRY_ADDED, we always notify.
|
|
*/
|
|
if (event == MPI2_EVENT_LOG_ENTRY_ADDED ||
|
|
(send_aen && !ioc->aen_event_read_flag)) {
|
|
ioc->aen_event_read_flag = 1;
|
|
wake_up_interruptible(&ctl_poll_wait);
|
|
if (async_queue)
|
|
kill_fasync(&async_queue, SIGIO, POLL_IN);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_ctl_event_callback - firmware event handler (called at ISR time)
|
|
* @ioc: per adapter object
|
|
* @msix_index: MSIX table index supplied by the OS
|
|
* @reply: reply message frame(lower 32bit addr)
|
|
* Context: interrupt.
|
|
*
|
|
* This function merely adds a new work task into ioc->firmware_event_thread.
|
|
* The tasks are worked from _firmware_event_work in user context.
|
|
*
|
|
* Return 1 meaning mf should be freed from _base_interrupt
|
|
* 0 means the mf is freed from this function.
|
|
*/
|
|
u8
|
|
mpt2sas_ctl_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
|
|
u32 reply)
|
|
{
|
|
Mpi2EventNotificationReply_t *mpi_reply;
|
|
|
|
mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
|
|
mpt2sas_ctl_add_to_event_log(ioc, mpi_reply);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* _ctl_verify_adapter - validates ioc_number passed from application
|
|
* @ioc: per adapter object
|
|
* @iocpp: The ioc pointer is returned in this.
|
|
*
|
|
* Return (-1) means error, else ioc_number.
|
|
*/
|
|
static int
|
|
_ctl_verify_adapter(int ioc_number, struct MPT2SAS_ADAPTER **iocpp)
|
|
{
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
|
|
list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
|
|
if (ioc->id != ioc_number)
|
|
continue;
|
|
*iocpp = ioc;
|
|
return ioc_number;
|
|
}
|
|
*iocpp = NULL;
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_ctl_reset_handler - reset callback handler (for ctl)
|
|
* @ioc: per adapter object
|
|
* @reset_phase: phase
|
|
*
|
|
* The handler for doing any required cleanup or initialization.
|
|
*
|
|
* The reset phase can be MPT2_IOC_PRE_RESET, MPT2_IOC_AFTER_RESET,
|
|
* MPT2_IOC_DONE_RESET
|
|
*/
|
|
void
|
|
mpt2sas_ctl_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
|
|
{
|
|
int i;
|
|
u8 issue_reset;
|
|
|
|
switch (reset_phase) {
|
|
case MPT2_IOC_PRE_RESET:
|
|
dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
|
|
"MPT2_IOC_PRE_RESET\n", ioc->name, __func__));
|
|
for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
|
|
if (!(ioc->diag_buffer_status[i] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED))
|
|
continue;
|
|
if ((ioc->diag_buffer_status[i] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED))
|
|
continue;
|
|
_ctl_send_release(ioc, i, &issue_reset);
|
|
}
|
|
break;
|
|
case MPT2_IOC_AFTER_RESET:
|
|
dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
|
|
"MPT2_IOC_AFTER_RESET\n", ioc->name, __func__));
|
|
if (ioc->ctl_cmds.status & MPT2_CMD_PENDING) {
|
|
ioc->ctl_cmds.status |= MPT2_CMD_RESET;
|
|
mpt2sas_base_free_smid(ioc, ioc->ctl_cmds.smid);
|
|
complete(&ioc->ctl_cmds.done);
|
|
}
|
|
break;
|
|
case MPT2_IOC_DONE_RESET:
|
|
dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
|
|
"MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
|
|
|
|
for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
|
|
if (!(ioc->diag_buffer_status[i] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED))
|
|
continue;
|
|
if ((ioc->diag_buffer_status[i] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED))
|
|
continue;
|
|
ioc->diag_buffer_status[i] |=
|
|
MPT2_DIAG_BUFFER_IS_DIAG_RESET;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* _ctl_fasync -
|
|
* @fd -
|
|
* @filep -
|
|
* @mode -
|
|
*
|
|
* Called when application request fasyn callback handler.
|
|
*/
|
|
static int
|
|
_ctl_fasync(int fd, struct file *filep, int mode)
|
|
{
|
|
return fasync_helper(fd, filep, mode, &async_queue);
|
|
}
|
|
|
|
/**
|
|
* _ctl_release -
|
|
* @inode -
|
|
* @filep -
|
|
*
|
|
* Called when application releases the fasyn callback handler.
|
|
*/
|
|
static int
|
|
_ctl_release(struct inode *inode, struct file *filep)
|
|
{
|
|
return fasync_helper(-1, filep, 0, &async_queue);
|
|
}
|
|
|
|
/**
|
|
* _ctl_poll -
|
|
* @file -
|
|
* @wait -
|
|
*
|
|
*/
|
|
static unsigned int
|
|
_ctl_poll(struct file *filep, poll_table *wait)
|
|
{
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
|
|
poll_wait(filep, &ctl_poll_wait, wait);
|
|
|
|
list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
|
|
if (ioc->aen_event_read_flag)
|
|
return POLLIN | POLLRDNORM;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_set_task_mid - assign an active smid to tm request
|
|
* @ioc: per adapter object
|
|
* @karg - (struct mpt2_ioctl_command)
|
|
* @tm_request - pointer to mf from user space
|
|
*
|
|
* Returns 0 when an smid if found, else fail.
|
|
* during failure, the reply frame is filled.
|
|
*/
|
|
static int
|
|
_ctl_set_task_mid(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command *karg,
|
|
Mpi2SCSITaskManagementRequest_t *tm_request)
|
|
{
|
|
u8 found = 0;
|
|
u16 i;
|
|
u16 handle;
|
|
struct scsi_cmnd *scmd;
|
|
struct MPT2SAS_DEVICE *priv_data;
|
|
unsigned long flags;
|
|
Mpi2SCSITaskManagementReply_t *tm_reply;
|
|
u32 sz;
|
|
u32 lun;
|
|
char *desc = NULL;
|
|
|
|
if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK)
|
|
desc = "abort_task";
|
|
else if (tm_request->TaskType == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK)
|
|
desc = "query_task";
|
|
else
|
|
return 0;
|
|
|
|
lun = scsilun_to_int((struct scsi_lun *)tm_request->LUN);
|
|
|
|
handle = le16_to_cpu(tm_request->DevHandle);
|
|
spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
|
|
for (i = ioc->scsiio_depth; i && !found; i--) {
|
|
scmd = ioc->scsi_lookup[i - 1].scmd;
|
|
if (scmd == NULL || scmd->device == NULL ||
|
|
scmd->device->hostdata == NULL)
|
|
continue;
|
|
if (lun != scmd->device->lun)
|
|
continue;
|
|
priv_data = scmd->device->hostdata;
|
|
if (priv_data->sas_target == NULL)
|
|
continue;
|
|
if (priv_data->sas_target->handle != handle)
|
|
continue;
|
|
tm_request->TaskMID = cpu_to_le16(ioc->scsi_lookup[i - 1].smid);
|
|
found = 1;
|
|
}
|
|
spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
|
|
|
|
if (!found) {
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
|
|
"handle(0x%04x), lun(%d), no active mid!!\n", ioc->name,
|
|
desc, le16_to_cpu(tm_request->DevHandle), lun));
|
|
tm_reply = ioc->ctl_cmds.reply;
|
|
tm_reply->DevHandle = tm_request->DevHandle;
|
|
tm_reply->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
|
|
tm_reply->TaskType = tm_request->TaskType;
|
|
tm_reply->MsgLength = sizeof(Mpi2SCSITaskManagementReply_t)/4;
|
|
tm_reply->VP_ID = tm_request->VP_ID;
|
|
tm_reply->VF_ID = tm_request->VF_ID;
|
|
sz = min_t(u32, karg->max_reply_bytes, ioc->reply_sz);
|
|
if (copy_to_user(karg->reply_frame_buf_ptr, ioc->ctl_cmds.reply,
|
|
sz))
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
|
|
__LINE__, __func__);
|
|
return 1;
|
|
}
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
|
|
"handle(0x%04x), lun(%d), task_mid(%d)\n", ioc->name,
|
|
desc, le16_to_cpu(tm_request->DevHandle), lun,
|
|
le16_to_cpu(tm_request->TaskMID)));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_do_mpt_command - main handler for MPT2COMMAND opcode
|
|
* @ioc: per adapter object
|
|
* @karg - (struct mpt2_ioctl_command)
|
|
* @mf - pointer to mf in user space
|
|
* @state - NON_BLOCKING or BLOCKING
|
|
*/
|
|
static long
|
|
_ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
|
|
struct mpt2_ioctl_command karg, void __user *mf, enum block_state state)
|
|
{
|
|
MPI2RequestHeader_t *mpi_request = NULL, *request;
|
|
MPI2DefaultReply_t *mpi_reply;
|
|
u32 ioc_state;
|
|
u16 ioc_status;
|
|
u16 smid;
|
|
unsigned long timeout, timeleft;
|
|
u8 issue_reset;
|
|
u32 sz;
|
|
void *psge;
|
|
void *data_out = NULL;
|
|
dma_addr_t data_out_dma;
|
|
size_t data_out_sz = 0;
|
|
void *data_in = NULL;
|
|
dma_addr_t data_in_dma;
|
|
size_t data_in_sz = 0;
|
|
u32 sgl_flags;
|
|
long ret;
|
|
u16 wait_state_count;
|
|
|
|
issue_reset = 0;
|
|
|
|
if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
|
|
return -EAGAIN;
|
|
else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
|
|
return -ERESTARTSYS;
|
|
|
|
if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
|
|
printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
|
|
ioc->name, __func__);
|
|
ret = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
wait_state_count = 0;
|
|
ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
|
|
while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
|
|
if (wait_state_count++ == 10) {
|
|
printk(MPT2SAS_ERR_FMT
|
|
"%s: failed due to ioc not operational\n",
|
|
ioc->name, __func__);
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
ssleep(1);
|
|
ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
|
|
printk(MPT2SAS_INFO_FMT "%s: waiting for "
|
|
"operational state(count=%d)\n", ioc->name,
|
|
__func__, wait_state_count);
|
|
}
|
|
if (wait_state_count)
|
|
printk(MPT2SAS_INFO_FMT "%s: ioc is operational\n",
|
|
ioc->name, __func__);
|
|
|
|
mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL);
|
|
if (!mpi_request) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed obtaining a memory for "
|
|
"mpi_request\n", ioc->name, __func__);
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
/* copy in request message frame from user */
|
|
if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__, __LINE__,
|
|
__func__);
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
|
|
smid = mpt2sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx);
|
|
if (!smid) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
|
|
ioc->name, __func__);
|
|
ret = -EAGAIN;
|
|
goto out;
|
|
}
|
|
} else {
|
|
|
|
smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->ctl_cb_idx, NULL);
|
|
if (!smid) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
|
|
ioc->name, __func__);
|
|
ret = -EAGAIN;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret = 0;
|
|
ioc->ctl_cmds.status = MPT2_CMD_PENDING;
|
|
memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
|
|
request = mpt2sas_base_get_msg_frame(ioc, smid);
|
|
memcpy(request, mpi_request, karg.data_sge_offset*4);
|
|
ioc->ctl_cmds.smid = smid;
|
|
data_out_sz = karg.data_out_size;
|
|
data_in_sz = karg.data_in_size;
|
|
|
|
if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
|
|
mpi_request->Function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) {
|
|
if (!le16_to_cpu(mpi_request->FunctionDependent1) ||
|
|
le16_to_cpu(mpi_request->FunctionDependent1) >
|
|
ioc->facts.MaxDevHandle) {
|
|
ret = -EINVAL;
|
|
mpt2sas_base_free_smid(ioc, smid);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/* obtain dma-able memory for data transfer */
|
|
if (data_out_sz) /* WRITE */ {
|
|
data_out = pci_alloc_consistent(ioc->pdev, data_out_sz,
|
|
&data_out_dma);
|
|
if (!data_out) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
|
|
__LINE__, __func__);
|
|
ret = -ENOMEM;
|
|
mpt2sas_base_free_smid(ioc, smid);
|
|
goto out;
|
|
}
|
|
if (copy_from_user(data_out, karg.data_out_buf_ptr,
|
|
data_out_sz)) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
|
|
__LINE__, __func__);
|
|
ret = -EFAULT;
|
|
mpt2sas_base_free_smid(ioc, smid);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
if (data_in_sz) /* READ */ {
|
|
data_in = pci_alloc_consistent(ioc->pdev, data_in_sz,
|
|
&data_in_dma);
|
|
if (!data_in) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
|
|
__LINE__, __func__);
|
|
ret = -ENOMEM;
|
|
mpt2sas_base_free_smid(ioc, smid);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/* add scatter gather elements */
|
|
psge = (void *)request + (karg.data_sge_offset*4);
|
|
|
|
if (!data_out_sz && !data_in_sz) {
|
|
mpt2sas_base_build_zero_len_sge(ioc, psge);
|
|
} else if (data_out_sz && data_in_sz) {
|
|
/* WRITE sgel first */
|
|
sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
|
|
MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
|
|
sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
|
|
ioc->base_add_sg_single(psge, sgl_flags |
|
|
data_out_sz, data_out_dma);
|
|
|
|
/* incr sgel */
|
|
psge += ioc->sge_size;
|
|
|
|
/* READ sgel last */
|
|
sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
|
|
MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
|
|
MPI2_SGE_FLAGS_END_OF_LIST);
|
|
sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
|
|
ioc->base_add_sg_single(psge, sgl_flags |
|
|
data_in_sz, data_in_dma);
|
|
} else if (data_out_sz) /* WRITE */ {
|
|
sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
|
|
MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
|
|
MPI2_SGE_FLAGS_END_OF_LIST | MPI2_SGE_FLAGS_HOST_TO_IOC);
|
|
sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
|
|
ioc->base_add_sg_single(psge, sgl_flags |
|
|
data_out_sz, data_out_dma);
|
|
} else if (data_in_sz) /* READ */ {
|
|
sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
|
|
MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
|
|
MPI2_SGE_FLAGS_END_OF_LIST);
|
|
sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
|
|
ioc->base_add_sg_single(psge, sgl_flags |
|
|
data_in_sz, data_in_dma);
|
|
}
|
|
|
|
/* send command to firmware */
|
|
#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
|
|
_ctl_display_some_debug(ioc, smid, "ctl_request", NULL);
|
|
#endif
|
|
|
|
switch (mpi_request->Function) {
|
|
case MPI2_FUNCTION_SCSI_IO_REQUEST:
|
|
case MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
|
|
{
|
|
Mpi2SCSIIORequest_t *scsiio_request =
|
|
(Mpi2SCSIIORequest_t *)request;
|
|
scsiio_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
|
|
scsiio_request->SenseBufferLowAddress =
|
|
mpt2sas_base_get_sense_buffer_dma(ioc, smid);
|
|
memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE);
|
|
if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)
|
|
mpt2sas_base_put_smid_scsi_io(ioc, smid,
|
|
le16_to_cpu(mpi_request->FunctionDependent1));
|
|
else
|
|
mpt2sas_base_put_smid_default(ioc, smid);
|
|
break;
|
|
}
|
|
case MPI2_FUNCTION_SCSI_TASK_MGMT:
|
|
{
|
|
Mpi2SCSITaskManagementRequest_t *tm_request =
|
|
(Mpi2SCSITaskManagementRequest_t *)request;
|
|
|
|
dtmprintk(ioc, printk(MPT2SAS_INFO_FMT "TASK_MGMT: "
|
|
"handle(0x%04x), task_type(0x%02x)\n", ioc->name,
|
|
le16_to_cpu(tm_request->DevHandle), tm_request->TaskType));
|
|
|
|
if (tm_request->TaskType ==
|
|
MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK ||
|
|
tm_request->TaskType ==
|
|
MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {
|
|
if (_ctl_set_task_mid(ioc, &karg, tm_request)) {
|
|
mpt2sas_base_free_smid(ioc, smid);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
mpt2sas_scsih_set_tm_flag(ioc, le16_to_cpu(
|
|
tm_request->DevHandle));
|
|
mpt2sas_base_put_smid_hi_priority(ioc, smid);
|
|
break;
|
|
}
|
|
case MPI2_FUNCTION_SMP_PASSTHROUGH:
|
|
{
|
|
Mpi2SmpPassthroughRequest_t *smp_request =
|
|
(Mpi2SmpPassthroughRequest_t *)mpi_request;
|
|
u8 *data;
|
|
|
|
/* ioc determines which port to use */
|
|
smp_request->PhysicalPort = 0xFF;
|
|
if (smp_request->PassthroughFlags &
|
|
MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE)
|
|
data = (u8 *)&smp_request->SGL;
|
|
else
|
|
data = data_out;
|
|
|
|
if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
|
|
ioc->ioc_link_reset_in_progress = 1;
|
|
ioc->ignore_loginfos = 1;
|
|
}
|
|
mpt2sas_base_put_smid_default(ioc, smid);
|
|
break;
|
|
}
|
|
case MPI2_FUNCTION_SAS_IO_UNIT_CONTROL:
|
|
{
|
|
Mpi2SasIoUnitControlRequest_t *sasiounit_request =
|
|
(Mpi2SasIoUnitControlRequest_t *)mpi_request;
|
|
|
|
if (sasiounit_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET
|
|
|| sasiounit_request->Operation ==
|
|
MPI2_SAS_OP_PHY_LINK_RESET) {
|
|
ioc->ioc_link_reset_in_progress = 1;
|
|
ioc->ignore_loginfos = 1;
|
|
}
|
|
mpt2sas_base_put_smid_default(ioc, smid);
|
|
break;
|
|
}
|
|
default:
|
|
mpt2sas_base_put_smid_default(ioc, smid);
|
|
break;
|
|
}
|
|
|
|
if (karg.timeout < MPT2_IOCTL_DEFAULT_TIMEOUT)
|
|
timeout = MPT2_IOCTL_DEFAULT_TIMEOUT;
|
|
else
|
|
timeout = karg.timeout;
|
|
init_completion(&ioc->ctl_cmds.done);
|
|
timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
|
|
timeout*HZ);
|
|
if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
|
|
Mpi2SCSITaskManagementRequest_t *tm_request =
|
|
(Mpi2SCSITaskManagementRequest_t *)mpi_request;
|
|
mpt2sas_scsih_clear_tm_flag(ioc, le16_to_cpu(
|
|
tm_request->DevHandle));
|
|
} else if ((mpi_request->Function == MPI2_FUNCTION_SMP_PASSTHROUGH ||
|
|
mpi_request->Function == MPI2_FUNCTION_SAS_IO_UNIT_CONTROL) &&
|
|
ioc->ioc_link_reset_in_progress) {
|
|
ioc->ioc_link_reset_in_progress = 0;
|
|
ioc->ignore_loginfos = 0;
|
|
}
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
|
|
__func__);
|
|
_debug_dump_mf(mpi_request, karg.data_sge_offset);
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
|
|
issue_reset = 1;
|
|
goto issue_host_reset;
|
|
}
|
|
|
|
mpi_reply = ioc->ctl_cmds.reply;
|
|
ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
|
|
|
|
#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
|
|
if (mpi_reply->Function == MPI2_FUNCTION_SCSI_TASK_MGMT &&
|
|
(ioc->logging_level & MPT_DEBUG_TM)) {
|
|
Mpi2SCSITaskManagementReply_t *tm_reply =
|
|
(Mpi2SCSITaskManagementReply_t *)mpi_reply;
|
|
|
|
printk(MPT2SAS_INFO_FMT "TASK_MGMT: "
|
|
"IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
|
|
"TerminationCount(0x%08x)\n", ioc->name,
|
|
le16_to_cpu(tm_reply->IOCStatus),
|
|
le32_to_cpu(tm_reply->IOCLogInfo),
|
|
le32_to_cpu(tm_reply->TerminationCount));
|
|
}
|
|
#endif
|
|
/* copy out xdata to user */
|
|
if (data_in_sz) {
|
|
if (copy_to_user(karg.data_in_buf_ptr, data_in,
|
|
data_in_sz)) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
|
|
__LINE__, __func__);
|
|
ret = -ENODATA;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/* copy out reply message frame to user */
|
|
if (karg.max_reply_bytes) {
|
|
sz = min_t(u32, karg.max_reply_bytes, ioc->reply_sz);
|
|
if (copy_to_user(karg.reply_frame_buf_ptr, ioc->ctl_cmds.reply,
|
|
sz)) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
|
|
__LINE__, __func__);
|
|
ret = -ENODATA;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/* copy out sense to user */
|
|
if (karg.max_sense_bytes && (mpi_request->Function ==
|
|
MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function ==
|
|
MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
|
|
sz = min_t(u32, karg.max_sense_bytes, SCSI_SENSE_BUFFERSIZE);
|
|
if (copy_to_user(karg.sense_data_ptr,
|
|
ioc->ctl_cmds.sense, sz)) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n", __FILE__,
|
|
__LINE__, __func__);
|
|
ret = -ENODATA;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
issue_host_reset:
|
|
if (issue_reset) {
|
|
ret = -ENODATA;
|
|
if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
|
|
mpi_request->Function ==
|
|
MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
|
|
printk(MPT2SAS_INFO_FMT "issue target reset: handle "
|
|
"= (0x%04x)\n", ioc->name,
|
|
le16_to_cpu(mpi_request->FunctionDependent1));
|
|
mpt2sas_halt_firmware(ioc);
|
|
mpt2sas_scsih_issue_tm(ioc,
|
|
le16_to_cpu(mpi_request->FunctionDependent1), 0, 0,
|
|
0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 10,
|
|
NULL);
|
|
ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
|
|
} else
|
|
mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
|
|
FORCE_BIG_HAMMER);
|
|
}
|
|
|
|
out:
|
|
|
|
/* free memory associated with sg buffers */
|
|
if (data_in)
|
|
pci_free_consistent(ioc->pdev, data_in_sz, data_in,
|
|
data_in_dma);
|
|
|
|
if (data_out)
|
|
pci_free_consistent(ioc->pdev, data_out_sz, data_out,
|
|
data_out_dma);
|
|
|
|
kfree(mpi_request);
|
|
ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
|
|
mutex_unlock(&ioc->ctl_cmds.mutex);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* _ctl_getiocinfo - main handler for MPT2IOCINFO opcode
|
|
* @arg - user space buffer containing ioctl content
|
|
*/
|
|
static long
|
|
_ctl_getiocinfo(void __user *arg)
|
|
{
|
|
struct mpt2_ioctl_iocinfo karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
u8 revision;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
|
|
__func__));
|
|
|
|
memset(&karg, 0 , sizeof(karg));
|
|
karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
|
|
if (ioc->pfacts)
|
|
karg.port_number = ioc->pfacts[0].PortNumber;
|
|
pci_read_config_byte(ioc->pdev, PCI_CLASS_REVISION, &revision);
|
|
karg.hw_rev = revision;
|
|
karg.pci_id = ioc->pdev->device;
|
|
karg.subsystem_device = ioc->pdev->subsystem_device;
|
|
karg.subsystem_vendor = ioc->pdev->subsystem_vendor;
|
|
karg.pci_information.u.bits.bus = ioc->pdev->bus->number;
|
|
karg.pci_information.u.bits.device = PCI_SLOT(ioc->pdev->devfn);
|
|
karg.pci_information.u.bits.function = PCI_FUNC(ioc->pdev->devfn);
|
|
karg.pci_information.segment_id = pci_domain_nr(ioc->pdev->bus);
|
|
karg.firmware_version = ioc->facts.FWVersion.Word;
|
|
strcpy(karg.driver_version, MPT2SAS_DRIVER_NAME);
|
|
strcat(karg.driver_version, "-");
|
|
strcat(karg.driver_version, MPT2SAS_DRIVER_VERSION);
|
|
karg.bios_version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
|
|
|
|
if (copy_to_user(arg, &karg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_eventquery - main handler for MPT2EVENTQUERY opcode
|
|
* @arg - user space buffer containing ioctl content
|
|
*/
|
|
static long
|
|
_ctl_eventquery(void __user *arg)
|
|
{
|
|
struct mpt2_ioctl_eventquery karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
|
|
__func__));
|
|
|
|
karg.event_entries = MPT2SAS_CTL_EVENT_LOG_SIZE;
|
|
memcpy(karg.event_types, ioc->event_type,
|
|
MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
|
|
|
|
if (copy_to_user(arg, &karg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_eventenable - main handler for MPT2EVENTENABLE opcode
|
|
* @arg - user space buffer containing ioctl content
|
|
*/
|
|
static long
|
|
_ctl_eventenable(void __user *arg)
|
|
{
|
|
struct mpt2_ioctl_eventenable karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
|
|
__func__));
|
|
|
|
if (ioc->event_log)
|
|
return 0;
|
|
memcpy(ioc->event_type, karg.event_types,
|
|
MPI2_EVENT_NOTIFY_EVENTMASK_WORDS * sizeof(u32));
|
|
mpt2sas_base_validate_event_type(ioc, ioc->event_type);
|
|
|
|
/* initialize event_log */
|
|
ioc->event_context = 0;
|
|
ioc->aen_event_read_flag = 0;
|
|
ioc->event_log = kcalloc(MPT2SAS_CTL_EVENT_LOG_SIZE,
|
|
sizeof(struct MPT2_IOCTL_EVENTS), GFP_KERNEL);
|
|
if (!ioc->event_log) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -ENOMEM;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_eventreport - main handler for MPT2EVENTREPORT opcode
|
|
* @arg - user space buffer containing ioctl content
|
|
*/
|
|
static long
|
|
_ctl_eventreport(void __user *arg)
|
|
{
|
|
struct mpt2_ioctl_eventreport karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
u32 number_bytes, max_events, max;
|
|
struct mpt2_ioctl_eventreport __user *uarg = arg;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
|
|
__func__));
|
|
|
|
number_bytes = karg.hdr.max_data_size -
|
|
sizeof(struct mpt2_ioctl_header);
|
|
max_events = number_bytes/sizeof(struct MPT2_IOCTL_EVENTS);
|
|
max = min_t(u32, MPT2SAS_CTL_EVENT_LOG_SIZE, max_events);
|
|
|
|
/* If fewer than 1 event is requested, there must have
|
|
* been some type of error.
|
|
*/
|
|
if (!max || !ioc->event_log)
|
|
return -ENODATA;
|
|
|
|
number_bytes = max * sizeof(struct MPT2_IOCTL_EVENTS);
|
|
if (copy_to_user(uarg->event_data, ioc->event_log, number_bytes)) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
|
|
/* reset flag so SIGIO can restart */
|
|
ioc->aen_event_read_flag = 0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_do_reset - main handler for MPT2HARDRESET opcode
|
|
* @arg - user space buffer containing ioctl content
|
|
*/
|
|
static long
|
|
_ctl_do_reset(void __user *arg)
|
|
{
|
|
struct mpt2_ioctl_diag_reset karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
int retval;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
|
|
__func__));
|
|
|
|
retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
|
|
FORCE_BIG_HAMMER);
|
|
printk(MPT2SAS_INFO_FMT "host reset: %s\n",
|
|
ioc->name, ((!retval) ? "SUCCESS" : "FAILED"));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_btdh_search_sas_device - searching for sas device
|
|
* @ioc: per adapter object
|
|
* @btdh: btdh ioctl payload
|
|
*/
|
|
static int
|
|
_ctl_btdh_search_sas_device(struct MPT2SAS_ADAPTER *ioc,
|
|
struct mpt2_ioctl_btdh_mapping *btdh)
|
|
{
|
|
struct _sas_device *sas_device;
|
|
unsigned long flags;
|
|
int rc = 0;
|
|
|
|
if (list_empty(&ioc->sas_device_list))
|
|
return rc;
|
|
|
|
spin_lock_irqsave(&ioc->sas_device_lock, flags);
|
|
list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
|
|
if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
|
|
btdh->handle == sas_device->handle) {
|
|
btdh->bus = sas_device->channel;
|
|
btdh->id = sas_device->id;
|
|
rc = 1;
|
|
goto out;
|
|
} else if (btdh->bus == sas_device->channel && btdh->id ==
|
|
sas_device->id && btdh->handle == 0xFFFF) {
|
|
btdh->handle = sas_device->handle;
|
|
rc = 1;
|
|
goto out;
|
|
}
|
|
}
|
|
out:
|
|
spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _ctl_btdh_search_raid_device - searching for raid device
|
|
* @ioc: per adapter object
|
|
* @btdh: btdh ioctl payload
|
|
*/
|
|
static int
|
|
_ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc,
|
|
struct mpt2_ioctl_btdh_mapping *btdh)
|
|
{
|
|
struct _raid_device *raid_device;
|
|
unsigned long flags;
|
|
int rc = 0;
|
|
|
|
if (list_empty(&ioc->raid_device_list))
|
|
return rc;
|
|
|
|
spin_lock_irqsave(&ioc->raid_device_lock, flags);
|
|
list_for_each_entry(raid_device, &ioc->raid_device_list, list) {
|
|
if (btdh->bus == 0xFFFFFFFF && btdh->id == 0xFFFFFFFF &&
|
|
btdh->handle == raid_device->handle) {
|
|
btdh->bus = raid_device->channel;
|
|
btdh->id = raid_device->id;
|
|
rc = 1;
|
|
goto out;
|
|
} else if (btdh->bus == raid_device->channel && btdh->id ==
|
|
raid_device->id && btdh->handle == 0xFFFF) {
|
|
btdh->handle = raid_device->handle;
|
|
rc = 1;
|
|
goto out;
|
|
}
|
|
}
|
|
out:
|
|
spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode
|
|
* @arg - user space buffer containing ioctl content
|
|
*/
|
|
static long
|
|
_ctl_btdh_mapping(void __user *arg)
|
|
{
|
|
struct mpt2_ioctl_btdh_mapping karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
int rc;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
|
|
__func__));
|
|
|
|
rc = _ctl_btdh_search_sas_device(ioc, &karg);
|
|
if (!rc)
|
|
_ctl_btdh_search_raid_device(ioc, &karg);
|
|
|
|
if (copy_to_user(arg, &karg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_diag_capability - return diag buffer capability
|
|
* @ioc: per adapter object
|
|
* @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
|
|
*
|
|
* returns 1 when diag buffer support is enabled in firmware
|
|
*/
|
|
static u8
|
|
_ctl_diag_capability(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type)
|
|
{
|
|
u8 rc = 0;
|
|
|
|
switch (buffer_type) {
|
|
case MPI2_DIAG_BUF_TYPE_TRACE:
|
|
if (ioc->facts.IOCCapabilities &
|
|
MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER)
|
|
rc = 1;
|
|
break;
|
|
case MPI2_DIAG_BUF_TYPE_SNAPSHOT:
|
|
if (ioc->facts.IOCCapabilities &
|
|
MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER)
|
|
rc = 1;
|
|
break;
|
|
case MPI2_DIAG_BUF_TYPE_EXTENDED:
|
|
if (ioc->facts.IOCCapabilities &
|
|
MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER)
|
|
rc = 1;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _ctl_diag_register_2 - wrapper for registering diag buffer support
|
|
* @ioc: per adapter object
|
|
* @diag_register: the diag_register struct passed in from user space
|
|
*
|
|
*/
|
|
static long
|
|
_ctl_diag_register_2(struct MPT2SAS_ADAPTER *ioc,
|
|
struct mpt2_diag_register *diag_register)
|
|
{
|
|
int rc, i;
|
|
void *request_data = NULL;
|
|
dma_addr_t request_data_dma;
|
|
u32 request_data_sz = 0;
|
|
Mpi2DiagBufferPostRequest_t *mpi_request;
|
|
Mpi2DiagBufferPostReply_t *mpi_reply;
|
|
u8 buffer_type;
|
|
unsigned long timeleft;
|
|
u16 smid;
|
|
u16 ioc_status;
|
|
u8 issue_reset = 0;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
|
|
__func__));
|
|
|
|
if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
|
|
printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
|
|
ioc->name, __func__);
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
buffer_type = diag_register->buffer_type;
|
|
if (!_ctl_diag_capability(ioc, buffer_type)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -EPERM;
|
|
}
|
|
|
|
if (ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) {
|
|
printk(MPT2SAS_ERR_FMT "%s: already has a registered "
|
|
"buffer for buffer_type(0x%02x)\n", ioc->name, __func__,
|
|
buffer_type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (diag_register->requested_buffer_size % 4) {
|
|
printk(MPT2SAS_ERR_FMT "%s: the requested_buffer_size "
|
|
"is not 4 byte aligned\n", ioc->name, __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
|
|
if (!smid) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
|
|
ioc->name, __func__);
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
rc = 0;
|
|
ioc->ctl_cmds.status = MPT2_CMD_PENDING;
|
|
memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
|
|
mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
|
|
ioc->ctl_cmds.smid = smid;
|
|
|
|
request_data = ioc->diag_buffer[buffer_type];
|
|
request_data_sz = diag_register->requested_buffer_size;
|
|
ioc->unique_id[buffer_type] = diag_register->unique_id;
|
|
ioc->diag_buffer_status[buffer_type] = 0;
|
|
memcpy(ioc->product_specific[buffer_type],
|
|
diag_register->product_specific, MPT2_PRODUCT_SPECIFIC_DWORDS);
|
|
ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags;
|
|
|
|
if (request_data) {
|
|
request_data_dma = ioc->diag_buffer_dma[buffer_type];
|
|
if (request_data_sz != ioc->diag_buffer_sz[buffer_type]) {
|
|
pci_free_consistent(ioc->pdev,
|
|
ioc->diag_buffer_sz[buffer_type],
|
|
request_data, request_data_dma);
|
|
request_data = NULL;
|
|
}
|
|
}
|
|
|
|
if (request_data == NULL) {
|
|
ioc->diag_buffer_sz[buffer_type] = 0;
|
|
ioc->diag_buffer_dma[buffer_type] = 0;
|
|
request_data = pci_alloc_consistent(
|
|
ioc->pdev, request_data_sz, &request_data_dma);
|
|
if (request_data == NULL) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed allocating memory"
|
|
" for diag buffers, requested size(%d)\n",
|
|
ioc->name, __func__, request_data_sz);
|
|
mpt2sas_base_free_smid(ioc, smid);
|
|
return -ENOMEM;
|
|
}
|
|
ioc->diag_buffer[buffer_type] = request_data;
|
|
ioc->diag_buffer_sz[buffer_type] = request_data_sz;
|
|
ioc->diag_buffer_dma[buffer_type] = request_data_dma;
|
|
}
|
|
|
|
mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
|
|
mpi_request->BufferType = diag_register->buffer_type;
|
|
mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags);
|
|
mpi_request->BufferAddress = cpu_to_le64(request_data_dma);
|
|
mpi_request->BufferLength = cpu_to_le32(request_data_sz);
|
|
mpi_request->VF_ID = 0; /* TODO */
|
|
mpi_request->VP_ID = 0;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(0x%p), "
|
|
"dma(0x%llx), sz(%d)\n", ioc->name, __func__, request_data,
|
|
(unsigned long long)request_data_dma,
|
|
le32_to_cpu(mpi_request->BufferLength)));
|
|
|
|
for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
|
|
mpi_request->ProductSpecific[i] =
|
|
cpu_to_le32(ioc->product_specific[buffer_type][i]);
|
|
|
|
mpt2sas_base_put_smid_default(ioc, smid);
|
|
init_completion(&ioc->ctl_cmds.done);
|
|
timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
|
|
MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
|
|
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
|
|
__func__);
|
|
_debug_dump_mf(mpi_request,
|
|
sizeof(Mpi2DiagBufferPostRequest_t)/4);
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
|
|
issue_reset = 1;
|
|
goto issue_host_reset;
|
|
}
|
|
|
|
/* process the completed Reply Message Frame */
|
|
if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
|
|
ioc->name, __func__);
|
|
rc = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
mpi_reply = ioc->ctl_cmds.reply;
|
|
ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
|
|
|
|
if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
|
|
ioc->diag_buffer_status[buffer_type] |=
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED;
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
|
|
ioc->name, __func__));
|
|
} else {
|
|
printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) "
|
|
"log_info(0x%08x)\n", ioc->name, __func__,
|
|
ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
|
|
rc = -EFAULT;
|
|
}
|
|
|
|
issue_host_reset:
|
|
if (issue_reset)
|
|
mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
|
|
FORCE_BIG_HAMMER);
|
|
|
|
out:
|
|
|
|
if (rc && request_data)
|
|
pci_free_consistent(ioc->pdev, request_data_sz,
|
|
request_data, request_data_dma);
|
|
|
|
ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_enable_diag_buffer - enabling diag_buffers support driver load time
|
|
* @ioc: per adapter object
|
|
* @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
|
|
*
|
|
* This is called when command line option diag_buffer_enable is enabled
|
|
* at driver load time.
|
|
*/
|
|
void
|
|
mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register)
|
|
{
|
|
struct mpt2_diag_register diag_register;
|
|
|
|
memset(&diag_register, 0, sizeof(struct mpt2_diag_register));
|
|
|
|
if (bits_to_register & 1) {
|
|
printk(MPT2SAS_INFO_FMT "registering trace buffer support\n",
|
|
ioc->name);
|
|
diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
|
|
/* register for 1MB buffers */
|
|
diag_register.requested_buffer_size = (1024 * 1024);
|
|
diag_register.unique_id = 0x7075900;
|
|
_ctl_diag_register_2(ioc, &diag_register);
|
|
}
|
|
|
|
if (bits_to_register & 2) {
|
|
printk(MPT2SAS_INFO_FMT "registering snapshot buffer support\n",
|
|
ioc->name);
|
|
diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT;
|
|
/* register for 2MB buffers */
|
|
diag_register.requested_buffer_size = 2 * (1024 * 1024);
|
|
diag_register.unique_id = 0x7075901;
|
|
_ctl_diag_register_2(ioc, &diag_register);
|
|
}
|
|
|
|
if (bits_to_register & 4) {
|
|
printk(MPT2SAS_INFO_FMT "registering extended buffer support\n",
|
|
ioc->name);
|
|
diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED;
|
|
/* register for 2MB buffers */
|
|
diag_register.requested_buffer_size = 2 * (1024 * 1024);
|
|
diag_register.unique_id = 0x7075901;
|
|
_ctl_diag_register_2(ioc, &diag_register);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* _ctl_diag_register - application register with driver
|
|
* @arg - user space buffer containing ioctl content
|
|
* @state - NON_BLOCKING or BLOCKING
|
|
*
|
|
* This will allow the driver to setup any required buffers that will be
|
|
* needed by firmware to communicate with the driver.
|
|
*/
|
|
static long
|
|
_ctl_diag_register(void __user *arg, enum block_state state)
|
|
{
|
|
struct mpt2_diag_register karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
long rc;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
|
|
return -EAGAIN;
|
|
else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
|
|
return -ERESTARTSYS;
|
|
rc = _ctl_diag_register_2(ioc, &karg);
|
|
mutex_unlock(&ioc->ctl_cmds.mutex);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _ctl_diag_unregister - application unregister with driver
|
|
* @arg - user space buffer containing ioctl content
|
|
*
|
|
* This will allow the driver to cleanup any memory allocated for diag
|
|
* messages and to free up any resources.
|
|
*/
|
|
static long
|
|
_ctl_diag_unregister(void __user *arg)
|
|
{
|
|
struct mpt2_diag_unregister karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
void *request_data;
|
|
dma_addr_t request_data_dma;
|
|
u32 request_data_sz;
|
|
u8 buffer_type;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
|
|
__func__));
|
|
|
|
buffer_type = karg.unique_id & 0x000000ff;
|
|
if (!_ctl_diag_capability(ioc, buffer_type)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -EPERM;
|
|
}
|
|
|
|
if ((ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
|
|
"registered\n", ioc->name, __func__, buffer_type);
|
|
return -EINVAL;
|
|
}
|
|
if ((ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) has not been "
|
|
"released\n", ioc->name, __func__, buffer_type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (karg.unique_id != ioc->unique_id[buffer_type]) {
|
|
printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
|
|
"registered\n", ioc->name, __func__, karg.unique_id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
request_data = ioc->diag_buffer[buffer_type];
|
|
if (!request_data) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
request_data_sz = ioc->diag_buffer_sz[buffer_type];
|
|
request_data_dma = ioc->diag_buffer_dma[buffer_type];
|
|
pci_free_consistent(ioc->pdev, request_data_sz,
|
|
request_data, request_data_dma);
|
|
ioc->diag_buffer[buffer_type] = NULL;
|
|
ioc->diag_buffer_status[buffer_type] = 0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_diag_query - query relevant info associated with diag buffers
|
|
* @arg - user space buffer containing ioctl content
|
|
*
|
|
* The application will send only buffer_type and unique_id. Driver will
|
|
* inspect unique_id first, if valid, fill in all the info. If unique_id is
|
|
* 0x00, the driver will return info specified by Buffer Type.
|
|
*/
|
|
static long
|
|
_ctl_diag_query(void __user *arg)
|
|
{
|
|
struct mpt2_diag_query karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
void *request_data;
|
|
int i;
|
|
u8 buffer_type;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
|
|
__func__));
|
|
|
|
karg.application_flags = 0;
|
|
buffer_type = karg.buffer_type;
|
|
|
|
if (!_ctl_diag_capability(ioc, buffer_type)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -EPERM;
|
|
}
|
|
|
|
if ((ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
|
|
"registered\n", ioc->name, __func__, buffer_type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (karg.unique_id & 0xffffff00) {
|
|
if (karg.unique_id != ioc->unique_id[buffer_type]) {
|
|
printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
|
|
"registered\n", ioc->name, __func__,
|
|
karg.unique_id);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
request_data = ioc->diag_buffer[buffer_type];
|
|
if (!request_data) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if (ioc->diag_buffer_status[buffer_type] & MPT2_DIAG_BUFFER_IS_RELEASED)
|
|
karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
|
|
MPT2_APP_FLAGS_BUFFER_VALID);
|
|
else
|
|
karg.application_flags = (MPT2_APP_FLAGS_APP_OWNED |
|
|
MPT2_APP_FLAGS_BUFFER_VALID |
|
|
MPT2_APP_FLAGS_FW_BUFFER_ACCESS);
|
|
|
|
for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
|
|
karg.product_specific[i] =
|
|
ioc->product_specific[buffer_type][i];
|
|
|
|
karg.total_buffer_size = ioc->diag_buffer_sz[buffer_type];
|
|
karg.driver_added_buffer_size = 0;
|
|
karg.unique_id = ioc->unique_id[buffer_type];
|
|
karg.diagnostic_flags = ioc->diagnostic_flags[buffer_type];
|
|
|
|
if (copy_to_user(arg, &karg, sizeof(struct mpt2_diag_query))) {
|
|
printk(MPT2SAS_ERR_FMT "%s: unable to write mpt2_diag_query "
|
|
"data @ %p\n", ioc->name, __func__, arg);
|
|
return -EFAULT;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _ctl_send_release - Diag Release Message
|
|
* @ioc: per adapter object
|
|
* @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
|
|
* @issue_reset - specifies whether host reset is required.
|
|
*
|
|
*/
|
|
static int
|
|
_ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
|
|
{
|
|
Mpi2DiagReleaseRequest_t *mpi_request;
|
|
Mpi2DiagReleaseReply_t *mpi_reply;
|
|
u16 smid;
|
|
u16 ioc_status;
|
|
u32 ioc_state;
|
|
int rc;
|
|
unsigned long timeleft;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
|
|
__func__));
|
|
|
|
rc = 0;
|
|
*issue_reset = 0;
|
|
|
|
ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
|
|
if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
|
|
"skipping due to FAULT state\n", ioc->name,
|
|
__func__));
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
|
|
printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
|
|
ioc->name, __func__);
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
|
|
if (!smid) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
|
|
ioc->name, __func__);
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
ioc->ctl_cmds.status = MPT2_CMD_PENDING;
|
|
memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
|
|
mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
|
|
ioc->ctl_cmds.smid = smid;
|
|
|
|
mpi_request->Function = MPI2_FUNCTION_DIAG_RELEASE;
|
|
mpi_request->BufferType = buffer_type;
|
|
mpi_request->VF_ID = 0; /* TODO */
|
|
mpi_request->VP_ID = 0;
|
|
|
|
mpt2sas_base_put_smid_default(ioc, smid);
|
|
init_completion(&ioc->ctl_cmds.done);
|
|
timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
|
|
MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
|
|
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
|
|
__func__);
|
|
_debug_dump_mf(mpi_request,
|
|
sizeof(Mpi2DiagReleaseRequest_t)/4);
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
|
|
*issue_reset = 1;
|
|
rc = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
/* process the completed Reply Message Frame */
|
|
if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
|
|
ioc->name, __func__);
|
|
rc = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
mpi_reply = ioc->ctl_cmds.reply;
|
|
ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
|
|
|
|
if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
|
|
ioc->diag_buffer_status[buffer_type] |=
|
|
MPT2_DIAG_BUFFER_IS_RELEASED;
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
|
|
ioc->name, __func__));
|
|
} else {
|
|
printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) "
|
|
"log_info(0x%08x)\n", ioc->name, __func__,
|
|
ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
|
|
rc = -EFAULT;
|
|
}
|
|
|
|
out:
|
|
ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _ctl_diag_release - request to send Diag Release Message to firmware
|
|
* @arg - user space buffer containing ioctl content
|
|
* @state - NON_BLOCKING or BLOCKING
|
|
*
|
|
* This allows ownership of the specified buffer to returned to the driver,
|
|
* allowing an application to read the buffer without fear that firmware is
|
|
* overwritting information in the buffer.
|
|
*/
|
|
static long
|
|
_ctl_diag_release(void __user *arg, enum block_state state)
|
|
{
|
|
struct mpt2_diag_release karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
void *request_data;
|
|
int rc;
|
|
u8 buffer_type;
|
|
u8 issue_reset = 0;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
|
|
__func__));
|
|
|
|
buffer_type = karg.unique_id & 0x000000ff;
|
|
if (!_ctl_diag_capability(ioc, buffer_type)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -EPERM;
|
|
}
|
|
|
|
if ((ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) is not "
|
|
"registered\n", ioc->name, __func__, buffer_type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (karg.unique_id != ioc->unique_id[buffer_type]) {
|
|
printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
|
|
"registered\n", ioc->name, __func__, karg.unique_id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED) {
|
|
printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
|
|
"is already released\n", ioc->name, __func__,
|
|
buffer_type);
|
|
return 0;
|
|
}
|
|
|
|
request_data = ioc->diag_buffer[buffer_type];
|
|
|
|
if (!request_data) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have memory allocated for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* buffers were released by due to host reset */
|
|
if ((ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_DIAG_RESET)) {
|
|
ioc->diag_buffer_status[buffer_type] |=
|
|
MPT2_DIAG_BUFFER_IS_RELEASED;
|
|
ioc->diag_buffer_status[buffer_type] &=
|
|
~MPT2_DIAG_BUFFER_IS_DIAG_RESET;
|
|
printk(MPT2SAS_ERR_FMT "%s: buffer_type(0x%02x) "
|
|
"was released due to host reset\n", ioc->name, __func__,
|
|
buffer_type);
|
|
return 0;
|
|
}
|
|
|
|
if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
|
|
return -EAGAIN;
|
|
else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
|
|
return -ERESTARTSYS;
|
|
|
|
rc = _ctl_send_release(ioc, buffer_type, &issue_reset);
|
|
|
|
if (issue_reset)
|
|
mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
|
|
FORCE_BIG_HAMMER);
|
|
|
|
mutex_unlock(&ioc->ctl_cmds.mutex);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _ctl_diag_read_buffer - request for copy of the diag buffer
|
|
* @arg - user space buffer containing ioctl content
|
|
* @state - NON_BLOCKING or BLOCKING
|
|
*/
|
|
static long
|
|
_ctl_diag_read_buffer(void __user *arg, enum block_state state)
|
|
{
|
|
struct mpt2_diag_read_buffer karg;
|
|
struct mpt2_diag_read_buffer __user *uarg = arg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
void *request_data, *diag_data;
|
|
Mpi2DiagBufferPostRequest_t *mpi_request;
|
|
Mpi2DiagBufferPostReply_t *mpi_reply;
|
|
int rc, i;
|
|
u8 buffer_type;
|
|
unsigned long timeleft;
|
|
u16 smid;
|
|
u16 ioc_status;
|
|
u8 issue_reset = 0;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
|
|
__func__));
|
|
|
|
buffer_type = karg.unique_id & 0x000000ff;
|
|
if (!_ctl_diag_capability(ioc, buffer_type)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -EPERM;
|
|
}
|
|
|
|
if (karg.unique_id != ioc->unique_id[buffer_type]) {
|
|
printk(MPT2SAS_ERR_FMT "%s: unique_id(0x%08x) is not "
|
|
"registered\n", ioc->name, __func__, karg.unique_id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
request_data = ioc->diag_buffer[buffer_type];
|
|
if (!request_data) {
|
|
printk(MPT2SAS_ERR_FMT "%s: doesn't have buffer for "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if ((karg.starting_offset % 4) || (karg.bytes_to_read % 4)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: either the starting_offset "
|
|
"or bytes_to_read are not 4 byte aligned\n", ioc->name,
|
|
__func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
diag_data = (void *)(request_data + karg.starting_offset);
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: diag_buffer(%p), "
|
|
"offset(%d), sz(%d)\n", ioc->name, __func__,
|
|
diag_data, karg.starting_offset, karg.bytes_to_read));
|
|
|
|
if (copy_to_user((void __user *)uarg->diagnostic_data,
|
|
diag_data, karg.bytes_to_read)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: Unable to write "
|
|
"mpt_diag_read_buffer_t data @ %p\n", ioc->name,
|
|
__func__, diag_data);
|
|
return -EFAULT;
|
|
}
|
|
|
|
if ((karg.flags & MPT2_FLAGS_REREGISTER) == 0)
|
|
return 0;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: Reregister "
|
|
"buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type));
|
|
if ((ioc->diag_buffer_status[buffer_type] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED) == 0) {
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: "
|
|
"buffer_type(0x%02x) is still registered\n", ioc->name,
|
|
__func__, buffer_type));
|
|
return 0;
|
|
}
|
|
/* Get a free request frame and save the message context.
|
|
*/
|
|
if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
|
|
return -EAGAIN;
|
|
else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
|
|
return -ERESTARTSYS;
|
|
|
|
if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
|
|
printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
|
|
ioc->name, __func__);
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
|
|
if (!smid) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
|
|
ioc->name, __func__);
|
|
rc = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
rc = 0;
|
|
ioc->ctl_cmds.status = MPT2_CMD_PENDING;
|
|
memset(ioc->ctl_cmds.reply, 0, ioc->reply_sz);
|
|
mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
|
|
ioc->ctl_cmds.smid = smid;
|
|
|
|
mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
|
|
mpi_request->BufferType = buffer_type;
|
|
mpi_request->BufferLength =
|
|
cpu_to_le32(ioc->diag_buffer_sz[buffer_type]);
|
|
mpi_request->BufferAddress =
|
|
cpu_to_le64(ioc->diag_buffer_dma[buffer_type]);
|
|
for (i = 0; i < MPT2_PRODUCT_SPECIFIC_DWORDS; i++)
|
|
mpi_request->ProductSpecific[i] =
|
|
cpu_to_le32(ioc->product_specific[buffer_type][i]);
|
|
mpi_request->VF_ID = 0; /* TODO */
|
|
mpi_request->VP_ID = 0;
|
|
|
|
mpt2sas_base_put_smid_default(ioc, smid);
|
|
init_completion(&ioc->ctl_cmds.done);
|
|
timeleft = wait_for_completion_timeout(&ioc->ctl_cmds.done,
|
|
MPT2_IOCTL_DEFAULT_TIMEOUT*HZ);
|
|
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_COMPLETE)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: timeout\n", ioc->name,
|
|
__func__);
|
|
_debug_dump_mf(mpi_request,
|
|
sizeof(Mpi2DiagBufferPostRequest_t)/4);
|
|
if (!(ioc->ctl_cmds.status & MPT2_CMD_RESET))
|
|
issue_reset = 1;
|
|
goto issue_host_reset;
|
|
}
|
|
|
|
/* process the completed Reply Message Frame */
|
|
if ((ioc->ctl_cmds.status & MPT2_CMD_REPLY_VALID) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: no reply message\n",
|
|
ioc->name, __func__);
|
|
rc = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
mpi_reply = ioc->ctl_cmds.reply;
|
|
ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
|
|
|
|
if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
|
|
ioc->diag_buffer_status[buffer_type] |=
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED;
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: success\n",
|
|
ioc->name, __func__));
|
|
} else {
|
|
printk(MPT2SAS_INFO_FMT "%s: ioc_status(0x%04x) "
|
|
"log_info(0x%08x)\n", ioc->name, __func__,
|
|
ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
|
|
rc = -EFAULT;
|
|
}
|
|
|
|
issue_host_reset:
|
|
if (issue_reset)
|
|
mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
|
|
FORCE_BIG_HAMMER);
|
|
|
|
out:
|
|
|
|
ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
|
|
mutex_unlock(&ioc->ctl_cmds.mutex);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* _ctl_ioctl_main - main ioctl entry point
|
|
* @file - (struct file)
|
|
* @cmd - ioctl opcode
|
|
* @arg -
|
|
*/
|
|
static long
|
|
_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg)
|
|
{
|
|
enum block_state state;
|
|
long ret = -EINVAL;
|
|
|
|
state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING :
|
|
BLOCKING;
|
|
|
|
switch (cmd) {
|
|
case MPT2IOCINFO:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo))
|
|
ret = _ctl_getiocinfo(arg);
|
|
break;
|
|
case MPT2COMMAND:
|
|
{
|
|
struct mpt2_ioctl_command karg;
|
|
struct mpt2_ioctl_command __user *uarg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
|
|
!ioc)
|
|
return -ENODEV;
|
|
|
|
if (ioc->shost_recovery || ioc->pci_error_recovery)
|
|
return -EAGAIN;
|
|
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) {
|
|
uarg = arg;
|
|
ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
|
|
}
|
|
break;
|
|
}
|
|
case MPT2EVENTQUERY:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery))
|
|
ret = _ctl_eventquery(arg);
|
|
break;
|
|
case MPT2EVENTENABLE:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable))
|
|
ret = _ctl_eventenable(arg);
|
|
break;
|
|
case MPT2EVENTREPORT:
|
|
ret = _ctl_eventreport(arg);
|
|
break;
|
|
case MPT2HARDRESET:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset))
|
|
ret = _ctl_do_reset(arg);
|
|
break;
|
|
case MPT2BTDHMAPPING:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping))
|
|
ret = _ctl_btdh_mapping(arg);
|
|
break;
|
|
case MPT2DIAGREGISTER:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register))
|
|
ret = _ctl_diag_register(arg, state);
|
|
break;
|
|
case MPT2DIAGUNREGISTER:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister))
|
|
ret = _ctl_diag_unregister(arg);
|
|
break;
|
|
case MPT2DIAGQUERY:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query))
|
|
ret = _ctl_diag_query(arg);
|
|
break;
|
|
case MPT2DIAGRELEASE:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release))
|
|
ret = _ctl_diag_release(arg, state);
|
|
break;
|
|
case MPT2DIAGREADBUFFER:
|
|
if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer))
|
|
ret = _ctl_diag_read_buffer(arg, state);
|
|
break;
|
|
default:
|
|
{
|
|
struct mpt2_ioctl_command karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
|
|
if (copy_from_user(&karg, arg, sizeof(karg))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
|
|
if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
|
|
!ioc)
|
|
return -ENODEV;
|
|
|
|
dctlprintk(ioc, printk(MPT2SAS_INFO_FMT
|
|
"unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* _ctl_ioctl - main ioctl entry point (unlocked)
|
|
* @file - (struct file)
|
|
* @cmd - ioctl opcode
|
|
* @arg -
|
|
*/
|
|
static long
|
|
_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
{
|
|
long ret;
|
|
|
|
lock_kernel();
|
|
ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
|
|
unlock_kernel();
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
/**
|
|
* _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
|
|
* @file - (struct file)
|
|
* @cmd - ioctl opcode
|
|
* @arg - (struct mpt2_ioctl_command32)
|
|
*
|
|
* MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
|
|
*/
|
|
static long
|
|
_ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
|
|
{
|
|
struct mpt2_ioctl_command32 karg32;
|
|
struct mpt2_ioctl_command32 __user *uarg;
|
|
struct mpt2_ioctl_command karg;
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
enum block_state state;
|
|
|
|
if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
|
|
return -EINVAL;
|
|
|
|
uarg = (struct mpt2_ioctl_command32 __user *) arg;
|
|
|
|
if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
|
|
printk(KERN_ERR "failure at %s:%d/%s()!\n",
|
|
__FILE__, __LINE__, __func__);
|
|
return -EFAULT;
|
|
}
|
|
if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc)
|
|
return -ENODEV;
|
|
|
|
if (ioc->shost_recovery || ioc->pci_error_recovery)
|
|
return -EAGAIN;
|
|
|
|
memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
|
|
karg.hdr.ioc_number = karg32.hdr.ioc_number;
|
|
karg.hdr.port_number = karg32.hdr.port_number;
|
|
karg.hdr.max_data_size = karg32.hdr.max_data_size;
|
|
karg.timeout = karg32.timeout;
|
|
karg.max_reply_bytes = karg32.max_reply_bytes;
|
|
karg.data_in_size = karg32.data_in_size;
|
|
karg.data_out_size = karg32.data_out_size;
|
|
karg.max_sense_bytes = karg32.max_sense_bytes;
|
|
karg.data_sge_offset = karg32.data_sge_offset;
|
|
karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
|
|
karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
|
|
karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
|
|
karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
|
|
state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
|
|
return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
|
|
}
|
|
|
|
/**
|
|
* _ctl_ioctl_compat - main ioctl entry point (compat)
|
|
* @file -
|
|
* @cmd -
|
|
* @arg -
|
|
*
|
|
* This routine handles 32 bit applications in 64bit os.
|
|
*/
|
|
static long
|
|
_ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
|
|
{
|
|
long ret;
|
|
|
|
lock_kernel();
|
|
if (cmd == MPT2COMMAND32)
|
|
ret = _ctl_compat_mpt_command(file, cmd, arg);
|
|
else
|
|
ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
|
|
unlock_kernel();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/* scsi host attributes */
|
|
|
|
/**
|
|
* _ctl_version_fw_show - firmware version
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_version_fw_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
|
|
(ioc->facts.FWVersion.Word & 0xFF000000) >> 24,
|
|
(ioc->facts.FWVersion.Word & 0x00FF0000) >> 16,
|
|
(ioc->facts.FWVersion.Word & 0x0000FF00) >> 8,
|
|
ioc->facts.FWVersion.Word & 0x000000FF);
|
|
}
|
|
static DEVICE_ATTR(version_fw, S_IRUGO, _ctl_version_fw_show, NULL);
|
|
|
|
/**
|
|
* _ctl_version_bios_show - bios version
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_version_bios_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
u32 version = le32_to_cpu(ioc->bios_pg3.BiosVersion);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%02d.%02d.%02d.%02d\n",
|
|
(version & 0xFF000000) >> 24,
|
|
(version & 0x00FF0000) >> 16,
|
|
(version & 0x0000FF00) >> 8,
|
|
version & 0x000000FF);
|
|
}
|
|
static DEVICE_ATTR(version_bios, S_IRUGO, _ctl_version_bios_show, NULL);
|
|
|
|
/**
|
|
* _ctl_version_mpi_show - MPI (message passing interface) version
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_version_mpi_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%03x.%02x\n",
|
|
ioc->facts.MsgVersion, ioc->facts.HeaderVersion >> 8);
|
|
}
|
|
static DEVICE_ATTR(version_mpi, S_IRUGO, _ctl_version_mpi_show, NULL);
|
|
|
|
/**
|
|
* _ctl_version_product_show - product name
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_version_product_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, 16, "%s\n", ioc->manu_pg0.ChipName);
|
|
}
|
|
static DEVICE_ATTR(version_product, S_IRUGO,
|
|
_ctl_version_product_show, NULL);
|
|
|
|
/**
|
|
* _ctl_version_nvdata_persistent_show - ndvata persistent version
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_version_nvdata_persistent_show(struct device *cdev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%08xh\n",
|
|
le32_to_cpu(ioc->iounit_pg0.NvdataVersionPersistent.Word));
|
|
}
|
|
static DEVICE_ATTR(version_nvdata_persistent, S_IRUGO,
|
|
_ctl_version_nvdata_persistent_show, NULL);
|
|
|
|
/**
|
|
* _ctl_version_nvdata_default_show - nvdata default version
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_version_nvdata_default_show(struct device *cdev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%08xh\n",
|
|
le32_to_cpu(ioc->iounit_pg0.NvdataVersionDefault.Word));
|
|
}
|
|
static DEVICE_ATTR(version_nvdata_default, S_IRUGO,
|
|
_ctl_version_nvdata_default_show, NULL);
|
|
|
|
/**
|
|
* _ctl_board_name_show - board name
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_board_name_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardName);
|
|
}
|
|
static DEVICE_ATTR(board_name, S_IRUGO, _ctl_board_name_show, NULL);
|
|
|
|
/**
|
|
* _ctl_board_assembly_show - board assembly name
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_board_assembly_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardAssembly);
|
|
}
|
|
static DEVICE_ATTR(board_assembly, S_IRUGO,
|
|
_ctl_board_assembly_show, NULL);
|
|
|
|
/**
|
|
* _ctl_board_tracer_show - board tracer number
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_board_tracer_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, 16, "%s\n", ioc->manu_pg0.BoardTracerNumber);
|
|
}
|
|
static DEVICE_ATTR(board_tracer, S_IRUGO,
|
|
_ctl_board_tracer_show, NULL);
|
|
|
|
/**
|
|
* _ctl_io_delay_show - io missing delay
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* This is for firmware implemention for deboucing device
|
|
* removal events.
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_io_delay_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->io_missing_delay);
|
|
}
|
|
static DEVICE_ATTR(io_delay, S_IRUGO,
|
|
_ctl_io_delay_show, NULL);
|
|
|
|
/**
|
|
* _ctl_device_delay_show - device missing delay
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* This is for firmware implemention for deboucing device
|
|
* removal events.
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_device_delay_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->device_missing_delay);
|
|
}
|
|
static DEVICE_ATTR(device_delay, S_IRUGO,
|
|
_ctl_device_delay_show, NULL);
|
|
|
|
/**
|
|
* _ctl_fw_queue_depth_show - global credits
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* This is firmware queue depth limit
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_fw_queue_depth_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%02d\n", ioc->facts.RequestCredit);
|
|
}
|
|
static DEVICE_ATTR(fw_queue_depth, S_IRUGO,
|
|
_ctl_fw_queue_depth_show, NULL);
|
|
|
|
/**
|
|
* _ctl_sas_address_show - sas address
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* This is the controller sas address
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_host_sas_address_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
|
|
(unsigned long long)ioc->sas_hba.sas_address);
|
|
}
|
|
static DEVICE_ATTR(host_sas_address, S_IRUGO,
|
|
_ctl_host_sas_address_show, NULL);
|
|
|
|
/**
|
|
* _ctl_logging_level_show - logging level
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read/write' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_logging_level_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%08xh\n", ioc->logging_level);
|
|
}
|
|
static ssize_t
|
|
_ctl_logging_level_store(struct device *cdev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
int val = 0;
|
|
|
|
if (sscanf(buf, "%x", &val) != 1)
|
|
return -EINVAL;
|
|
|
|
ioc->logging_level = val;
|
|
printk(MPT2SAS_INFO_FMT "logging_level=%08xh\n", ioc->name,
|
|
ioc->logging_level);
|
|
return strlen(buf);
|
|
}
|
|
static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR,
|
|
_ctl_logging_level_show, _ctl_logging_level_store);
|
|
|
|
/* device attributes */
|
|
/*
|
|
* _ctl_fwfault_debug_show - show/store fwfault_debug
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* mpt2sas_fwfault_debug is command line option
|
|
* A sysfs 'read/write' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_fwfault_debug_show(struct device *cdev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug);
|
|
}
|
|
static ssize_t
|
|
_ctl_fwfault_debug_store(struct device *cdev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
int val = 0;
|
|
|
|
if (sscanf(buf, "%d", &val) != 1)
|
|
return -EINVAL;
|
|
|
|
ioc->fwfault_debug = val;
|
|
printk(MPT2SAS_INFO_FMT "fwfault_debug=%d\n", ioc->name,
|
|
ioc->fwfault_debug);
|
|
return strlen(buf);
|
|
}
|
|
static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR,
|
|
_ctl_fwfault_debug_show, _ctl_fwfault_debug_store);
|
|
|
|
|
|
/**
|
|
* _ctl_ioc_reset_count_show - ioc reset count
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* This is firmware queue depth limit
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_ioc_reset_count_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%08d\n", ioc->ioc_reset_count);
|
|
}
|
|
static DEVICE_ATTR(ioc_reset_count, S_IRUGO,
|
|
_ctl_ioc_reset_count_show, NULL);
|
|
|
|
struct DIAG_BUFFER_START {
|
|
u32 Size;
|
|
u32 DiagVersion;
|
|
u8 BufferType;
|
|
u8 Reserved[3];
|
|
u32 Reserved1;
|
|
u32 Reserved2;
|
|
u32 Reserved3;
|
|
};
|
|
/**
|
|
* _ctl_host_trace_buffer_size_show - host buffer size (trace only)
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_host_trace_buffer_size_show(struct device *cdev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
u32 size = 0;
|
|
struct DIAG_BUFFER_START *request_data;
|
|
|
|
if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
|
|
printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
|
|
"registered\n", ioc->name, __func__);
|
|
return 0;
|
|
}
|
|
|
|
if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
|
|
"registered\n", ioc->name, __func__);
|
|
return 0;
|
|
}
|
|
|
|
request_data = (struct DIAG_BUFFER_START *)
|
|
ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE];
|
|
if ((le32_to_cpu(request_data->DiagVersion) == 0x00000000 ||
|
|
le32_to_cpu(request_data->DiagVersion) == 0x01000000) &&
|
|
le32_to_cpu(request_data->Reserved3) == 0x4742444c)
|
|
size = le32_to_cpu(request_data->Size);
|
|
|
|
ioc->ring_buffer_sz = size;
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", size);
|
|
}
|
|
static DEVICE_ATTR(host_trace_buffer_size, S_IRUGO,
|
|
_ctl_host_trace_buffer_size_show, NULL);
|
|
|
|
/**
|
|
* _ctl_host_trace_buffer_show - firmware ring buffer (trace only)
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read/write' shost attribute.
|
|
*
|
|
* You will only be able to read 4k bytes of ring buffer at a time.
|
|
* In order to read beyond 4k bytes, you will have to write out the
|
|
* offset to the same attribute, it will move the pointer.
|
|
*/
|
|
static ssize_t
|
|
_ctl_host_trace_buffer_show(struct device *cdev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
void *request_data;
|
|
u32 size;
|
|
|
|
if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) {
|
|
printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
|
|
"registered\n", ioc->name, __func__);
|
|
return 0;
|
|
}
|
|
|
|
if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) == 0) {
|
|
printk(MPT2SAS_ERR_FMT "%s: host_trace_buffer is not "
|
|
"registered\n", ioc->name, __func__);
|
|
return 0;
|
|
}
|
|
|
|
if (ioc->ring_buffer_offset > ioc->ring_buffer_sz)
|
|
return 0;
|
|
|
|
size = ioc->ring_buffer_sz - ioc->ring_buffer_offset;
|
|
size = (size > PAGE_SIZE) ? PAGE_SIZE : size;
|
|
request_data = ioc->diag_buffer[0] + ioc->ring_buffer_offset;
|
|
memcpy(buf, request_data, size);
|
|
return size;
|
|
}
|
|
|
|
static ssize_t
|
|
_ctl_host_trace_buffer_store(struct device *cdev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
int val = 0;
|
|
|
|
if (sscanf(buf, "%d", &val) != 1)
|
|
return -EINVAL;
|
|
|
|
ioc->ring_buffer_offset = val;
|
|
return strlen(buf);
|
|
}
|
|
static DEVICE_ATTR(host_trace_buffer, S_IRUGO | S_IWUSR,
|
|
_ctl_host_trace_buffer_show, _ctl_host_trace_buffer_store);
|
|
|
|
/*****************************************/
|
|
|
|
/**
|
|
* _ctl_host_trace_buffer_enable_show - firmware ring buffer (trace only)
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* A sysfs 'read/write' shost attribute.
|
|
*
|
|
* This is a mechnism to post/release host_trace_buffers
|
|
*/
|
|
static ssize_t
|
|
_ctl_host_trace_buffer_enable_show(struct device *cdev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
|
|
if ((!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) ||
|
|
((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) == 0))
|
|
return snprintf(buf, PAGE_SIZE, "off\n");
|
|
else if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED))
|
|
return snprintf(buf, PAGE_SIZE, "release\n");
|
|
else
|
|
return snprintf(buf, PAGE_SIZE, "post\n");
|
|
}
|
|
|
|
static ssize_t
|
|
_ctl_host_trace_buffer_enable_store(struct device *cdev,
|
|
struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
|
|
char str[10] = "";
|
|
struct mpt2_diag_register diag_register;
|
|
u8 issue_reset = 0;
|
|
|
|
if (sscanf(buf, "%s", str) != 1)
|
|
return -EINVAL;
|
|
|
|
if (!strcmp(str, "post")) {
|
|
/* exit out if host buffers are already posted */
|
|
if ((ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE]) &&
|
|
(ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) &&
|
|
((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED) == 0))
|
|
goto out;
|
|
memset(&diag_register, 0, sizeof(struct mpt2_diag_register));
|
|
printk(MPT2SAS_INFO_FMT "posting host trace buffers\n",
|
|
ioc->name);
|
|
diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
|
|
diag_register.requested_buffer_size = (1024 * 1024);
|
|
diag_register.unique_id = 0x7075900;
|
|
ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] = 0;
|
|
_ctl_diag_register_2(ioc, &diag_register);
|
|
} else if (!strcmp(str, "release")) {
|
|
/* exit out if host buffers are already released */
|
|
if (!ioc->diag_buffer[MPI2_DIAG_BUF_TYPE_TRACE])
|
|
goto out;
|
|
if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_REGISTERED) == 0)
|
|
goto out;
|
|
if ((ioc->diag_buffer_status[MPI2_DIAG_BUF_TYPE_TRACE] &
|
|
MPT2_DIAG_BUFFER_IS_RELEASED))
|
|
goto out;
|
|
printk(MPT2SAS_INFO_FMT "releasing host trace buffer\n",
|
|
ioc->name);
|
|
_ctl_send_release(ioc, MPI2_DIAG_BUF_TYPE_TRACE, &issue_reset);
|
|
}
|
|
|
|
out:
|
|
return strlen(buf);
|
|
}
|
|
static DEVICE_ATTR(host_trace_buffer_enable, S_IRUGO | S_IWUSR,
|
|
_ctl_host_trace_buffer_enable_show, _ctl_host_trace_buffer_enable_store);
|
|
|
|
struct device_attribute *mpt2sas_host_attrs[] = {
|
|
&dev_attr_version_fw,
|
|
&dev_attr_version_bios,
|
|
&dev_attr_version_mpi,
|
|
&dev_attr_version_product,
|
|
&dev_attr_version_nvdata_persistent,
|
|
&dev_attr_version_nvdata_default,
|
|
&dev_attr_board_name,
|
|
&dev_attr_board_assembly,
|
|
&dev_attr_board_tracer,
|
|
&dev_attr_io_delay,
|
|
&dev_attr_device_delay,
|
|
&dev_attr_logging_level,
|
|
&dev_attr_fwfault_debug,
|
|
&dev_attr_fw_queue_depth,
|
|
&dev_attr_host_sas_address,
|
|
&dev_attr_ioc_reset_count,
|
|
&dev_attr_host_trace_buffer_size,
|
|
&dev_attr_host_trace_buffer,
|
|
&dev_attr_host_trace_buffer_enable,
|
|
NULL,
|
|
};
|
|
|
|
/**
|
|
* _ctl_device_sas_address_show - sas address
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* This is the sas address for the target
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_device_sas_address_show(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
|
|
(unsigned long long)sas_device_priv_data->sas_target->sas_address);
|
|
}
|
|
static DEVICE_ATTR(sas_address, S_IRUGO, _ctl_device_sas_address_show, NULL);
|
|
|
|
/**
|
|
* _ctl_device_handle_show - device handle
|
|
* @cdev - pointer to embedded class device
|
|
* @buf - the buffer returned
|
|
*
|
|
* This is the firmware assigned device handle
|
|
*
|
|
* A sysfs 'read-only' shost attribute.
|
|
*/
|
|
static ssize_t
|
|
_ctl_device_handle_show(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct MPT2SAS_DEVICE *sas_device_priv_data = sdev->hostdata;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%04x\n",
|
|
sas_device_priv_data->sas_target->handle);
|
|
}
|
|
static DEVICE_ATTR(sas_device_handle, S_IRUGO, _ctl_device_handle_show, NULL);
|
|
|
|
struct device_attribute *mpt2sas_dev_attrs[] = {
|
|
&dev_attr_sas_address,
|
|
&dev_attr_sas_device_handle,
|
|
NULL,
|
|
};
|
|
|
|
static const struct file_operations ctl_fops = {
|
|
.owner = THIS_MODULE,
|
|
.unlocked_ioctl = _ctl_ioctl,
|
|
.release = _ctl_release,
|
|
.poll = _ctl_poll,
|
|
.fasync = _ctl_fasync,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = _ctl_ioctl_compat,
|
|
#endif
|
|
};
|
|
|
|
static struct miscdevice ctl_dev = {
|
|
.minor = MPT2SAS_MINOR,
|
|
.name = MPT2SAS_DEV_NAME,
|
|
.fops = &ctl_fops,
|
|
};
|
|
|
|
/**
|
|
* mpt2sas_ctl_init - main entry point for ctl.
|
|
*
|
|
*/
|
|
void
|
|
mpt2sas_ctl_init(void)
|
|
{
|
|
async_queue = NULL;
|
|
if (misc_register(&ctl_dev) < 0)
|
|
printk(KERN_ERR "%s can't register misc device [minor=%d]\n",
|
|
MPT2SAS_DRIVER_NAME, MPT2SAS_MINOR);
|
|
|
|
init_waitqueue_head(&ctl_poll_wait);
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_ctl_exit - exit point for ctl
|
|
*
|
|
*/
|
|
void
|
|
mpt2sas_ctl_exit(void)
|
|
{
|
|
struct MPT2SAS_ADAPTER *ioc;
|
|
int i;
|
|
|
|
list_for_each_entry(ioc, &mpt2sas_ioc_list, list) {
|
|
|
|
/* free memory associated to diag buffers */
|
|
for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) {
|
|
if (!ioc->diag_buffer[i])
|
|
continue;
|
|
pci_free_consistent(ioc->pdev, ioc->diag_buffer_sz[i],
|
|
ioc->diag_buffer[i], ioc->diag_buffer_dma[i]);
|
|
ioc->diag_buffer[i] = NULL;
|
|
ioc->diag_buffer_status[i] = 0;
|
|
}
|
|
|
|
kfree(ioc->event_log);
|
|
}
|
|
misc_deregister(&ctl_dev);
|
|
}
|
|
|