1874 lines
61 KiB
C
1874 lines
61 KiB
C
/*
|
|
* This module provides common API for accessing firmware configuration pages
|
|
*
|
|
* This code is based on drivers/scsi/mpt2sas/mpt2_base.c
|
|
* Copyright (C) 2007-2008 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/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/pci.h>
|
|
|
|
#include "mpt2sas_base.h"
|
|
|
|
/* local definitions */
|
|
|
|
/* Timeout for config page request (in seconds) */
|
|
#define MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT 15
|
|
|
|
/* Common sgl flags for READING a config page. */
|
|
#define MPT2_CONFIG_COMMON_SGLFLAGS ((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_SHIFT)
|
|
|
|
/* Common sgl flags for WRITING a config page. */
|
|
#define MPT2_CONFIG_COMMON_WRITE_SGLFLAGS ((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) \
|
|
<< MPI2_SGE_FLAGS_SHIFT)
|
|
|
|
/**
|
|
* struct config_request - obtain dma memory via routine
|
|
* @config_page_sz: size
|
|
* @config_page: virt pointer
|
|
* @config_page_dma: phys pointer
|
|
*
|
|
*/
|
|
struct config_request{
|
|
u16 config_page_sz;
|
|
void *config_page;
|
|
dma_addr_t config_page_dma;
|
|
};
|
|
|
|
#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
|
|
/**
|
|
* _config_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
|
|
_config_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_CONFIG))
|
|
return;
|
|
|
|
mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
|
|
switch (mpi_request->Header.PageType & MPI2_CONFIG_PAGETYPE_MASK) {
|
|
case MPI2_CONFIG_PAGETYPE_IO_UNIT:
|
|
desc = "io_unit";
|
|
break;
|
|
case MPI2_CONFIG_PAGETYPE_IOC:
|
|
desc = "ioc";
|
|
break;
|
|
case MPI2_CONFIG_PAGETYPE_BIOS:
|
|
desc = "bios";
|
|
break;
|
|
case MPI2_CONFIG_PAGETYPE_RAID_VOLUME:
|
|
desc = "raid_volume";
|
|
break;
|
|
case MPI2_CONFIG_PAGETYPE_MANUFACTURING:
|
|
desc = "manufaucturing";
|
|
break;
|
|
case MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK:
|
|
desc = "physdisk";
|
|
break;
|
|
case MPI2_CONFIG_PAGETYPE_EXTENDED:
|
|
switch (mpi_request->ExtPageType) {
|
|
case MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT:
|
|
desc = "sas_io_unit";
|
|
break;
|
|
case MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER:
|
|
desc = "sas_expander";
|
|
break;
|
|
case MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE:
|
|
desc = "sas_device";
|
|
break;
|
|
case MPI2_CONFIG_EXTPAGETYPE_SAS_PHY:
|
|
desc = "sas_phy";
|
|
break;
|
|
case MPI2_CONFIG_EXTPAGETYPE_LOG:
|
|
desc = "log";
|
|
break;
|
|
case MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE:
|
|
desc = "enclosure";
|
|
break;
|
|
case MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG:
|
|
desc = "raid_config";
|
|
break;
|
|
case MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING:
|
|
desc = "driver_mappping";
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!desc)
|
|
return;
|
|
|
|
printk(MPT2SAS_DEBUG_FMT "%s: %s(%d), action(%d), form(0x%08x), "
|
|
"smid(%d)\n", ioc->name, calling_function_name, desc,
|
|
mpi_request->Header.PageNumber, mpi_request->Action,
|
|
le32_to_cpu(mpi_request->PageAddress), smid);
|
|
|
|
if (!mpi_reply)
|
|
return;
|
|
|
|
if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
|
|
printk(MPT2SAS_DEBUG_FMT
|
|
"\tiocstatus(0x%04x), loginfo(0x%08x)\n",
|
|
ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
|
|
le32_to_cpu(mpi_reply->IOCLogInfo));
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* mpt2sas_config_done - config page completion routine
|
|
* @ioc: per adapter object
|
|
* @smid: system request message index
|
|
* @VF_ID: virtual function id
|
|
* @reply: reply message frame(lower 32bit addr)
|
|
* Context: none.
|
|
*
|
|
* The callback handler when using _config_request.
|
|
*
|
|
* Return nothing.
|
|
*/
|
|
void
|
|
mpt2sas_config_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 VF_ID, u32 reply)
|
|
{
|
|
MPI2DefaultReply_t *mpi_reply;
|
|
|
|
if (ioc->config_cmds.status == MPT2_CMD_NOT_USED)
|
|
return;
|
|
if (ioc->config_cmds.smid != smid)
|
|
return;
|
|
ioc->config_cmds.status |= MPT2_CMD_COMPLETE;
|
|
mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
|
|
if (mpi_reply) {
|
|
ioc->config_cmds.status |= MPT2_CMD_REPLY_VALID;
|
|
memcpy(ioc->config_cmds.reply, mpi_reply,
|
|
mpi_reply->MsgLength*4);
|
|
}
|
|
ioc->config_cmds.status &= ~MPT2_CMD_PENDING;
|
|
#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
|
|
_config_display_some_debug(ioc, smid, "config_done", mpi_reply);
|
|
#endif
|
|
complete(&ioc->config_cmds.done);
|
|
}
|
|
|
|
/**
|
|
* _config_request - main routine for sending config page requests
|
|
* @ioc: per adapter object
|
|
* @mpi_request: request message frame
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @timeout: timeout in seconds
|
|
* Context: sleep, the calling function needs to acquire the config_cmds.mutex
|
|
*
|
|
* A generic API for config page requests to firmware.
|
|
*
|
|
* The ioc->config_cmds.status flag should be MPT2_CMD_NOT_USED before calling
|
|
* this API.
|
|
*
|
|
* The callback index is set inside `ioc->config_cb_idx.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
_config_request(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigRequest_t
|
|
*mpi_request, Mpi2ConfigReply_t *mpi_reply, int timeout)
|
|
{
|
|
u16 smid;
|
|
u32 ioc_state;
|
|
unsigned long timeleft;
|
|
Mpi2ConfigRequest_t *config_request;
|
|
int r;
|
|
u8 retry_count;
|
|
u8 issue_reset;
|
|
u16 wait_state_count;
|
|
|
|
if (ioc->config_cmds.status != MPT2_CMD_NOT_USED) {
|
|
printk(MPT2SAS_ERR_FMT "%s: config_cmd in use\n",
|
|
ioc->name, __func__);
|
|
return -EAGAIN;
|
|
}
|
|
retry_count = 0;
|
|
|
|
retry_config:
|
|
wait_state_count = 0;
|
|
ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
|
|
while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
|
|
if (wait_state_count++ == MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT) {
|
|
printk(MPT2SAS_ERR_FMT
|
|
"%s: failed due to ioc not operational\n",
|
|
ioc->name, __func__);
|
|
ioc->config_cmds.status = MPT2_CMD_NOT_USED;
|
|
return -EFAULT;
|
|
}
|
|
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__);
|
|
|
|
smid = mpt2sas_base_get_smid(ioc, ioc->config_cb_idx);
|
|
if (!smid) {
|
|
printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
|
|
ioc->name, __func__);
|
|
ioc->config_cmds.status = MPT2_CMD_NOT_USED;
|
|
return -EAGAIN;
|
|
}
|
|
|
|
r = 0;
|
|
memset(mpi_reply, 0, sizeof(Mpi2ConfigReply_t));
|
|
ioc->config_cmds.status = MPT2_CMD_PENDING;
|
|
config_request = mpt2sas_base_get_msg_frame(ioc, smid);
|
|
ioc->config_cmds.smid = smid;
|
|
memcpy(config_request, mpi_request, sizeof(Mpi2ConfigRequest_t));
|
|
#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
|
|
_config_display_some_debug(ioc, smid, "config_request", NULL);
|
|
#endif
|
|
mpt2sas_base_put_smid_default(ioc, smid, config_request->VF_ID);
|
|
timeleft = wait_for_completion_timeout(&ioc->config_cmds.done,
|
|
timeout*HZ);
|
|
if (!(ioc->config_cmds.status & MPT2_CMD_COMPLETE)) {
|
|
printk(MPT2SAS_ERR_FMT "%s: timeout\n",
|
|
ioc->name, __func__);
|
|
_debug_dump_mf(mpi_request,
|
|
sizeof(Mpi2ConfigRequest_t)/4);
|
|
if (!(ioc->config_cmds.status & MPT2_CMD_RESET))
|
|
issue_reset = 1;
|
|
goto issue_host_reset;
|
|
}
|
|
if (ioc->config_cmds.status & MPT2_CMD_REPLY_VALID)
|
|
memcpy(mpi_reply, ioc->config_cmds.reply,
|
|
sizeof(Mpi2ConfigReply_t));
|
|
if (retry_count)
|
|
printk(MPT2SAS_INFO_FMT "%s: retry completed!!\n",
|
|
ioc->name, __func__);
|
|
ioc->config_cmds.status = MPT2_CMD_NOT_USED;
|
|
return r;
|
|
|
|
issue_host_reset:
|
|
if (issue_reset)
|
|
mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
|
|
FORCE_BIG_HAMMER);
|
|
ioc->config_cmds.status = MPT2_CMD_NOT_USED;
|
|
if (!retry_count) {
|
|
printk(MPT2SAS_INFO_FMT "%s: attempting retry\n",
|
|
ioc->name, __func__);
|
|
retry_count++;
|
|
goto retry_config;
|
|
}
|
|
return -EFAULT;
|
|
}
|
|
|
|
/**
|
|
* _config_alloc_config_dma_memory - obtain physical memory
|
|
* @ioc: per adapter object
|
|
* @mem: struct config_request
|
|
*
|
|
* A wrapper for obtaining dma-able memory for config page request.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static int
|
|
_config_alloc_config_dma_memory(struct MPT2SAS_ADAPTER *ioc,
|
|
struct config_request *mem)
|
|
{
|
|
int r = 0;
|
|
|
|
mem->config_page = pci_alloc_consistent(ioc->pdev, mem->config_page_sz,
|
|
&mem->config_page_dma);
|
|
if (!mem->config_page)
|
|
r = -ENOMEM;
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* _config_free_config_dma_memory - wrapper to free the memory
|
|
* @ioc: per adapter object
|
|
* @mem: struct config_request
|
|
*
|
|
* A wrapper to free dma-able memory when using _config_alloc_config_dma_memory.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
static void
|
|
_config_free_config_dma_memory(struct MPT2SAS_ADAPTER *ioc,
|
|
struct config_request *mem)
|
|
{
|
|
pci_free_consistent(ioc->pdev, mem->config_page_sz, mem->config_page,
|
|
mem->config_page_dma);
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_manufacturing_pg0 - obtain manufacturing page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_manufacturing_pg0(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage0_t *config_page)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2ManufacturingPage0_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2ManufacturingPage0_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_bios_pg2 - obtain bios page 2
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_bios_pg2(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2BiosPage2_t *config_page)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2BiosPage2_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
|
|
mpi_request.Header.PageNumber = 2;
|
|
mpi_request.Header.PageVersion = MPI2_BIOSPAGE2_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2BiosPage2_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_bios_pg3 - obtain bios page 3
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_bios_pg3(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2BiosPage3_t *config_page)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2BiosPage3_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
|
|
mpi_request.Header.PageNumber = 3;
|
|
mpi_request.Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2BiosPage3_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_iounit_pg0 - obtain iounit page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_iounit_pg0(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage0_t *config_page)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2IOUnitPage0_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_IOUNITPAGE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2IOUnitPage0_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_iounit_pg1 - obtain iounit page 1
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_iounit_pg1(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2IOUnitPage1_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
|
|
mpi_request.Header.PageNumber = 1;
|
|
mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2IOUnitPage1_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_set_iounit_pg1 - set iounit page 1
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_set_iounit_pg1(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t config_page)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
|
|
mpi_request.Header.PageNumber = 1;
|
|
mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
|
|
memset(mem.config_page, 0, mem.config_page_sz);
|
|
memcpy(mem.config_page, &config_page,
|
|
sizeof(Mpi2IOUnitPage1_t));
|
|
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_WRITE_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_ioc_pg8 - obtain ioc page 8
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_ioc_pg8(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage8_t *config_page)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2IOCPage8_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
|
|
mpi_request.Header.PageNumber = 8;
|
|
mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2IOCPage8_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_sas_device_pg0 - obtain sas device page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @form: GET_NEXT_HANDLE or HANDLE
|
|
* @handle: device handle
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_sas_device_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2SasDevicePage0_t *config_page, u32 form, u32 handle)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2SasDevicePage0_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
|
|
mpi_request.Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress = cpu_to_le32(form | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2SasDevicePage0_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_sas_device_pg1 - obtain sas device page 1
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @form: GET_NEXT_HANDLE or HANDLE
|
|
* @handle: device handle
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_sas_device_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2SasDevicePage1_t *config_page, u32 form, u32 handle)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2SasDevicePage1_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
|
|
mpi_request.Header.PageVersion = MPI2_SASDEVICE1_PAGEVERSION;
|
|
mpi_request.Header.PageNumber = 1;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress = cpu_to_le32(form | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2SasDevicePage1_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_number_hba_phys - obtain number of phys on the host
|
|
* @ioc: per adapter object
|
|
* @num_phys: pointer returned with the number of phys
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_number_hba_phys(struct MPT2SAS_ADAPTER *ioc, u8 *num_phys)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
u16 ioc_status;
|
|
Mpi2ConfigReply_t mpi_reply;
|
|
Mpi2SasIOUnitPage0_t config_page;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, &mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply.Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply.Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply.Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply.ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply.ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply.ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, &mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r) {
|
|
ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
|
|
MPI2_IOCSTATUS_MASK;
|
|
if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
|
|
memcpy(&config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2SasIOUnitPage0_t)));
|
|
*num_phys = config_page.NumPhys;
|
|
}
|
|
}
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_sas_iounit_pg0 - obtain sas iounit page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @sz: size of buffer passed in config_page
|
|
* Context: sleep.
|
|
*
|
|
* Calling function should call config_get_number_hba_phys prior to
|
|
* this function, so enough memory is allocated for config_page.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_sas_iounit_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2SasIOUnitPage0_t *config_page, u16 sz)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sz);
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, sz, mem.config_page_sz));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_sas_iounit_pg1 - obtain sas iounit page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @sz: size of buffer passed in config_page
|
|
* Context: sleep.
|
|
*
|
|
* Calling function should call config_get_number_hba_phys prior to
|
|
* this function, so enough memory is allocated for config_page.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2SasIOUnitPage1_t *config_page, u16 sz)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sz);
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
|
|
mpi_request.Header.PageNumber = 1;
|
|
mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, sz, mem.config_page_sz));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_expander_pg0 - obtain expander page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @form: GET_NEXT_HANDLE or HANDLE
|
|
* @handle: expander handle
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_expander_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2ExpanderPage0_t *config_page, u32 form, u32 handle)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2ExpanderPage0_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_SASEXPANDER0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress = cpu_to_le32(form | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2ExpanderPage0_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_expander_pg1 - obtain expander page 1
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @phy_number: phy number
|
|
* @handle: expander handle
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_expander_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2ExpanderPage1_t *config_page, u32 phy_number,
|
|
u16 handle)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2ExpanderPage1_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
|
|
mpi_request.Header.PageNumber = 1;
|
|
mpi_request.Header.PageVersion = MPI2_SASEXPANDER1_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress =
|
|
cpu_to_le32(MPI2_SAS_EXPAND_PGAD_FORM_HNDL_PHY_NUM |
|
|
(phy_number << MPI2_SAS_EXPAND_PGAD_PHYNUM_SHIFT) | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2ExpanderPage1_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_enclosure_pg0 - obtain enclosure page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @form: GET_NEXT_HANDLE or HANDLE
|
|
* @handle: expander handle
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_enclosure_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2SasEnclosurePage0_t *config_page, u32 form, u32 handle)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2SasEnclosurePage0_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_SASENCLOSURE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress = cpu_to_le32(form | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2SasEnclosurePage0_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_phy_pg0 - obtain phy page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @phy_number: phy number
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_phy_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2SasPhyPage0_t *config_page, u32 phy_number)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2SasPhyPage0_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_SASPHY0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress =
|
|
cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2SasPhyPage0_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_phy_pg1 - obtain phy page 1
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @phy_number: phy number
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_phy_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2SasPhyPage1_t *config_page, u32 phy_number)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2SasPhyPage1_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
|
|
mpi_request.Header.PageNumber = 1;
|
|
mpi_request.Header.PageVersion = MPI2_SASPHY1_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress =
|
|
cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply->ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply->ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2SasPhyPage1_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_raid_volume_pg1 - obtain raid volume page 1
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @form: GET_NEXT_HANDLE or HANDLE
|
|
* @handle: volume handle
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_raid_volume_pg1(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage1_t *config_page, u32 form,
|
|
u32 handle)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(config_page, 0, sizeof(Mpi2RaidVolPage1_t));
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
|
|
mpi_request.Header.PageNumber = 1;
|
|
mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE1_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress = cpu_to_le32(form | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2RaidVolPage1_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_number_pds - obtain number of phys disk assigned to volume
|
|
* @ioc: per adapter object
|
|
* @handle: volume handle
|
|
* @num_pds: returns pds count
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_number_pds(struct MPT2SAS_ADAPTER *ioc, u16 handle,
|
|
u8 *num_pds)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
Mpi2RaidVolPage0_t *config_page;
|
|
Mpi2ConfigReply_t mpi_reply;
|
|
int r;
|
|
struct config_request mem;
|
|
u16 ioc_status;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
*num_pds = 0;
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, &mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress =
|
|
cpu_to_le32(MPI2_RAID_VOLUME_PGAD_FORM_HANDLE | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply.Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply.Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply.Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply.Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply.Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, &mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r) {
|
|
ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
|
|
MPI2_IOCSTATUS_MASK;
|
|
if (ioc_status == MPI2_IOCSTATUS_SUCCESS) {
|
|
config_page = mem.config_page;
|
|
*num_pds = config_page->NumPhysDisks;
|
|
}
|
|
}
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_raid_volume_pg0 - obtain raid volume page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @form: GET_NEXT_HANDLE or HANDLE
|
|
* @handle: volume handle
|
|
* @sz: size of buffer passed in config_page
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_raid_volume_pg0(struct MPT2SAS_ADAPTER *ioc,
|
|
Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage0_t *config_page, u32 form,
|
|
u32 handle, u16 sz)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
memset(config_page, 0, sz);
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress = cpu_to_le32(form | handle);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, sz, mem.config_page_sz));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_phys_disk_pg0 - obtain phys disk page 0
|
|
* @ioc: per adapter object
|
|
* @mpi_reply: reply mf payload returned from firmware
|
|
* @config_page: contents of the config page
|
|
* @form: GET_NEXT_PHYSDISKNUM, PHYSDISKNUM, DEVHANDLE
|
|
* @form_specific: specific to the form
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_phys_disk_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
|
|
*mpi_reply, Mpi2RaidPhysDiskPage0_t *config_page, u32 form,
|
|
u32 form_specific)
|
|
{
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
int r;
|
|
struct config_request mem;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
memset(config_page, 0, sizeof(Mpi2RaidPhysDiskPage0_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpi_request.Header.PageVersion = MPI2_RAIDPHYSDISKPAGE0_PAGEVERSION;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress = cpu_to_le32(form | form_specific);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply->Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply->Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply->Header.PageType;
|
|
mpi_request.Header.PageLength = mpi_reply->Header.PageLength;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply->Header.PageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (!r)
|
|
memcpy(config_page, mem.config_page,
|
|
min_t(u16, mem.config_page_sz,
|
|
sizeof(Mpi2RaidPhysDiskPage0_t)));
|
|
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_volume_handle - returns volume handle for give hidden raid components
|
|
* @ioc: per adapter object
|
|
* @pd_handle: phys disk handle
|
|
* @volume_handle: volume handle
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_volume_handle(struct MPT2SAS_ADAPTER *ioc, u16 pd_handle,
|
|
u16 *volume_handle)
|
|
{
|
|
Mpi2RaidConfigurationPage0_t *config_page;
|
|
Mpi2ConfigRequest_t mpi_request;
|
|
Mpi2ConfigReply_t mpi_reply;
|
|
int r, i;
|
|
struct config_request mem;
|
|
u16 ioc_status;
|
|
|
|
mutex_lock(&ioc->config_cmds.mutex);
|
|
*volume_handle = 0;
|
|
memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
|
|
mpi_request.Function = MPI2_FUNCTION_CONFIG;
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
|
|
mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
|
|
mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG;
|
|
mpi_request.Header.PageVersion = MPI2_RAIDCONFIG0_PAGEVERSION;
|
|
mpi_request.Header.PageNumber = 0;
|
|
mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
|
|
r = _config_request(ioc, &mpi_request, &mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
mpi_request.PageAddress =
|
|
cpu_to_le32(MPI2_RAID_PGAD_FORM_ACTIVE_CONFIG);
|
|
mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
|
|
mpi_request.Header.PageVersion = mpi_reply.Header.PageVersion;
|
|
mpi_request.Header.PageNumber = mpi_reply.Header.PageNumber;
|
|
mpi_request.Header.PageType = mpi_reply.Header.PageType;
|
|
mpi_request.ExtPageLength = mpi_reply.ExtPageLength;
|
|
mpi_request.ExtPageType = mpi_reply.ExtPageType;
|
|
mem.config_page_sz = le16_to_cpu(mpi_reply.ExtPageLength) * 4;
|
|
if (mem.config_page_sz > ioc->config_page_sz) {
|
|
r = _config_alloc_config_dma_memory(ioc, &mem);
|
|
if (r)
|
|
goto out;
|
|
} else {
|
|
mem.config_page_dma = ioc->config_page_dma;
|
|
mem.config_page = ioc->config_page;
|
|
}
|
|
ioc->base_add_sg_single(&mpi_request.PageBufferSGE,
|
|
MPT2_CONFIG_COMMON_SGLFLAGS | mem.config_page_sz,
|
|
mem.config_page_dma);
|
|
r = _config_request(ioc, &mpi_request, &mpi_reply,
|
|
MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT);
|
|
if (r)
|
|
goto out;
|
|
|
|
r = -1;
|
|
ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
|
|
if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
|
|
goto done;
|
|
config_page = mem.config_page;
|
|
for (i = 0; i < config_page->NumElements; i++) {
|
|
if ((config_page->ConfigElement[i].ElementFlags &
|
|
MPI2_RAIDCONFIG0_EFLAGS_MASK_ELEMENT_TYPE) !=
|
|
MPI2_RAIDCONFIG0_EFLAGS_VOL_PHYS_DISK_ELEMENT)
|
|
continue;
|
|
if (config_page->ConfigElement[i].PhysDiskDevHandle ==
|
|
pd_handle) {
|
|
*volume_handle = le16_to_cpu(config_page->
|
|
ConfigElement[i].VolDevHandle);
|
|
r = 0;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (mem.config_page_sz > ioc->config_page_sz)
|
|
_config_free_config_dma_memory(ioc, &mem);
|
|
|
|
out:
|
|
mutex_unlock(&ioc->config_cmds.mutex);
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* mpt2sas_config_get_volume_wwid - returns wwid given the volume handle
|
|
* @ioc: per adapter object
|
|
* @volume_handle: volume handle
|
|
* @wwid: volume wwid
|
|
* Context: sleep.
|
|
*
|
|
* Returns 0 for success, non-zero for failure.
|
|
*/
|
|
int
|
|
mpt2sas_config_get_volume_wwid(struct MPT2SAS_ADAPTER *ioc, u16 volume_handle,
|
|
u64 *wwid)
|
|
{
|
|
Mpi2ConfigReply_t mpi_reply;
|
|
Mpi2RaidVolPage1_t raid_vol_pg1;
|
|
|
|
*wwid = 0;
|
|
if (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
|
|
&raid_vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE,
|
|
volume_handle))) {
|
|
*wwid = le64_to_cpu(raid_vol_pg1.WWID);
|
|
return 0;
|
|
} else
|
|
return -1;
|
|
}
|