/* * Management Module Support for MPT (Message Passing Technology) based * controllers * * This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.c * Copyright (C) 2012-2014 LSI Corporation * Copyright (C) 2013-2014 Avago Technologies * (mailto: MPT-FusionLinux.pdl@avagotech.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * NO WARRANTY * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is * solely responsible for determining the appropriateness of using and * distributing the Program and assumes all risks associated with its * exercise of rights under this Agreement, including but not limited to * the risks and costs of program errors, damage to or loss of data, * programs or equipment, and unavailability or interruption of operations.
* DISCLAIMER OF LIABILITY * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
* You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, * USA.
*/
/** * 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_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 helpful when debugging issues * in this module.
*/ staticvoid
_ctl_display_some_debug(struct MPT3SAS_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;
/** * mpt3sas_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
mpt3sas_ctl_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
u32 reply)
{
MPI2DefaultReply_t *mpi_reply;
Mpi2SCSIIOReply_t *scsiio_reply;
Mpi26NVMeEncapsulatedErrorReply_t *nvme_error_reply; constvoid *sense_data;
u32 sz;
if (ioc->ctl_cmds.status == MPT3_CMD_NOT_USED) return 1; if (ioc->ctl_cmds.smid != smid) return 1;
ioc->ctl_cmds.status |= MPT3_CMD_COMPLETE;
mpi_reply = mpt3sas_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 |= MPT3_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 = mpt3sas_base_get_sense_buffer(ioc,
smid);
memcpy(ioc->ctl_cmds.sense, sense_data, sz);
}
} /* * Get Error Response data for NVMe device. The ctl_cmds.sense * buffer is used to store the Error Response data.
*/ if (mpi_reply->Function == MPI2_FUNCTION_NVME_ENCAPSULATED) {
nvme_error_reply =
(Mpi26NVMeEncapsulatedErrorReply_t *)mpi_reply;
sz = min_t(u32, NVME_ERROR_RESPONSE_SIZE,
le16_to_cpu(nvme_error_reply->ErrorResponseCount));
sense_data = mpt3sas_base_get_sense_buffer(ioc, smid);
memcpy(ioc->ctl_cmds.sense, sense_data, sz);
}
}
/** * _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. * * Return: 1 when event should be captured, or zero means no match.
*/ staticint
_ctl_check_event_type(struct MPT3SAS_ADAPTER *ioc, u16 event)
{
u16 i;
u32 desired_event;
if (event >= 128 || !event || !ioc->event_log) return 0;
/* 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);
}
}
/** * mpt3sas_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
mpt3sas_ctl_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
u32 reply)
{
Mpi2EventNotificationReply_t *mpi_reply;
/** * _ctl_verify_adapter - validates ioc_number passed from application * @ioc_number: ? * @iocpp: The ioc pointer is returned in this. * @mpi_version: will be MPI2_VERSION for mpt2ctl ioctl device & * MPI25_VERSION | MPI26_VERSION for mpt3ctl ioctl device. * * Return: (-1) means error, else ioc_number.
*/ staticint
_ctl_verify_adapter(int ioc_number, struct MPT3SAS_ADAPTER **iocpp, int mpi_version)
{ struct MPT3SAS_ADAPTER *ioc; int version = 0; /* global ioc lock to protect controller on list operations */
spin_lock(&gioc_lock);
list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { if (ioc->id != ioc_number) continue; /* Check whether this ioctl command is from right * ioctl device or not, if not continue the search.
*/
version = ioc->hba_mpi_version_belonged; /* MPI25_VERSION and MPI26_VERSION uses same ioctl * device.
*/ if (mpi_version == (MPI25_VERSION | MPI26_VERSION)) { if ((version == MPI25_VERSION) ||
(version == MPI26_VERSION)) goto out; else continue;
} else { if (version != mpi_version) continue;
}
out:
spin_unlock(&gioc_lock);
*iocpp = ioc; return ioc_number;
}
spin_unlock(&gioc_lock);
*iocpp = NULL; return -1;
}
/** * mpt3sas_ctl_pre_reset_handler - reset callback handler (for ctl) * @ioc: per adapter object * * The handler for doing any required cleanup or initialization.
*/ void mpt3sas_ctl_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc)
{ int i;
u8 issue_reset;
dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__)); for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { if (!(ioc->diag_buffer_status[i] &
MPT3_DIAG_BUFFER_IS_REGISTERED)) continue; if ((ioc->diag_buffer_status[i] &
MPT3_DIAG_BUFFER_IS_RELEASED)) continue;
/* * add a log message to indicate the release
*/
ioc_info(ioc, "%s: Releasing the trace buffer due to adapter reset.",
__func__);
ioc->htb_rel.buffer_rel_condition =
MPT3_DIAG_BUFFER_REL_TRIGGER;
mpt3sas_send_diag_release(ioc, i, &issue_reset);
}
}
/** * mpt3sas_ctl_clear_outstanding_ioctls - clears outstanding ioctl cmd. * @ioc: per adapter object * * The handler for doing any required cleanup or initialization.
*/ void mpt3sas_ctl_clear_outstanding_ioctls(struct MPT3SAS_ADAPTER *ioc)
{
dtmprintk(ioc,
ioc_info(ioc, "%s: clear outstanding ioctl cmd\n", __func__)); if (ioc->ctl_cmds.status & MPT3_CMD_PENDING) {
ioc->ctl_cmds.status |= MPT3_CMD_RESET;
mpt3sas_base_free_smid(ioc, ioc->ctl_cmds.smid);
complete(&ioc->ctl_cmds.done);
}
}
/** * mpt3sas_ctl_reset_done_handler - reset callback handler (for ctl) * @ioc: per adapter object * * The handler for doing any required cleanup or initialization.
*/ void mpt3sas_ctl_reset_done_handler(struct MPT3SAS_ADAPTER *ioc)
{ int i;
for (i = 0; i < MPI2_DIAG_BUF_TYPE_COUNT; i++) { if (!(ioc->diag_buffer_status[i] &
MPT3_DIAG_BUFFER_IS_REGISTERED)) continue; if ((ioc->diag_buffer_status[i] &
MPT3_DIAG_BUFFER_IS_RELEASED)) continue;
ioc->diag_buffer_status[i] |=
MPT3_DIAG_BUFFER_IS_DIAG_RESET;
}
}
/* global ioc lock to protect controller on list operations */
spin_lock(&gioc_lock);
list_for_each_entry(ioc, &mpt3sas_ioc_list, list) { if (ioc->aen_event_read_flag) {
spin_unlock(&gioc_lock); return EPOLLIN | EPOLLRDNORM;
}
}
spin_unlock(&gioc_lock); return 0;
}
/** * _ctl_set_task_mid - assign an active smid to tm request * @ioc: per adapter object * @karg: (struct mpt3_ioctl_command) * @tm_request: pointer to mf from user space * * Return: 0 when an smid if found, else fail. * during failure, the reply frame is filled.
*/ staticint
_ctl_set_task_mid(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command *karg,
Mpi2SCSITaskManagementRequest_t *tm_request)
{ bool found = false;
u16 smid;
u16 handle; struct scsi_cmnd *scmd; struct MPT3SAS_DEVICE *priv_data;
Mpi2SCSITaskManagementReply_t *tm_reply;
u32 sz;
u32 lun; char *desc = NULL;
scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); if (!scmd) 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;
st = scsi_cmd_priv(scmd);
/* * If the given TaskMID from the user space is zero, then the * first outstanding smid will be picked up. Otherwise, * targeted smid will be the one.
*/
task_mid = cpu_to_le16(st->smid); if (!tm_request->TaskMID)
tm_request->TaskMID = task_mid;
found = tm_request->TaskMID == task_mid;
}
if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
ret = -EAGAIN; goto out;
}
ret = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT); if (ret) goto out;
mpi_request = kzalloc(ioc->request_sz, GFP_KERNEL); if (!mpi_request) {
ioc_err(ioc, "%s: failed obtaining a memory for mpi_request\n",
__func__);
ret = -ENOMEM; goto out;
}
/* Check for overflow and wraparound */ if (karg.data_sge_offset * 4 > ioc->request_sz ||
karg.data_sge_offset > (UINT_MAX / 4)) {
ret = -EINVAL; goto out;
}
/* copy in request message frame from user */ if (copy_from_user(mpi_request, mf, karg.data_sge_offset*4)) {
pr_err("failure at %s:%d/%s()!\n", __FILE__, __LINE__,
__func__);
ret = -EFAULT; goto out;
}
if (mpi_request->Function == MPI2_FUNCTION_SCSI_TASK_MGMT) {
smid = mpt3sas_base_get_smid_hpr(ioc, ioc->ctl_cb_idx); if (!smid) {
ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
ret = -EAGAIN; goto out;
}
} else { /* Use first reserved smid for passthrough ioctls */
smid = ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT + 1;
}
if (ioc->logging_level & MPT_DEBUG_TM)
_debug_dump_mf(nvme_encap_request,
ioc->request_sz/4);
mpt3sas_base_free_smid(ioc, smid);
ret = -EINVAL; goto out;
} /* * Get the Physical Address of the sense buffer. * Use Error Response buffer address field to hold the sense * buffer address. * Clear the internal sense buffer, which will potentially hold * the Completion Queue Entry on return, or 0 if no Entry. * Build the PRPs and set direction bits. * Send the request.
*/
nvme_encap_request->ErrorResponseBaseAddress =
cpu_to_le64(ioc->sense_dma & 0xFFFFFFFF00000000UL);
nvme_encap_request->ErrorResponseBaseAddress |=
cpu_to_le64(le32_to_cpu(
mpt3sas_base_get_sense_buffer_dma(ioc, smid)));
nvme_encap_request->ErrorResponseAllocationLength =
cpu_to_le16(NVME_ERROR_RESPONSE_SIZE);
memset(ioc->ctl_cmds.sense, 0, NVME_ERROR_RESPONSE_SIZE);
ioc->build_nvme_prp(ioc, smid, nvme_encap_request,
data_out_dma, data_out_sz, data_in_dma, data_in_sz); if (test_bit(device_handle, ioc->device_remove_in_progress)) {
dtmprintk(ioc,
ioc_info(ioc, "handle(0x%04x): ioctl failed due to device removal in progress\n",
device_handle));
mpt3sas_base_free_smid(ioc, smid);
ret = -EINVAL; goto out;
}
mpt3sas_base_put_smid_nvme_encap(ioc, smid); break;
} 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 =
mpt3sas_base_get_sense_buffer_dma(ioc, smid);
memset(ioc->ctl_cmds.sense, 0, SCSI_SENSE_BUFFERSIZE); if (test_bit(device_handle, ioc->device_remove_in_progress)) {
dtmprintk(ioc,
ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
device_handle));
mpt3sas_base_free_smid(ioc, smid);
ret = -EINVAL; goto out;
}
ioc->build_sg(ioc, psge, data_out_dma, data_out_sz,
data_in_dma, data_in_sz); if (mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)
ioc->put_smid_scsi_io(ioc, smid, device_handle); else
ioc->put_smid_default(ioc, smid); break;
} case MPI2_FUNCTION_SCSI_TASK_MGMT:
{
Mpi2SCSITaskManagementRequest_t *tm_request =
(Mpi2SCSITaskManagementRequest_t *)request;
if (test_bit(device_handle, ioc->device_remove_in_progress)) {
dtmprintk(ioc,
ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
device_handle));
mpt3sas_base_free_smid(ioc, smid);
ret = -EINVAL; goto out;
}
mpt3sas_scsih_set_tm_flag(ioc, le16_to_cpu(
tm_request->DevHandle));
ioc->build_sg_mpi(ioc, psge, data_out_dma, data_out_sz,
data_in_dma, data_in_sz);
ioc->put_smid_hi_priority(ioc, smid, 0); break;
} case MPI2_FUNCTION_SMP_PASSTHROUGH:
{
Mpi2SmpPassthroughRequest_t *smp_request =
(Mpi2SmpPassthroughRequest_t *)mpi_request;
u8 *data;
if (!ioc->multipath_on_hba) { /* 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 { if (unlikely(data_out == NULL)) {
pr_err("failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__);
mpt3sas_base_free_smid(ioc, smid);
ret = -EINVAL; goto out;
}
data = data_out;
}
if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
ioc->ioc_link_reset_in_progress = 1;
ioc->ignore_loginfos = 1;
}
ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
data_in_sz);
ioc->put_smid_default(ioc, smid); break;
} case MPI2_FUNCTION_SATA_PASSTHROUGH:
{ if (test_bit(device_handle, ioc->device_remove_in_progress)) {
dtmprintk(ioc,
ioc_info(ioc, "handle(0x%04x) :ioctl failed due to device removal in progress\n",
device_handle));
mpt3sas_base_free_smid(ioc, smid);
ret = -EINVAL; goto out;
}
ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
data_in_sz);
ioc->put_smid_default(ioc, smid); break;
} case MPI2_FUNCTION_FW_DOWNLOAD:
{ if (ioc->pdev->vendor == MPI2_MFGPAGE_VENDORID_ATTO) {
ioc_info(ioc, "Firmware download not supported for ATTO HBA.\n");
ret = -EPERM; break;
}
fallthrough;
} case MPI2_FUNCTION_FW_UPLOAD:
{
ioc->build_sg(ioc, psge, data_out_dma, data_out_sz, data_in_dma,
data_in_sz);
ioc->put_smid_default(ioc, smid); break;
} case MPI2_FUNCTION_TOOLBOX:
{
Mpi2ToolboxCleanRequest_t *toolbox_request =
(Mpi2ToolboxCleanRequest_t *)mpi_request;
/* copy out xdata to user */ if (data_in_sz) { if (copy_to_user(karg.data_in_buf_ptr, data_in,
data_in_sz)) {
pr_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)) {
pr_err("failure at %s:%d/%s()!\n", __FILE__,
__LINE__, __func__);
ret = -ENODATA; goto out;
}
}
/* copy out sense/NVMe Error Response to user */ if (karg.max_sense_bytes && (mpi_request->Function ==
MPI2_FUNCTION_SCSI_IO_REQUEST || mpi_request->Function ==
MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH || mpi_request->Function ==
MPI2_FUNCTION_NVME_ENCAPSULATED)) { if (karg.sense_data_ptr == NULL) {
ioc_info(ioc, "Response buffer provided by application is NULL; Response data will not be returned\n"); goto out;
}
sz_arg = (mpi_request->Function ==
MPI2_FUNCTION_NVME_ENCAPSULATED) ? NVME_ERROR_RESPONSE_SIZE :
SCSI_SENSE_BUFFERSIZE;
sz = min_t(u32, karg.max_sense_bytes, sz_arg); if (copy_to_user(karg.sense_data_ptr, ioc->ctl_cmds.sense,
sz)) {
pr_err("failure at %s:%d/%s()!\n", __FILE__,
__LINE__, __func__);
ret = -ENODATA; goto out;
}
}
/** * _ctl_btdh_mapping - main handler for MPT3BTDHMAPPING opcode * @ioc: per adapter object * @arg: user space buffer containing ioctl content
*/ staticlong
_ctl_btdh_mapping(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
{ struct mpt3_ioctl_btdh_mapping karg; int rc;
if (copy_from_user(&karg, arg, sizeof(karg))) {
pr_err("failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__); return -EFAULT;
}
dctlprintk(ioc, ioc_info(ioc, "%s\n",
__func__));
rc = _ctl_btdh_search_sas_device(ioc, &karg); if (!rc)
rc = _ctl_btdh_search_pcie_device(ioc, &karg); if (!rc)
_ctl_btdh_search_raid_device(ioc, &karg);
if (copy_to_user(arg, &karg, sizeof(karg))) {
pr_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 MPT3SAS_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_get_bufftype - return diag buffer type * either TRACE, SNAPSHOT, or EXTENDED * @ioc: per adapter object * @unique_id: specifies the unique_id for the buffer * * returns MPT3_DIAG_UID_NOT_FOUND if the id not found
*/ static u8
_ctl_diag_get_bufftype(struct MPT3SAS_ADAPTER *ioc, u32 unique_id)
{
u8 index;
for (index = 0; index < MPI2_DIAG_BUF_TYPE_COUNT; index++) { if (ioc->unique_id[index] == unique_id) return index;
}
return MPT3_DIAG_UID_NOT_FOUND;
}
/** * _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 *
*/ staticlong
_ctl_diag_register_2(struct MPT3SAS_ADAPTER *ioc, struct mpt3_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;
u16 smid;
u16 ioc_status;
u32 ioc_state;
u8 issue_reset = 0;
dctlprintk(ioc, ioc_info(ioc, "%s\n",
__func__));
ioc_state = mpt3sas_base_get_iocstate(ioc, 1); if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
ioc_err(ioc, "%s: failed due to ioc not operational\n",
__func__);
rc = -EAGAIN; goto out;
}
if (ioc->ctl_cmds.status != MPT3_CMD_NOT_USED) {
ioc_err(ioc, "%s: ctl_cmd in use\n", __func__);
rc = -EAGAIN; goto out;
}
buffer_type = diag_register->buffer_type; if (!_ctl_diag_capability(ioc, buffer_type)) {
ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
__func__, buffer_type); return -EPERM;
}
if ((ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_APP_OWNED) &&
!(ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_RELEASED)) {
ioc_err(ioc, "%s: buffer_type(0x%02x) is already registered by application with UID(0x%08x)\n",
__func__, buffer_type, ioc->unique_id[buffer_type]); return -EINVAL;
}
if (ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_REGISTERED) { /* * If driver posts buffer initially, then an application wants * to Register that buffer (own it) without Releasing first, * the application Register command MUST have the same buffer * type and size in the Register command (obtained from the * Query command). Otherwise that Register command will be * failed. If the application has released the buffer but wants * to re-register it, it should be allowed as long as the * Unique-Id/Size match.
*/
if (ioc->unique_id[buffer_type] == MPT3DIAGBUFFUNIQUEID &&
ioc->diag_buffer_sz[buffer_type] ==
diag_register->requested_buffer_size) {
/* * Application wants to own the buffer with * the same size.
*/
ioc->unique_id[buffer_type] =
diag_register->unique_id;
rc = 0; /* success */ goto out;
}
} elseif (ioc->unique_id[buffer_type] !=
MPT3DIAGBUFFUNIQUEID) { if (ioc->unique_id[buffer_type] !=
diag_register->unique_id ||
ioc->diag_buffer_sz[buffer_type] !=
diag_register->requested_buffer_size ||
!(ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_RELEASED)) {
ioc_err(ioc, "%s: already has a registered buffer for buffer_type(0x%02x)\n",
__func__, buffer_type); return -EINVAL;
}
} else {
ioc_err(ioc, "%s: already has a registered buffer for buffer_type(0x%02x)\n",
__func__, buffer_type); return -EINVAL;
}
} elseif (ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED) {
if (ioc->unique_id[buffer_type] != MPT3DIAGBUFFUNIQUEID ||
ioc->diag_buffer_sz[buffer_type] !=
diag_register->requested_buffer_size) {
ioc_err(ioc, "%s: already a buffer is allocated for buffer_type(0x%02x) of size %d bytes, so please try registering again with same size\n",
__func__, buffer_type,
ioc->diag_buffer_sz[buffer_type]); return -EINVAL;
}
}
if (diag_register->requested_buffer_size % 4) {
ioc_err(ioc, "%s: the requested_buffer_size is not 4 byte aligned\n",
__func__); return -EINVAL;
}
smid = mpt3sas_base_get_smid(ioc, ioc->ctl_cb_idx); if (!smid) {
ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
rc = -EAGAIN; goto out;
}
/** * mpt3sas_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
mpt3sas_enable_diag_buffer(struct MPT3SAS_ADAPTER *ioc, u8 bits_to_register)
{ struct mpt3_diag_register diag_register;
u32 ret_val;
u32 trace_buff_size = ioc->manu_pg11.HostTraceBufferMaxSizeKB<<10;
u32 min_trace_buff_size = 0;
u32 decr_trace_buff_size = 0;
if (min_trace_buff_size > trace_buff_size) { /* The buff size is not set correctly */
ioc_err(ioc, "Min Trace Buff size (%d KB) greater than Max Trace Buff size (%d KB)\n",
min_trace_buff_size>>10,
trace_buff_size>>10);
ioc_err(ioc, "Using zero Min Trace Buff Size\n");
min_trace_buff_size = 0;
}
if (decr_trace_buff_size == 0) { /* * retry the min size if decrement * is not available.
*/
decr_trace_buff_size =
trace_buff_size - min_trace_buff_size;
}
} else { /* register for 2MB buffers */
diag_register.requested_buffer_size = 2 * (1024 * 1024);
}
do {
ret_val = _ctl_diag_register_2(ioc, &diag_register);
/** * _ctl_diag_register - application register with driver * @ioc: per adapter object * @arg: user space buffer containing ioctl content * * This will allow the driver to setup any required buffers that will be * needed by firmware to communicate with the driver.
*/ staticlong
_ctl_diag_register(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
{ struct mpt3_diag_register karg; long rc;
if (copy_from_user(&karg, arg, sizeof(karg))) {
pr_err("failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__); return -EFAULT;
}
rc = _ctl_diag_register_2(ioc, &karg);
if (!rc && (ioc->diag_buffer_status[karg.buffer_type] &
MPT3_DIAG_BUFFER_IS_REGISTERED))
ioc->diag_buffer_status[karg.buffer_type] |=
MPT3_DIAG_BUFFER_IS_APP_OWNED;
return rc;
}
/** * _ctl_diag_unregister - application unregister with driver * @ioc: per adapter object * @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.
*/ staticlong
_ctl_diag_unregister(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
{ struct mpt3_diag_unregister karg; void *request_data;
dma_addr_t request_data_dma;
u32 request_data_sz;
u8 buffer_type;
if (copy_from_user(&karg, arg, sizeof(karg))) {
pr_err("failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__); return -EFAULT;
}
dctlprintk(ioc, ioc_info(ioc, "%s\n",
__func__));
buffer_type = _ctl_diag_get_bufftype(ioc, karg.unique_id); if (buffer_type == MPT3_DIAG_UID_NOT_FOUND) {
ioc_err(ioc, "%s: buffer with unique_id(0x%08x) not found\n",
__func__, karg.unique_id); return -EINVAL;
}
if (!_ctl_diag_capability(ioc, buffer_type)) {
ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
__func__, buffer_type); return -EPERM;
}
if ((ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
__func__, buffer_type); return -EINVAL;
} if ((ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_RELEASED) == 0) {
ioc_err(ioc, "%s: buffer_type(0x%02x) has not been released\n",
__func__, buffer_type); return -EINVAL;
}
if (karg.unique_id != ioc->unique_id[buffer_type]) {
ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
__func__, karg.unique_id); return -EINVAL;
}
request_data = ioc->diag_buffer[buffer_type]; if (!request_data) {
ioc_err(ioc, "%s: doesn't have memory allocated for buffer_type(0x%02x)\n",
__func__, buffer_type); return -ENOMEM;
}
/** * _ctl_diag_query - query relevant info associated with diag buffers * @ioc: per adapter object * @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.
*/ staticlong
_ctl_diag_query(struct MPT3SAS_ADAPTER *ioc, void __user *arg)
{ struct mpt3_diag_query karg; void *request_data; int i;
u8 buffer_type;
if (copy_from_user(&karg, arg, sizeof(karg))) {
pr_err("failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__); return -EFAULT;
}
if (!_ctl_diag_capability(ioc, buffer_type)) {
ioc_err(ioc, "%s: doesn't have capability for buffer_type(0x%02x)\n",
__func__, buffer_type); return -EPERM;
}
if (!(ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED)) { if ((ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_REGISTERED) == 0) {
ioc_err(ioc, "%s: buffer_type(0x%02x) is not registered\n",
__func__, buffer_type); return -EINVAL;
}
}
if (karg.unique_id) { if (karg.unique_id != ioc->unique_id[buffer_type]) {
ioc_err(ioc, "%s: unique_id(0x%08x) is not registered\n",
__func__, karg.unique_id); return -EINVAL;
}
}
request_data = ioc->diag_buffer[buffer_type]; if (!request_data) {
ioc_err(ioc, "%s: doesn't have buffer for buffer_type(0x%02x)\n",
__func__, buffer_type); return -ENOMEM;
}
if ((ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_REGISTERED))
karg.application_flags |= MPT3_APP_FLAGS_BUFFER_VALID;
if (!(ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_RELEASED))
karg.application_flags |= MPT3_APP_FLAGS_FW_BUFFER_ACCESS;
if (!(ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_DRIVER_ALLOCATED))
karg.application_flags |= MPT3_APP_FLAGS_DYNAMIC_BUFFER_ALLOC;
if ((ioc->diag_buffer_status[buffer_type] &
MPT3_DIAG_BUFFER_IS_APP_OWNED))
karg.application_flags |= MPT3_APP_FLAGS_APP_OWNED;
for (i = 0; i < MPT3_PRODUCT_SPECIFIC_DWORDS; i++)
karg.product_specific[i] =
ioc->product_specific[buffer_type][i];
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
