drivers/scsi/mpt3sas/mpt3sas_config.c

   1 /*
   2  * This module provides common API for accessing firmware configuration pages
   3  *
   4  * This code is based on drivers/scsi/mpt3sas/mpt3sas_base.c
   5  * Copyright (C) 2012-2014  LSI Corporation
   6  * Copyright (C) 2013-2014 Avago Technologies
   7  *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * NO WARRANTY
  20  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  21  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  22  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  23  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  24  * solely responsible for determining the appropriateness of using and
  25  * distributing the Program and assumes all risks associated with its
  26  * exercise of rights under this Agreement, including but not limited to
  27  * the risks and costs of program errors, damage to or loss of data,
  28  * programs or equipment, and unavailability or interruption of operations.
  29
  30  * DISCLAIMER OF LIABILITY
  31  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  32  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  34  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  35  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  36  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  37  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  38
  39  * You should have received a copy of the GNU General Public License
  40  * along with this program; if not, write to the Free Software
  41  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  42  * USA.
  43  */
  44
  45 #include <linux/module.h>
  46 #include <linux/kernel.h>
  47 #include <linux/init.h>
  48 #include <linux/errno.h>
  49 #include <linux/blkdev.h>
  50 #include <linux/sched.h>
  51 #include <linux/workqueue.h>
  52 #include <linux/delay.h>
  53 #include <linux/pci.h>
  54
  55 #include "mpt3sas_base.h"
  56
  57 /* local definitions */
  58
  59 /* Timeout for config page request (in seconds) */
  60 #define MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT 15
  61
  62 /* Common sgl flags for READING a config page. */
  63 #define MPT3_CONFIG_COMMON_SGLFLAGS ((MPI2_SGE_FLAGS_SIMPLE_ELEMENT | \
  64         MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER \
  65         | MPI2_SGE_FLAGS_END_OF_LIST) << MPI2_SGE_FLAGS_SHIFT)
  66
  67 /* Common sgl flags for WRITING a config page. */
  68 #define MPT3_CONFIG_COMMON_WRITE_SGLFLAGS ((MPI2_SGE_FLAGS_SIMPLE_ELEMENT | \
  69         MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER \
  70         | MPI2_SGE_FLAGS_END_OF_LIST | MPI2_SGE_FLAGS_HOST_TO_IOC) \
  71         << MPI2_SGE_FLAGS_SHIFT)
  72
  73 /**
  74  * struct config_request - obtain dma memory via routine
  75  * @sz: size
  76  * @page: virt pointer
  77  * @page_dma: phys pointer
  78  *
  79  */
  80 struct config_request {
  81         u16                     sz;
  82         void                    *page;
  83         dma_addr_t              page_dma;
  84 };
  85
  86 /**
  87  * _config_display_some_debug - debug routine
  88  * @ioc: per adapter object
  89  * @smid: system request message index
  90  * @calling_function_name: string pass from calling function
  91  * @mpi_reply: reply message frame
  92  * Context: none.
  93  *
  94  * Function for displaying debug info helpful when debugging issues
  95  * in this module.
  96  */
  97 static void
  98 _config_display_some_debug(struct MPT3SAS_ADAPTER *ioc, u16 smid,
  99         char *calling_function_name, MPI2DefaultReply_t *mpi_reply)
 100 {
 101         Mpi2ConfigRequest_t *mpi_request;
 102         char *desc = NULL;
 103
 104         if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
 105                 return;
 106
 107         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 108         switch (mpi_request->Header.PageType & MPI2_CONFIG_PAGETYPE_MASK) {
 109         case MPI2_CONFIG_PAGETYPE_IO_UNIT:
 110                 desc = "io_unit";
 111                 break;
 112         case MPI2_CONFIG_PAGETYPE_IOC:
 113                 desc = "ioc";
 114                 break;
 115         case MPI2_CONFIG_PAGETYPE_BIOS:
 116                 desc = "bios";
 117                 break;
 118         case MPI2_CONFIG_PAGETYPE_RAID_VOLUME:
 119                 desc = "raid_volume";
 120                 break;
 121         case MPI2_CONFIG_PAGETYPE_MANUFACTURING:
 122                 desc = "manufaucturing";
 123                 break;
 124         case MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK:
 125                 desc = "physdisk";
 126                 break;
 127         case MPI2_CONFIG_PAGETYPE_EXTENDED:
 128                 switch (mpi_request->ExtPageType) {
 129                 case MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT:
 130                         desc = "sas_io_unit";
 131                         break;
 132                 case MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER:
 133                         desc = "sas_expander";
 134                         break;
 135                 case MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE:
 136                         desc = "sas_device";
 137                         break;
 138                 case MPI2_CONFIG_EXTPAGETYPE_SAS_PHY:
 139                         desc = "sas_phy";
 140                         break;
 141                 case MPI2_CONFIG_EXTPAGETYPE_LOG:
 142                         desc = "log";
 143                         break;
 144                 case MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE:
 145                         desc = "enclosure";
 146                         break;
 147                 case MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG:
 148                         desc = "raid_config";
 149                         break;
 150                 case MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING:
 151                         desc = "driver_mapping";
 152                         break;
 153                 }
 154                 break;
 155         }
 156
 157         if (!desc)
 158                 return;
 159
 160         pr_info(MPT3SAS_FMT
 161                 "%s: %s(%d), action(%d), form(0x%08x), smid(%d)\n",
 162                 ioc->name, calling_function_name, desc,
 163             mpi_request->Header.PageNumber, mpi_request->Action,
 164             le32_to_cpu(mpi_request->PageAddress), smid);
 165
 166         if (!mpi_reply)
 167                 return;
 168
 169         if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
 170                 pr_info(MPT3SAS_FMT
 171                     "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
 172                     ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
 173                     le32_to_cpu(mpi_reply->IOCLogInfo));
 174 }
 175
 176 /**
 177  * _config_alloc_config_dma_memory - obtain physical memory
 178  * @ioc: per adapter object
 179  * @mem: struct config_request
 180  *
 181  * A wrapper for obtaining dma-able memory for config page request.
 182  *
 183  * Returns 0 for success, non-zero for failure.
 184  */
 185 static int
 186 _config_alloc_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
 187         struct config_request *mem)
 188 {
 189         int r = 0;
 190
 191         if (mem->sz > ioc->config_page_sz) {
 192                 mem->page = dma_alloc_coherent(&ioc->pdev->dev, mem->sz,
 193                     &mem->page_dma, GFP_KERNEL);
 194                 if (!mem->page) {
 195                         pr_err(MPT3SAS_FMT
 196                                 "%s: dma_alloc_coherent failed asking for (%d) bytes!!\n",
 197                             ioc->name, __func__, mem->sz);
 198                         r = -ENOMEM;
 199                 }
 200         } else { /* use tmp buffer if less than 512 bytes */
 201                 mem->page = ioc->config_page;
 202                 mem->page_dma = ioc->config_page_dma;
 203         }
 204         return r;
 205 }
 206
 207 /**
 208  * _config_free_config_dma_memory - wrapper to free the memory
 209  * @ioc: per adapter object
 210  * @mem: struct config_request
 211  *
 212  * A wrapper to free dma-able memory when using _config_alloc_config_dma_memory.
 213  *
 214  * Returns 0 for success, non-zero for failure.
 215  */
 216 static void
 217 _config_free_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
 218         struct config_request *mem)
 219 {
 220         if (mem->sz > ioc->config_page_sz)
 221                 dma_free_coherent(&ioc->pdev->dev, mem->sz, mem->page,
 222                     mem->page_dma);
 223 }
 224
 225 /**
 226  * mpt3sas_config_done - config page completion routine
 227  * @ioc: per adapter object
 228  * @smid: system request message index
 229  * @msix_index: MSIX table index supplied by the OS
 230  * @reply: reply message frame(lower 32bit addr)
 231  * Context: none.
 232  *
 233  * The callback handler when using _config_request.
 234  *
 235  * Return 1 meaning mf should be freed from _base_interrupt
 236  *        0 means the mf is freed from this function.
 237  */
 238 u8
 239 mpt3sas_config_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
 240         u32 reply)
 241 {
 242         MPI2DefaultReply_t *mpi_reply;
 243
 244         if (ioc->config_cmds.status == MPT3_CMD_NOT_USED)
 245                 return 1;
 246         if (ioc->config_cmds.smid != smid)
 247                 return 1;
 248         ioc->config_cmds.status |= MPT3_CMD_COMPLETE;
 249         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
 250         if (mpi_reply) {
 251                 ioc->config_cmds.status |= MPT3_CMD_REPLY_VALID;
 252                 memcpy(ioc->config_cmds.reply, mpi_reply,
 253                     mpi_reply->MsgLength*4);
 254         }
 255         ioc->config_cmds.status &= ~MPT3_CMD_PENDING;
 256         _config_display_some_debug(ioc, smid, "config_done", mpi_reply);
 257         ioc->config_cmds.smid = USHRT_MAX;
 258         complete(&ioc->config_cmds.done);
 259         return 1;
 260 }
 261
 262 /**
 263  * _config_request - main routine for sending config page requests
 264  * @ioc: per adapter object
 265  * @mpi_request: request message frame
 266  * @mpi_reply: reply mf payload returned from firmware
 267  * @timeout: timeout in seconds
 268  * @config_page: contents of the config page
 269  * @config_page_sz: size of config page
 270  * Context: sleep
 271  *
 272  * A generic API for config page requests to firmware.
 273  *
 274  * The ioc->config_cmds.status flag should be MPT3_CMD_NOT_USED before calling
 275  * this API.
 276  *
 277  * The callback index is set inside `ioc->config_cb_idx.
 278  *
 279  * Returns 0 for success, non-zero for failure.
 280  */
 281 static int
 282 _config_request(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigRequest_t
 283         *mpi_request, Mpi2ConfigReply_t *mpi_reply, int timeout,
 284         void *config_page, u16 config_page_sz)
 285 {
 286         u16 smid;
 287         u32 ioc_state;
 288         Mpi2ConfigRequest_t *config_request;
 289         int r;
 290         u8 retry_count, issue_host_reset = 0;
 291         u16 wait_state_count;
 292         struct config_request mem;
 293         u32 ioc_status = UINT_MAX;
 294
 295         mutex_lock(&ioc->config_cmds.mutex);
 296         if (ioc->config_cmds.status != MPT3_CMD_NOT_USED) {
 297                 pr_err(MPT3SAS_FMT "%s: config_cmd in use\n",
 298                     ioc->name, __func__);
 299                 mutex_unlock(&ioc->config_cmds.mutex);
 300                 return -EAGAIN;
 301         }
 302
 303         retry_count = 0;
 304         memset(&mem, 0, sizeof(struct config_request));
 305
 306         mpi_request->VF_ID = 0; /* TODO */
 307         mpi_request->VP_ID = 0;
 308
 309         if (config_page) {
 310                 mpi_request->Header.PageVersion = mpi_reply->Header.PageVersion;
 311                 mpi_request->Header.PageNumber = mpi_reply->Header.PageNumber;
 312                 mpi_request->Header.PageType = mpi_reply->Header.PageType;
 313                 mpi_request->Header.PageLength = mpi_reply->Header.PageLength;
 314                 mpi_request->ExtPageLength = mpi_reply->ExtPageLength;
 315                 mpi_request->ExtPageType = mpi_reply->ExtPageType;
 316                 if (mpi_request->Header.PageLength)
 317                         mem.sz = mpi_request->Header.PageLength * 4;
 318                 else
 319                         mem.sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
 320                 r = _config_alloc_config_dma_memory(ioc, &mem);
 321                 if (r != 0)
 322                         goto out;
 323                 if (mpi_request->Action ==
 324                     MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
 325                     mpi_request->Action ==
 326                     MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
 327                         ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
 328                             MPT3_CONFIG_COMMON_WRITE_SGLFLAGS | mem.sz,
 329                             mem.page_dma);
 330                         memcpy(mem.page, config_page, min_t(u16, mem.sz,
 331                             config_page_sz));
 332                 } else {
 333                         memset(config_page, 0, config_page_sz);
 334                         ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
 335                             MPT3_CONFIG_COMMON_SGLFLAGS | mem.sz, mem.page_dma);
 336                         memset(mem.page, 0, min_t(u16, mem.sz, config_page_sz));
 337                 }
 338         }
 339
 340  retry_config:
 341         if (retry_count) {
 342                 if (retry_count > 2) { /* attempt only 2 retries */
 343                         r = -EFAULT;
 344                         goto free_mem;
 345                 }
 346                 pr_info(MPT3SAS_FMT "%s: attempting retry (%d)\n",
 347                     ioc->name, __func__, retry_count);
 348         }
 349         wait_state_count = 0;
 350         ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 351         while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
 352                 if (wait_state_count++ == MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT) {
 353                         pr_err(MPT3SAS_FMT
 354                             "%s: failed due to ioc not operational\n",
 355                             ioc->name, __func__);
 356                         ioc->config_cmds.status = MPT3_CMD_NOT_USED;
 357                         r = -EFAULT;
 358                         goto free_mem;
 359                 }
 360                 ssleep(1);
 361                 ioc_state = mpt3sas_base_get_iocstate(ioc, 1);
 362                 pr_info(MPT3SAS_FMT
 363                         "%s: waiting for operational state(count=%d)\n",
 364                         ioc->name, __func__, wait_state_count);
 365         }
 366         if (wait_state_count)
 367                 pr_info(MPT3SAS_FMT "%s: ioc is operational\n",
 368                     ioc->name, __func__);
 369
 370         smid = mpt3sas_base_get_smid(ioc, ioc->config_cb_idx);
 371         if (!smid) {
 372                 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n",
 373                     ioc->name, __func__);
 374                 ioc->config_cmds.status = MPT3_CMD_NOT_USED;
 375                 r = -EAGAIN;
 376                 goto free_mem;
 377         }
 378
 379         r = 0;
 380         memset(mpi_reply, 0, sizeof(Mpi2ConfigReply_t));
 381         ioc->config_cmds.status = MPT3_CMD_PENDING;
 382         config_request = mpt3sas_base_get_msg_frame(ioc, smid);
 383         ioc->config_cmds.smid = smid;
 384         memcpy(config_request, mpi_request, sizeof(Mpi2ConfigRequest_t));
 385         _config_display_some_debug(ioc, smid, "config_request", NULL);
 386         init_completion(&ioc->config_cmds.done);
 387         mpt3sas_base_put_smid_default(ioc, smid);
 388         wait_for_completion_timeout(&ioc->config_cmds.done, timeout*HZ);
 389         if (!(ioc->config_cmds.status & MPT3_CMD_COMPLETE)) {
 390                 pr_err(MPT3SAS_FMT "%s: timeout\n",
 391                     ioc->name, __func__);
 392                 _debug_dump_mf(mpi_request,
 393                     sizeof(Mpi2ConfigRequest_t)/4);
 394                 retry_count++;
 395                 if (ioc->config_cmds.smid == smid)
 396                         mpt3sas_base_free_smid(ioc, smid);
 397                 if ((ioc->shost_recovery) || (ioc->config_cmds.status &
 398                     MPT3_CMD_RESET) || ioc->pci_error_recovery)
 399                         goto retry_config;
 400                 issue_host_reset = 1;
 401                 r = -EFAULT;
 402                 goto free_mem;
 403         }
 404
 405         if (ioc->config_cmds.status & MPT3_CMD_REPLY_VALID) {
 406                 memcpy(mpi_reply, ioc->config_cmds.reply,
 407                     sizeof(Mpi2ConfigReply_t));
 408
 409                 /* Reply Frame Sanity Checks to workaround FW issues */
 410                 if ((mpi_request->Header.PageType & 0xF) !=
 411                     (mpi_reply->Header.PageType & 0xF)) {
 412                         _debug_dump_mf(mpi_request, ioc->request_sz/4);
 413                         _debug_dump_reply(mpi_reply, ioc->request_sz/4);
 414                         panic(KERN_WARNING MPT3SAS_FMT "%s: Firmware BUG:" \
 415                             " mpi_reply mismatch: Requested PageType(0x%02x)" \
 416                             " Reply PageType(0x%02x)\n", \
 417                             ioc->name, __func__,
 418                             (mpi_request->Header.PageType & 0xF),
 419                             (mpi_reply->Header.PageType & 0xF));
 420                 }
 421
 422                 if (((mpi_request->Header.PageType & 0xF) ==
 423                     MPI2_CONFIG_PAGETYPE_EXTENDED) &&
 424                     mpi_request->ExtPageType != mpi_reply->ExtPageType) {
 425                         _debug_dump_mf(mpi_request, ioc->request_sz/4);
 426                         _debug_dump_reply(mpi_reply, ioc->request_sz/4);
 427                         panic(KERN_WARNING MPT3SAS_FMT "%s: Firmware BUG:" \
 428                             " mpi_reply mismatch: Requested ExtPageType(0x%02x)"
 429                             " Reply ExtPageType(0x%02x)\n",
 430                             ioc->name, __func__, mpi_request->ExtPageType,
 431                             mpi_reply->ExtPageType);
 432                 }
 433                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
 434                     & MPI2_IOCSTATUS_MASK;
 435         }
 436
 437         if (retry_count)
 438                 pr_info(MPT3SAS_FMT "%s: retry (%d) completed!!\n", \
 439                     ioc->name, __func__, retry_count);
 440
 441         if ((ioc_status == MPI2_IOCSTATUS_SUCCESS) &&
 442             config_page && mpi_request->Action ==
 443             MPI2_CONFIG_ACTION_PAGE_READ_CURRENT) {
 444                 u8 *p = (u8 *)mem.page;
 445
 446                 /* Config Page Sanity Checks to workaround FW issues */
 447                 if (p) {
 448                         if ((mpi_request->Header.PageType & 0xF) !=
 449                             (p[3] & 0xF)) {
 450                                 _debug_dump_mf(mpi_request, ioc->request_sz/4);
 451                                 _debug_dump_reply(mpi_reply, ioc->request_sz/4);
 452                                 _debug_dump_config(p, min_t(u16, mem.sz,
 453                                     config_page_sz)/4);
 454                                 panic(KERN_WARNING MPT3SAS_FMT
 455                                         "%s: Firmware BUG:" \
 456                                     " config page mismatch:"
 457                                     " Requested PageType(0x%02x)"
 458                                     " Reply PageType(0x%02x)\n",
 459                                     ioc->name, __func__,
 460                                     (mpi_request->Header.PageType & 0xF),
 461                                     (p[3] & 0xF));
 462                         }
 463
 464                         if (((mpi_request->Header.PageType & 0xF) ==
 465                             MPI2_CONFIG_PAGETYPE_EXTENDED) &&
 466                             (mpi_request->ExtPageType != p[6])) {
 467                                 _debug_dump_mf(mpi_request, ioc->request_sz/4);
 468                                 _debug_dump_reply(mpi_reply, ioc->request_sz/4);
 469                                 _debug_dump_config(p, min_t(u16, mem.sz,
 470                                     config_page_sz)/4);
 471                                 panic(KERN_WARNING MPT3SAS_FMT
 472                                         "%s: Firmware BUG:" \
 473                                     " config page mismatch:"
 474                                     " Requested ExtPageType(0x%02x)"
 475                                     " Reply ExtPageType(0x%02x)\n",
 476                                     ioc->name, __func__,
 477                                     mpi_request->ExtPageType, p[6]);
 478                         }
 479                 }
 480                 memcpy(config_page, mem.page, min_t(u16, mem.sz,
 481                     config_page_sz));
 482         }
 483
 484  free_mem:
 485         if (config_page)
 486                 _config_free_config_dma_memory(ioc, &mem);
 487  out:
 488         ioc->config_cmds.status = MPT3_CMD_NOT_USED;
 489         mutex_unlock(&ioc->config_cmds.mutex);
 490
 491         if (issue_host_reset)
 492                 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
 493         return r;
 494 }
 495
 496 /**
 497  * mpt3sas_config_get_manufacturing_pg0 - obtain manufacturing page 0
 498  * @ioc: per adapter object
 499  * @mpi_reply: reply mf payload returned from firmware
 500  * @config_page: contents of the config page
 501  * Context: sleep.
 502  *
 503  * Returns 0 for success, non-zero for failure.
 504  */
 505 int
 506 mpt3sas_config_get_manufacturing_pg0(struct MPT3SAS_ADAPTER *ioc,
 507         Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage0_t *config_page)
 508 {
 509         Mpi2ConfigRequest_t mpi_request;
 510         int r;
 511
 512         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 513         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 514         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 515         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 516         mpi_request.Header.PageNumber = 0;
 517         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 518         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 519         r = _config_request(ioc, &mpi_request, mpi_reply,
 520             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 521         if (r)
 522                 goto out;
 523
 524         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 525         r = _config_request(ioc, &mpi_request, mpi_reply,
 526             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 527             sizeof(*config_page));
 528  out:
 529         return r;
 530 }
 531
 532 /**
 533  * mpt3sas_config_get_manufacturing_pg7 - obtain manufacturing page 7
 534  * @ioc: per adapter object
 535  * @mpi_reply: reply mf payload returned from firmware
 536  * @config_page: contents of the config page
 537  * @sz: size of buffer passed in config_page
 538  * Context: sleep.
 539  *
 540  * Returns 0 for success, non-zero for failure.
 541  */
 542 int
 543 mpt3sas_config_get_manufacturing_pg7(struct MPT3SAS_ADAPTER *ioc,
 544         Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage7_t *config_page,
 545         u16 sz)
 546 {
 547         Mpi2ConfigRequest_t mpi_request;
 548         int r;
 549
 550         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 551         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 552         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 553         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 554         mpi_request.Header.PageNumber = 7;
 555         mpi_request.Header.PageVersion = MPI2_MANUFACTURING7_PAGEVERSION;
 556         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 557         r = _config_request(ioc, &mpi_request, mpi_reply,
 558             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 559         if (r)
 560                 goto out;
 561
 562         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 563         r = _config_request(ioc, &mpi_request, mpi_reply,
 564             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 565             sz);
 566  out:
 567         return r;
 568 }
 569
 570 /**
 571  * mpt3sas_config_get_manufacturing_pg10 - obtain manufacturing page 10
 572  * @ioc: per adapter object
 573  * @mpi_reply: reply mf payload returned from firmware
 574  * @config_page: contents of the config page
 575  * Context: sleep.
 576  *
 577  * Returns 0 for success, non-zero for failure.
 578  */
 579 int
 580 mpt3sas_config_get_manufacturing_pg10(struct MPT3SAS_ADAPTER *ioc,
 581         Mpi2ConfigReply_t *mpi_reply,
 582         struct Mpi2ManufacturingPage10_t *config_page)
 583 {
 584         Mpi2ConfigRequest_t mpi_request;
 585         int r;
 586
 587         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 588         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 589         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 590         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 591         mpi_request.Header.PageNumber = 10;
 592         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 593         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 594         r = _config_request(ioc, &mpi_request, mpi_reply,
 595             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 596         if (r)
 597                 goto out;
 598
 599         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 600         r = _config_request(ioc, &mpi_request, mpi_reply,
 601             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 602             sizeof(*config_page));
 603  out:
 604         return r;
 605 }
 606
 607 /**
 608  * mpt3sas_config_get_manufacturing_pg11 - obtain manufacturing page 11
 609  * @ioc: per adapter object
 610  * @mpi_reply: reply mf payload returned from firmware
 611  * @config_page: contents of the config page
 612  * Context: sleep.
 613  *
 614  * Returns 0 for success, non-zero for failure.
 615  */
 616 int
 617 mpt3sas_config_get_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
 618         Mpi2ConfigReply_t *mpi_reply,
 619         struct Mpi2ManufacturingPage11_t *config_page)
 620 {
 621         Mpi2ConfigRequest_t mpi_request;
 622         int r;
 623
 624         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 625         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 626         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 627         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 628         mpi_request.Header.PageNumber = 11;
 629         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 630         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 631         r = _config_request(ioc, &mpi_request, mpi_reply,
 632             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 633         if (r)
 634                 goto out;
 635
 636         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 637         r = _config_request(ioc, &mpi_request, mpi_reply,
 638             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 639             sizeof(*config_page));
 640  out:
 641         return r;
 642 }
 643
 644 /**
 645  * mpt3sas_config_set_manufacturing_pg11 - set manufacturing page 11
 646  * @ioc: per adapter object
 647  * @mpi_reply: reply mf payload returned from firmware
 648  * @config_page: contents of the config page
 649  * Context: sleep.
 650  *
 651  * Returns 0 for success, non-zero for failure.
 652  */
 653 int
 654 mpt3sas_config_set_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
 655         Mpi2ConfigReply_t *mpi_reply,
 656         struct Mpi2ManufacturingPage11_t *config_page)
 657 {
 658         Mpi2ConfigRequest_t mpi_request;
 659         int r;
 660
 661         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 662         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 663         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 664         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 665         mpi_request.Header.PageNumber = 11;
 666         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 667         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 668         r = _config_request(ioc, &mpi_request, mpi_reply,
 669             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 670         if (r)
 671                 goto out;
 672
 673         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 674         r = _config_request(ioc, &mpi_request, mpi_reply,
 675             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 676             sizeof(*config_page));
 677  out:
 678         return r;
 679 }
 680
 681 /**
 682  * mpt3sas_config_get_bios_pg2 - obtain bios page 2
 683  * @ioc: per adapter object
 684  * @mpi_reply: reply mf payload returned from firmware
 685  * @config_page: contents of the config page
 686  * Context: sleep.
 687  *
 688  * Returns 0 for success, non-zero for failure.
 689  */
 690 int
 691 mpt3sas_config_get_bios_pg2(struct MPT3SAS_ADAPTER *ioc,
 692         Mpi2ConfigReply_t *mpi_reply, Mpi2BiosPage2_t *config_page)
 693 {
 694         Mpi2ConfigRequest_t mpi_request;
 695         int r;
 696
 697         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 698         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 699         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 700         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
 701         mpi_request.Header.PageNumber = 2;
 702         mpi_request.Header.PageVersion = MPI2_BIOSPAGE2_PAGEVERSION;
 703         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 704         r = _config_request(ioc, &mpi_request, mpi_reply,
 705             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 706         if (r)
 707                 goto out;
 708
 709         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 710         r = _config_request(ioc, &mpi_request, mpi_reply,
 711             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 712             sizeof(*config_page));
 713  out:
 714         return r;
 715 }
 716
 717 /**
 718  * mpt3sas_config_get_bios_pg3 - obtain bios page 3
 719  * @ioc: per adapter object
 720  * @mpi_reply: reply mf payload returned from firmware
 721  * @config_page: contents of the config page
 722  * Context: sleep.
 723  *
 724  * Returns 0 for success, non-zero for failure.
 725  */
 726 int
 727 mpt3sas_config_get_bios_pg3(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
 728         *mpi_reply, Mpi2BiosPage3_t *config_page)
 729 {
 730         Mpi2ConfigRequest_t mpi_request;
 731         int r;
 732
 733         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 734         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 735         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 736         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
 737         mpi_request.Header.PageNumber = 3;
 738         mpi_request.Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION;
 739         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 740         r = _config_request(ioc, &mpi_request, mpi_reply,
 741             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 742         if (r)
 743                 goto out;
 744
 745         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 746         r = _config_request(ioc, &mpi_request, mpi_reply,
 747             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 748             sizeof(*config_page));
 749  out:
 750         return r;
 751 }
 752
 753 /**
 754  * mpt3sas_config_get_iounit_pg0 - obtain iounit page 0
 755  * @ioc: per adapter object
 756  * @mpi_reply: reply mf payload returned from firmware
 757  * @config_page: contents of the config page
 758  * Context: sleep.
 759  *
 760  * Returns 0 for success, non-zero for failure.
 761  */
 762 int
 763 mpt3sas_config_get_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
 764         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage0_t *config_page)
 765 {
 766         Mpi2ConfigRequest_t mpi_request;
 767         int r;
 768
 769         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 770         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 771         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 772         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 773         mpi_request.Header.PageNumber = 0;
 774         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE0_PAGEVERSION;
 775         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 776         r = _config_request(ioc, &mpi_request, mpi_reply,
 777             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 778         if (r)
 779                 goto out;
 780
 781         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 782         r = _config_request(ioc, &mpi_request, mpi_reply,
 783             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 784             sizeof(*config_page));
 785  out:
 786         return r;
 787 }
 788
 789 /**
 790  * mpt3sas_config_get_iounit_pg1 - obtain iounit page 1
 791  * @ioc: per adapter object
 792  * @mpi_reply: reply mf payload returned from firmware
 793  * @config_page: contents of the config page
 794  * Context: sleep.
 795  *
 796  * Returns 0 for success, non-zero for failure.
 797  */
 798 int
 799 mpt3sas_config_get_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
 800         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
 801 {
 802         Mpi2ConfigRequest_t mpi_request;
 803         int r;
 804
 805         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 806         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 807         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 808         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 809         mpi_request.Header.PageNumber = 1;
 810         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
 811         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 812         r = _config_request(ioc, &mpi_request, mpi_reply,
 813             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 814         if (r)
 815                 goto out;
 816
 817         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 818         r = _config_request(ioc, &mpi_request, mpi_reply,
 819             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 820             sizeof(*config_page));
 821  out:
 822         return r;
 823 }
 824
 825 /**
 826  * mpt3sas_config_set_iounit_pg1 - set iounit page 1
 827  * @ioc: per adapter object
 828  * @mpi_reply: reply mf payload returned from firmware
 829  * @config_page: contents of the config page
 830  * Context: sleep.
 831  *
 832  * Returns 0 for success, non-zero for failure.
 833  */
 834 int
 835 mpt3sas_config_set_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
 836         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
 837 {
 838         Mpi2ConfigRequest_t mpi_request;
 839         int r;
 840
 841         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 842         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 843         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 844         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 845         mpi_request.Header.PageNumber = 1;
 846         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
 847         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 848         r = _config_request(ioc, &mpi_request, mpi_reply,
 849             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 850         if (r)
 851                 goto out;
 852
 853         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 854         r = _config_request(ioc, &mpi_request, mpi_reply,
 855             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 856             sizeof(*config_page));
 857  out:
 858         return r;
 859 }
 860
 861 /**
 862  * mpt3sas_config_get_iounit_pg3 - obtain iounit page 3
 863  * @ioc: per adapter object
 864  * @mpi_reply: reply mf payload returned from firmware
 865  * @config_page: contents of the config page
 866  * @sz: size of buffer passed in config_page
 867  * Context: sleep.
 868  *
 869  * Returns 0 for success, non-zero for failure.
 870  */
 871 int
 872 mpt3sas_config_get_iounit_pg3(struct MPT3SAS_ADAPTER *ioc,
 873         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage3_t *config_page, u16 sz)
 874 {
 875         Mpi2ConfigRequest_t mpi_request;
 876         int r;
 877
 878         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 879         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 880         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 881         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 882         mpi_request.Header.PageNumber = 3;
 883         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE3_PAGEVERSION;
 884         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 885         r = _config_request(ioc, &mpi_request, mpi_reply,
 886             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 887         if (r)
 888                 goto out;
 889
 890         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 891         r = _config_request(ioc, &mpi_request, mpi_reply,
 892             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
 893  out:
 894         return r;
 895 }
 896
 897 /**
 898  * mpt3sas_config_get_iounit_pg8 - obtain iounit page 8
 899  * @ioc: per adapter object
 900  * @mpi_reply: reply mf payload returned from firmware
 901  * @config_page: contents of the config page
 902  * Context: sleep.
 903  *
 904  * Returns 0 for success, non-zero for failure.
 905  */
 906 int
 907 mpt3sas_config_get_iounit_pg8(struct MPT3SAS_ADAPTER *ioc,
 908         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage8_t *config_page)
 909 {
 910         Mpi2ConfigRequest_t mpi_request;
 911         int r;
 912
 913         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 914         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 915         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 916         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 917         mpi_request.Header.PageNumber = 8;
 918         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE8_PAGEVERSION;
 919         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 920         r = _config_request(ioc, &mpi_request, mpi_reply,
 921             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 922         if (r)
 923                 goto out;
 924
 925         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 926         r = _config_request(ioc, &mpi_request, mpi_reply,
 927             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 928             sizeof(*config_page));
 929  out:
 930         return r;
 931 }
 932
 933 /**
 934  * mpt3sas_config_get_ioc_pg8 - obtain ioc page 8
 935  * @ioc: per adapter object
 936  * @mpi_reply: reply mf payload returned from firmware
 937  * @config_page: contents of the config page
 938  * Context: sleep.
 939  *
 940  * Returns 0 for success, non-zero for failure.
 941  */
 942 int
 943 mpt3sas_config_get_ioc_pg8(struct MPT3SAS_ADAPTER *ioc,
 944         Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage8_t *config_page)
 945 {
 946         Mpi2ConfigRequest_t mpi_request;
 947         int r;
 948
 949         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 950         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 951         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 952         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
 953         mpi_request.Header.PageNumber = 8;
 954         mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
 955         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 956         r = _config_request(ioc, &mpi_request, mpi_reply,
 957             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 958         if (r)
 959                 goto out;
 960
 961         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 962         r = _config_request(ioc, &mpi_request, mpi_reply,
 963             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 964             sizeof(*config_page));
 965  out:
 966         return r;
 967 }
 968
 969 /**
 970  * mpt3sas_config_get_sas_device_pg0 - obtain sas device page 0
 971  * @ioc: per adapter object
 972  * @mpi_reply: reply mf payload returned from firmware
 973  * @config_page: contents of the config page
 974  * @form: GET_NEXT_HANDLE or HANDLE
 975  * @handle: device handle
 976  * Context: sleep.
 977  *
 978  * Returns 0 for success, non-zero for failure.
 979  */
 980 int
 981 mpt3sas_config_get_sas_device_pg0(struct MPT3SAS_ADAPTER *ioc,
 982         Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage0_t *config_page,
 983         u32 form, u32 handle)
 984 {
 985         Mpi2ConfigRequest_t mpi_request;
 986         int r;
 987
 988         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 989         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 990         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 991         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 992         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
 993         mpi_request.Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION;
 994         mpi_request.Header.PageNumber = 0;
 995         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 996         r = _config_request(ioc, &mpi_request, mpi_reply,
 997             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 998         if (r)
 999                 goto out;
1000
1001         mpi_request.PageAddress = cpu_to_le32(form | handle);
1002         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1003         r = _config_request(ioc, &mpi_request, mpi_reply,
1004             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1005             sizeof(*config_page));
1006  out:
1007         return r;
1008 }
1009
1010 /**
1011  * mpt3sas_config_get_sas_device_pg1 - obtain sas device page 1
1012  * @ioc: per adapter object
1013  * @mpi_reply: reply mf payload returned from firmware
1014  * @config_page: contents of the config page
1015  * @form: GET_NEXT_HANDLE or HANDLE
1016  * @handle: device handle
1017  * Context: sleep.
1018  *
1019  * Returns 0 for success, non-zero for failure.
1020  */
1021 int
1022 mpt3sas_config_get_sas_device_pg1(struct MPT3SAS_ADAPTER *ioc,
1023         Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage1_t *config_page,
1024         u32 form, u32 handle)
1025 {
1026         Mpi2ConfigRequest_t mpi_request;
1027         int r;
1028
1029         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1030         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1031         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1032         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1033         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1034         mpi_request.Header.PageVersion = MPI2_SASDEVICE1_PAGEVERSION;
1035         mpi_request.Header.PageNumber = 1;
1036         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1037         r = _config_request(ioc, &mpi_request, mpi_reply,
1038             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1039         if (r)
1040                 goto out;
1041
1042         mpi_request.PageAddress = cpu_to_le32(form | handle);
1043         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1044         r = _config_request(ioc, &mpi_request, mpi_reply,
1045             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1046             sizeof(*config_page));
1047  out:
1048         return r;
1049 }
1050
1051 /**
1052  * mpt3sas_config_get_number_hba_phys - obtain number of phys on the host
1053  * @ioc: per adapter object
1054  * @num_phys: pointer returned with the number of phys
1055  * Context: sleep.
1056  *
1057  * Returns 0 for success, non-zero for failure.
1058  */
1059 int
1060 mpt3sas_config_get_number_hba_phys(struct MPT3SAS_ADAPTER *ioc, u8 *num_phys)
1061 {
1062         Mpi2ConfigRequest_t mpi_request;
1063         int r;
1064         u16 ioc_status;
1065         Mpi2ConfigReply_t mpi_reply;
1066         Mpi2SasIOUnitPage0_t config_page;
1067
1068         *num_phys = 0;
1069         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1070         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1071         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1072         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1073         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1074         mpi_request.Header.PageNumber = 0;
1075         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1076         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1077         r = _config_request(ioc, &mpi_request, &mpi_reply,
1078             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1079         if (r)
1080                 goto out;
1081
1082         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1083         r = _config_request(ioc, &mpi_request, &mpi_reply,
1084             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1085             sizeof(Mpi2SasIOUnitPage0_t));
1086         if (!r) {
1087                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1088                     MPI2_IOCSTATUS_MASK;
1089                 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1090                         *num_phys = config_page.NumPhys;
1091         }
1092  out:
1093         return r;
1094 }
1095
1096 /**
1097  * mpt3sas_config_get_sas_iounit_pg0 - obtain sas iounit page 0
1098  * @ioc: per adapter object
1099  * @mpi_reply: reply mf payload returned from firmware
1100  * @config_page: contents of the config page
1101  * @sz: size of buffer passed in config_page
1102  * Context: sleep.
1103  *
1104  * Calling function should call config_get_number_hba_phys prior to
1105  * this function, so enough memory is allocated for config_page.
1106  *
1107  * Returns 0 for success, non-zero for failure.
1108  */
1109 int
1110 mpt3sas_config_get_sas_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
1111         Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage0_t *config_page,
1112         u16 sz)
1113 {
1114         Mpi2ConfigRequest_t mpi_request;
1115         int r;
1116
1117         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1118         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1119         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1120         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1121         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1122         mpi_request.Header.PageNumber = 0;
1123         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1124         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1125         r = _config_request(ioc, &mpi_request, mpi_reply,
1126             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1127         if (r)
1128                 goto out;
1129
1130         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1131         r = _config_request(ioc, &mpi_request, mpi_reply,
1132             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1133  out:
1134         return r;
1135 }
1136
1137 /**
1138  * mpt3sas_config_get_sas_iounit_pg1 - obtain sas iounit page 1
1139  * @ioc: per adapter object
1140  * @mpi_reply: reply mf payload returned from firmware
1141  * @config_page: contents of the config page
1142  * @sz: size of buffer passed in config_page
1143  * Context: sleep.
1144  *
1145  * Calling function should call config_get_number_hba_phys prior to
1146  * this function, so enough memory is allocated for config_page.
1147  *
1148  * Returns 0 for success, non-zero for failure.
1149  */
1150 int
1151 mpt3sas_config_get_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1152         Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1153         u16 sz)
1154 {
1155         Mpi2ConfigRequest_t mpi_request;
1156         int r;
1157
1158         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1159         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1160         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1161         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1162         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1163         mpi_request.Header.PageNumber = 1;
1164         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1165         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1166         r = _config_request(ioc, &mpi_request, mpi_reply,
1167             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1168         if (r)
1169                 goto out;
1170
1171         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1172         r = _config_request(ioc, &mpi_request, mpi_reply,
1173             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1174  out:
1175         return r;
1176 }
1177
1178 /**
1179  * mpt3sas_config_set_sas_iounit_pg1 - send sas iounit page 1
1180  * @ioc: per adapter object
1181  * @mpi_reply: reply mf payload returned from firmware
1182  * @config_page: contents of the config page
1183  * @sz: size of buffer passed in config_page
1184  * Context: sleep.
1185  *
1186  * Calling function should call config_get_number_hba_phys prior to
1187  * this function, so enough memory is allocated for config_page.
1188  *
1189  * Returns 0 for success, non-zero for failure.
1190  */
1191 int
1192 mpt3sas_config_set_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1193         Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1194         u16 sz)
1195 {
1196         Mpi2ConfigRequest_t mpi_request;
1197         int r;
1198
1199         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1200         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1201         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1202         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1203         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1204         mpi_request.Header.PageNumber = 1;
1205         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1206         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1207         r = _config_request(ioc, &mpi_request, mpi_reply,
1208             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1209         if (r)
1210                 goto out;
1211
1212         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
1213         _config_request(ioc, &mpi_request, mpi_reply,
1214             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1215         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
1216         r = _config_request(ioc, &mpi_request, mpi_reply,
1217             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1218  out:
1219         return r;
1220 }
1221
1222 /**
1223  * mpt3sas_config_get_expander_pg0 - obtain expander page 0
1224  * @ioc: per adapter object
1225  * @mpi_reply: reply mf payload returned from firmware
1226  * @config_page: contents of the config page
1227  * @form: GET_NEXT_HANDLE or HANDLE
1228  * @handle: expander handle
1229  * Context: sleep.
1230  *
1231  * Returns 0 for success, non-zero for failure.
1232  */
1233 int
1234 mpt3sas_config_get_expander_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1235         *mpi_reply, Mpi2ExpanderPage0_t *config_page, u32 form, u32 handle)
1236 {
1237         Mpi2ConfigRequest_t mpi_request;
1238         int r;
1239
1240         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1241         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1242         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1243         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1244         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1245         mpi_request.Header.PageNumber = 0;
1246         mpi_request.Header.PageVersion = MPI2_SASEXPANDER0_PAGEVERSION;
1247         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1248         r = _config_request(ioc, &mpi_request, mpi_reply,
1249             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1250         if (r)
1251                 goto out;
1252
1253         mpi_request.PageAddress = cpu_to_le32(form | handle);
1254         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1255         r = _config_request(ioc, &mpi_request, mpi_reply,
1256             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1257             sizeof(*config_page));
1258  out:
1259         return r;
1260 }
1261
1262 /**
1263  * mpt3sas_config_get_expander_pg1 - obtain expander page 1
1264  * @ioc: per adapter object
1265  * @mpi_reply: reply mf payload returned from firmware
1266  * @config_page: contents of the config page
1267  * @phy_number: phy number
1268  * @handle: expander handle
1269  * Context: sleep.
1270  *
1271  * Returns 0 for success, non-zero for failure.
1272  */
1273 int
1274 mpt3sas_config_get_expander_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1275         *mpi_reply, Mpi2ExpanderPage1_t *config_page, u32 phy_number,
1276         u16 handle)
1277 {
1278         Mpi2ConfigRequest_t mpi_request;
1279         int r;
1280
1281         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1282         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1283         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1284         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1285         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1286         mpi_request.Header.PageNumber = 1;
1287         mpi_request.Header.PageVersion = MPI2_SASEXPANDER1_PAGEVERSION;
1288         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1289         r = _config_request(ioc, &mpi_request, mpi_reply,
1290             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1291         if (r)
1292                 goto out;
1293
1294         mpi_request.PageAddress =
1295             cpu_to_le32(MPI2_SAS_EXPAND_PGAD_FORM_HNDL_PHY_NUM |
1296             (phy_number << MPI2_SAS_EXPAND_PGAD_PHYNUM_SHIFT) | handle);
1297         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1298         r = _config_request(ioc, &mpi_request, mpi_reply,
1299             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1300             sizeof(*config_page));
1301  out:
1302         return r;
1303 }
1304
1305 /**
1306  * mpt3sas_config_get_enclosure_pg0 - obtain enclosure page 0
1307  * @ioc: per adapter object
1308  * @mpi_reply: reply mf payload returned from firmware
1309  * @config_page: contents of the config page
1310  * @form: GET_NEXT_HANDLE or HANDLE
1311  * @handle: expander handle
1312  * Context: sleep.
1313  *
1314  * Returns 0 for success, non-zero for failure.
1315  */
1316 int
1317 mpt3sas_config_get_enclosure_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1318         *mpi_reply, Mpi2SasEnclosurePage0_t *config_page, u32 form, u32 handle)
1319 {
1320         Mpi2ConfigRequest_t mpi_request;
1321         int r;
1322
1323         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1324         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1325         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1326         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1327         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE;
1328         mpi_request.Header.PageNumber = 0;
1329         mpi_request.Header.PageVersion = MPI2_SASENCLOSURE0_PAGEVERSION;
1330         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1331         r = _config_request(ioc, &mpi_request, mpi_reply,
1332             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1333         if (r)
1334                 goto out;
1335
1336         mpi_request.PageAddress = cpu_to_le32(form | handle);
1337         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1338         r = _config_request(ioc, &mpi_request, mpi_reply,
1339             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1340             sizeof(*config_page));
1341  out:
1342         return r;
1343 }
1344
1345 /**
1346  * mpt3sas_config_get_phy_pg0 - obtain phy page 0
1347  * @ioc: per adapter object
1348  * @mpi_reply: reply mf payload returned from firmware
1349  * @config_page: contents of the config page
1350  * @phy_number: phy number
1351  * Context: sleep.
1352  *
1353  * Returns 0 for success, non-zero for failure.
1354  */
1355 int
1356 mpt3sas_config_get_phy_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1357         *mpi_reply, Mpi2SasPhyPage0_t *config_page, u32 phy_number)
1358 {
1359         Mpi2ConfigRequest_t mpi_request;
1360         int r;
1361
1362         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1363         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1364         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1365         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1366         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1367         mpi_request.Header.PageNumber = 0;
1368         mpi_request.Header.PageVersion = MPI2_SASPHY0_PAGEVERSION;
1369         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1370         r = _config_request(ioc, &mpi_request, mpi_reply,
1371             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1372         if (r)
1373                 goto out;
1374
1375         mpi_request.PageAddress =
1376             cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1377         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1378         r = _config_request(ioc, &mpi_request, mpi_reply,
1379             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1380             sizeof(*config_page));
1381  out:
1382         return r;
1383 }
1384
1385 /**
1386  * mpt3sas_config_get_phy_pg1 - obtain phy page 1
1387  * @ioc: per adapter object
1388  * @mpi_reply: reply mf payload returned from firmware
1389  * @config_page: contents of the config page
1390  * @phy_number: phy number
1391  * Context: sleep.
1392  *
1393  * Returns 0 for success, non-zero for failure.
1394  */
1395 int
1396 mpt3sas_config_get_phy_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1397         *mpi_reply, Mpi2SasPhyPage1_t *config_page, u32 phy_number)
1398 {
1399         Mpi2ConfigRequest_t mpi_request;
1400         int r;
1401
1402         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1403         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1404         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1405         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1406         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1407         mpi_request.Header.PageNumber = 1;
1408         mpi_request.Header.PageVersion = MPI2_SASPHY1_PAGEVERSION;
1409         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1410         r = _config_request(ioc, &mpi_request, mpi_reply,
1411             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1412         if (r)
1413                 goto out;
1414
1415         mpi_request.PageAddress =
1416             cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1417         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1418         r = _config_request(ioc, &mpi_request, mpi_reply,
1419             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1420             sizeof(*config_page));
1421  out:
1422         return r;
1423 }
1424
1425 /**
1426  * mpt3sas_config_get_raid_volume_pg1 - obtain raid volume page 1
1427  * @ioc: per adapter object
1428  * @mpi_reply: reply mf payload returned from firmware
1429  * @config_page: contents of the config page
1430  * @form: GET_NEXT_HANDLE or HANDLE
1431  * @handle: volume handle
1432  * Context: sleep.
1433  *
1434  * Returns 0 for success, non-zero for failure.
1435  */
1436 int
1437 mpt3sas_config_get_raid_volume_pg1(struct MPT3SAS_ADAPTER *ioc,
1438         Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage1_t *config_page, u32 form,
1439         u32 handle)
1440 {
1441         Mpi2ConfigRequest_t mpi_request;
1442         int r;
1443
1444         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1445         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1446         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1447         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1448         mpi_request.Header.PageNumber = 1;
1449         mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE1_PAGEVERSION;
1450         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1451         r = _config_request(ioc, &mpi_request, mpi_reply,
1452             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1453         if (r)
1454                 goto out;
1455
1456         mpi_request.PageAddress = cpu_to_le32(form | handle);
1457         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1458         r = _config_request(ioc, &mpi_request, mpi_reply,
1459             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1460             sizeof(*config_page));
1461  out:
1462         return r;
1463 }
1464
1465 /**
1466  * mpt3sas_config_get_number_pds - obtain number of phys disk assigned to volume
1467  * @ioc: per adapter object
1468  * @handle: volume handle
1469  * @num_pds: returns pds count
1470  * Context: sleep.
1471  *
1472  * Returns 0 for success, non-zero for failure.
1473  */
1474 int
1475 mpt3sas_config_get_number_pds(struct MPT3SAS_ADAPTER *ioc, u16 handle,
1476         u8 *num_pds)
1477 {
1478         Mpi2ConfigRequest_t mpi_request;
1479         Mpi2RaidVolPage0_t config_page;
1480         Mpi2ConfigReply_t mpi_reply;
1481         int r;
1482         u16 ioc_status;
1483
1484         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1485         *num_pds = 0;
1486         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1487         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1488         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1489         mpi_request.Header.PageNumber = 0;
1490         mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1491         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1492         r = _config_request(ioc, &mpi_request, &mpi_reply,
1493             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1494         if (r)
1495                 goto out;
1496
1497         mpi_request.PageAddress =
1498             cpu_to_le32(MPI2_RAID_VOLUME_PGAD_FORM_HANDLE | handle);
1499         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1500         r = _config_request(ioc, &mpi_request, &mpi_reply,
1501             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1502             sizeof(Mpi2RaidVolPage0_t));
1503         if (!r) {
1504                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1505                     MPI2_IOCSTATUS_MASK;
1506                 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1507                         *num_pds = config_page.NumPhysDisks;
1508         }
1509
1510  out:
1511         return r;
1512 }
1513
1514 /**
1515  * mpt3sas_config_get_raid_volume_pg0 - obtain raid volume page 0
1516  * @ioc: per adapter object
1517  * @mpi_reply: reply mf payload returned from firmware
1518  * @config_page: contents of the config page
1519  * @form: GET_NEXT_HANDLE or HANDLE
1520  * @handle: volume handle
1521  * @sz: size of buffer passed in config_page
1522  * Context: sleep.
1523  *
1524  * Returns 0 for success, non-zero for failure.
1525  */
1526 int
1527 mpt3sas_config_get_raid_volume_pg0(struct MPT3SAS_ADAPTER *ioc,
1528         Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage0_t *config_page, u32 form,
1529         u32 handle, u16 sz)
1530 {
1531         Mpi2ConfigRequest_t mpi_request;
1532         int r;
1533
1534         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1535         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1536         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1537         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1538         mpi_request.Header.PageNumber = 0;
1539         mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1540         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1541         r = _config_request(ioc, &mpi_request, mpi_reply,
1542             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1543         if (r)
1544                 goto out;
1545
1546         mpi_request.PageAddress = cpu_to_le32(form | handle);
1547         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1548         r = _config_request(ioc, &mpi_request, mpi_reply,
1549             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1550  out:
1551         return r;
1552 }
1553
1554 /**
1555  * mpt3sas_config_get_phys_disk_pg0 - obtain phys disk page 0
1556  * @ioc: per adapter object
1557  * @mpi_reply: reply mf payload returned from firmware
1558  * @config_page: contents of the config page
1559  * @form: GET_NEXT_PHYSDISKNUM, PHYSDISKNUM, DEVHANDLE
1560  * @form_specific: specific to the form
1561  * Context: sleep.
1562  *
1563  * Returns 0 for success, non-zero for failure.
1564  */
1565 int
1566 mpt3sas_config_get_phys_disk_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1567         *mpi_reply, Mpi2RaidPhysDiskPage0_t *config_page, u32 form,
1568         u32 form_specific)
1569 {
1570         Mpi2ConfigRequest_t mpi_request;
1571         int r;
1572
1573         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1574         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1575         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1576         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK;
1577         mpi_request.Header.PageNumber = 0;
1578         mpi_request.Header.PageVersion = MPI2_RAIDPHYSDISKPAGE0_PAGEVERSION;
1579         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1580         r = _config_request(ioc, &mpi_request, mpi_reply,
1581             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1582         if (r)
1583                 goto out;
1584
1585         mpi_request.PageAddress = cpu_to_le32(form | form_specific);
1586         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1587         r = _config_request(ioc, &mpi_request, mpi_reply,
1588             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1589             sizeof(*config_page));
1590  out:
1591         return r;
1592 }
1593
1594 /**
1595  * mpt3sas_config_get_volume_handle - returns volume handle for give hidden
1596  * raid components
1597  * @ioc: per adapter object
1598  * @pd_handle: phys disk handle
1599  * @volume_handle: volume handle
1600  * Context: sleep.
1601  *
1602  * Returns 0 for success, non-zero for failure.
1603  */
1604 int
1605 mpt3sas_config_get_volume_handle(struct MPT3SAS_ADAPTER *ioc, u16 pd_handle,
1606         u16 *volume_handle)
1607 {
1608         Mpi2RaidConfigurationPage0_t *config_page = NULL;
1609         Mpi2ConfigRequest_t mpi_request;
1610         Mpi2ConfigReply_t mpi_reply;
1611         int r, i, config_page_sz;
1612         u16 ioc_status;
1613         int config_num;
1614         u16 element_type;
1615         u16 phys_disk_dev_handle;
1616
1617         *volume_handle = 0;
1618         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1619         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1620         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1621         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1622         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG;
1623         mpi_request.Header.PageVersion = MPI2_RAIDCONFIG0_PAGEVERSION;
1624         mpi_request.Header.PageNumber = 0;
1625         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1626         r = _config_request(ioc, &mpi_request, &mpi_reply,
1627             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1628         if (r)
1629                 goto out;
1630
1631         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1632         config_page_sz = (le16_to_cpu(mpi_reply.ExtPageLength) * 4);
1633         config_page = kmalloc(config_page_sz, GFP_KERNEL);
1634         if (!config_page) {
1635                 r = -1;
1636                 goto out;
1637         }
1638
1639         config_num = 0xff;
1640         while (1) {
1641                 mpi_request.PageAddress = cpu_to_le32(config_num +
1642                     MPI2_RAID_PGAD_FORM_GET_NEXT_CONFIGNUM);
1643                 r = _config_request(ioc, &mpi_request, &mpi_reply,
1644                     MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1645                     config_page_sz);
1646                 if (r)
1647                         goto out;
1648                 r = -1;
1649                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1650                     MPI2_IOCSTATUS_MASK;
1651                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
1652                         goto out;
1653                 for (i = 0; i < config_page->NumElements; i++) {
1654                         element_type = le16_to_cpu(config_page->
1655                             ConfigElement[i].ElementFlags) &
1656                             MPI2_RAIDCONFIG0_EFLAGS_MASK_ELEMENT_TYPE;
1657                         if (element_type ==
1658                             MPI2_RAIDCONFIG0_EFLAGS_VOL_PHYS_DISK_ELEMENT ||
1659                             element_type ==
1660                             MPI2_RAIDCONFIG0_EFLAGS_OCE_ELEMENT) {
1661                                 phys_disk_dev_handle =
1662                                     le16_to_cpu(config_page->ConfigElement[i].
1663                                     PhysDiskDevHandle);
1664                                 if (phys_disk_dev_handle == pd_handle) {
1665                                         *volume_handle =
1666                                             le16_to_cpu(config_page->
1667                                             ConfigElement[i].VolDevHandle);
1668                                         r = 0;
1669                                         goto out;
1670                                 }
1671                         } else if (element_type ==
1672                             MPI2_RAIDCONFIG0_EFLAGS_HOT_SPARE_ELEMENT) {
1673                                 *volume_handle = 0;
1674                                 r = 0;
1675                                 goto out;
1676                         }
1677                 }
1678                 config_num = config_page->ConfigNum;
1679         }
1680  out:
1681         kfree(config_page);
1682         return r;
1683 }
1684
1685 /**
1686  * mpt3sas_config_get_volume_wwid - returns wwid given the volume handle
1687  * @ioc: per adapter object
1688  * @volume_handle: volume handle
1689  * @wwid: volume wwid
1690  * Context: sleep.
1691  *
1692  * Returns 0 for success, non-zero for failure.
1693  */
1694 int
1695 mpt3sas_config_get_volume_wwid(struct MPT3SAS_ADAPTER *ioc, u16 volume_handle,
1696         u64 *wwid)
1697 {
1698         Mpi2ConfigReply_t mpi_reply;
1699         Mpi2RaidVolPage1_t raid_vol_pg1;
1700
1701         *wwid = 0;
1702         if (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
1703             &raid_vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE,
1704             volume_handle))) {
1705                 *wwid = le64_to_cpu(raid_vol_pg1.WWID);
1706                 return 0;
1707         } else
1708                 return -1;
1709 }