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         mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
 105         switch (mpi_request->Header.PageType & MPI2_CONFIG_PAGETYPE_MASK) {
 106         case MPI2_CONFIG_PAGETYPE_IO_UNIT:
 107                 desc = "io_unit";
 108                 break;
 109         case MPI2_CONFIG_PAGETYPE_IOC:
 110                 desc = "ioc";
 111                 break;
 112         case MPI2_CONFIG_PAGETYPE_BIOS:
 113                 desc = "bios";
 114                 break;
 115         case MPI2_CONFIG_PAGETYPE_RAID_VOLUME:
 116                 desc = "raid_volume";
 117                 break;
 118         case MPI2_CONFIG_PAGETYPE_MANUFACTURING:
 119                 desc = "manufacturing";
 120                 break;
 121         case MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK:
 122                 desc = "physdisk";
 123                 break;
 124         case MPI2_CONFIG_PAGETYPE_EXTENDED:
 125                 switch (mpi_request->ExtPageType) {
 126                 case MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT:
 127                         desc = "sas_io_unit";
 128                         break;
 129                 case MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER:
 130                         desc = "sas_expander";
 131                         break;
 132                 case MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE:
 133                         desc = "sas_device";
 134                         break;
 135                 case MPI2_CONFIG_EXTPAGETYPE_SAS_PHY:
 136                         desc = "sas_phy";
 137                         break;
 138                 case MPI2_CONFIG_EXTPAGETYPE_LOG:
 139                         desc = "log";
 140                         break;
 141                 case MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE:
 142                         desc = "enclosure";
 143                         break;
 144                 case MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG:
 145                         desc = "raid_config";
 146                         break;
 147                 case MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING:
 148                         desc = "driver_mapping";
 149                         break;
 150                 case MPI2_CONFIG_EXTPAGETYPE_SAS_PORT:
 151                         desc = "sas_port";
 152                         break;
 153                 case MPI2_CONFIG_EXTPAGETYPE_EXT_MANUFACTURING:
 154                         desc = "ext_manufacturing";
 155                         break;
 156                 case MPI2_CONFIG_EXTPAGETYPE_PCIE_IO_UNIT:
 157                         desc = "pcie_io_unit";
 158                         break;
 159                 case MPI2_CONFIG_EXTPAGETYPE_PCIE_SWITCH:
 160                         desc = "pcie_switch";
 161                         break;
 162                 case MPI2_CONFIG_EXTPAGETYPE_PCIE_DEVICE:
 163                         desc = "pcie_device";
 164                         break;
 165                 case MPI2_CONFIG_EXTPAGETYPE_PCIE_LINK:
 166                         desc = "pcie_link";
 167                         break;
 168                 }
 169                 break;
 170         }
 171
 172         if (!desc)
 173                 return;
 174
 175         ioc_info(ioc, "%s: %s(%d), action(%d), form(0x%08x), smid(%d)\n",
 176                  calling_function_name, desc,
 177                  mpi_request->Header.PageNumber, mpi_request->Action,
 178                  le32_to_cpu(mpi_request->PageAddress), smid);
 179
 180         if (!mpi_reply)
 181                 return;
 182
 183         if (mpi_reply->IOCStatus || mpi_reply->IOCLogInfo)
 184                 ioc_info(ioc, "\tiocstatus(0x%04x), loginfo(0x%08x)\n",
 185                          le16_to_cpu(mpi_reply->IOCStatus),
 186                          le32_to_cpu(mpi_reply->IOCLogInfo));
 187 }
 188
 189 /**
 190  * _config_alloc_config_dma_memory - obtain physical memory
 191  * @ioc: per adapter object
 192  * @mem: struct config_request
 193  *
 194  * A wrapper for obtaining dma-able memory for config page request.
 195  *
 196  * Return: 0 for success, non-zero for failure.
 197  */
 198 static int
 199 _config_alloc_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
 200         struct config_request *mem)
 201 {
 202         int r = 0;
 203
 204         if (mem->sz > ioc->config_page_sz) {
 205                 mem->page = dma_alloc_coherent(&ioc->pdev->dev, mem->sz,
 206                     &mem->page_dma, GFP_KERNEL);
 207                 if (!mem->page) {
 208                         ioc_err(ioc, "%s: dma_alloc_coherent failed asking for (%d) bytes!!\n",
 209                                 __func__, mem->sz);
 210                         r = -ENOMEM;
 211                 }
 212         } else { /* use tmp buffer if less than 512 bytes */
 213                 mem->page = ioc->config_page;
 214                 mem->page_dma = ioc->config_page_dma;
 215         }
 216         ioc->config_vaddr = mem->page;
 217         return r;
 218 }
 219
 220 /**
 221  * _config_free_config_dma_memory - wrapper to free the memory
 222  * @ioc: per adapter object
 223  * @mem: struct config_request
 224  *
 225  * A wrapper to free dma-able memory when using _config_alloc_config_dma_memory.
 226  *
 227  * Return: 0 for success, non-zero for failure.
 228  */
 229 static void
 230 _config_free_config_dma_memory(struct MPT3SAS_ADAPTER *ioc,
 231         struct config_request *mem)
 232 {
 233         if (mem->sz > ioc->config_page_sz)
 234                 dma_free_coherent(&ioc->pdev->dev, mem->sz, mem->page,
 235                     mem->page_dma);
 236 }
 237
 238 /**
 239  * mpt3sas_config_done - config page completion routine
 240  * @ioc: per adapter object
 241  * @smid: system request message index
 242  * @msix_index: MSIX table index supplied by the OS
 243  * @reply: reply message frame(lower 32bit addr)
 244  * Context: none.
 245  *
 246  * The callback handler when using _config_request.
 247  *
 248  * Return: 1 meaning mf should be freed from _base_interrupt
 249  *         0 means the mf is freed from this function.
 250  */
 251 u8
 252 mpt3sas_config_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
 253         u32 reply)
 254 {
 255         MPI2DefaultReply_t *mpi_reply;
 256
 257         if (ioc->config_cmds.status == MPT3_CMD_NOT_USED)
 258                 return 1;
 259         if (ioc->config_cmds.smid != smid)
 260                 return 1;
 261         ioc->config_cmds.status |= MPT3_CMD_COMPLETE;
 262         mpi_reply =  mpt3sas_base_get_reply_virt_addr(ioc, reply);
 263         if (mpi_reply) {
 264                 ioc->config_cmds.status |= MPT3_CMD_REPLY_VALID;
 265                 memcpy(ioc->config_cmds.reply, mpi_reply,
 266                     mpi_reply->MsgLength*4);
 267         }
 268         ioc->config_cmds.status &= ~MPT3_CMD_PENDING;
 269         if (ioc->logging_level & MPT_DEBUG_CONFIG)
 270                 _config_display_some_debug(ioc, smid, "config_done", mpi_reply);
 271         ioc->config_cmds.smid = USHRT_MAX;
 272         complete(&ioc->config_cmds.done);
 273         return 1;
 274 }
 275
 276 /**
 277  * _config_request - main routine for sending config page requests
 278  * @ioc: per adapter object
 279  * @mpi_request: request message frame
 280  * @mpi_reply: reply mf payload returned from firmware
 281  * @timeout: timeout in seconds
 282  * @config_page: contents of the config page
 283  * @config_page_sz: size of config page
 284  * Context: sleep
 285  *
 286  * A generic API for config page requests to firmware.
 287  *
 288  * The ioc->config_cmds.status flag should be MPT3_CMD_NOT_USED before calling
 289  * this API.
 290  *
 291  * The callback index is set inside `ioc->config_cb_idx.
 292  *
 293  * Return: 0 for success, non-zero for failure.
 294  */
 295 static int
 296 _config_request(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigRequest_t
 297         *mpi_request, Mpi2ConfigReply_t *mpi_reply, int timeout,
 298         void *config_page, u16 config_page_sz)
 299 {
 300         u16 smid;
 301         Mpi2ConfigRequest_t *config_request;
 302         int r;
 303         u8 retry_count, issue_host_reset = 0;
 304         struct config_request mem;
 305         u32 ioc_status = UINT_MAX;
 306
 307         mutex_lock(&ioc->config_cmds.mutex);
 308         if (ioc->config_cmds.status != MPT3_CMD_NOT_USED) {
 309                 ioc_err(ioc, "%s: config_cmd in use\n", __func__);
 310                 mutex_unlock(&ioc->config_cmds.mutex);
 311                 return -EAGAIN;
 312         }
 313
 314         retry_count = 0;
 315         memset(&mem, 0, sizeof(struct config_request));
 316
 317         mpi_request->VF_ID = 0; /* TODO */
 318         mpi_request->VP_ID = 0;
 319
 320         if (config_page) {
 321                 mpi_request->Header.PageVersion = mpi_reply->Header.PageVersion;
 322                 mpi_request->Header.PageNumber = mpi_reply->Header.PageNumber;
 323                 mpi_request->Header.PageType = mpi_reply->Header.PageType;
 324                 mpi_request->Header.PageLength = mpi_reply->Header.PageLength;
 325                 mpi_request->ExtPageLength = mpi_reply->ExtPageLength;
 326                 mpi_request->ExtPageType = mpi_reply->ExtPageType;
 327                 if (mpi_request->Header.PageLength)
 328                         mem.sz = mpi_request->Header.PageLength * 4;
 329                 else
 330                         mem.sz = le16_to_cpu(mpi_reply->ExtPageLength) * 4;
 331                 r = _config_alloc_config_dma_memory(ioc, &mem);
 332                 if (r != 0)
 333                         goto out;
 334                 if (mpi_request->Action ==
 335                     MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
 336                     mpi_request->Action ==
 337                     MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
 338                         ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
 339                             MPT3_CONFIG_COMMON_WRITE_SGLFLAGS | mem.sz,
 340                             mem.page_dma);
 341                         memcpy(mem.page, config_page, min_t(u16, mem.sz,
 342                             config_page_sz));
 343                 } else {
 344                         memset(config_page, 0, config_page_sz);
 345                         ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
 346                             MPT3_CONFIG_COMMON_SGLFLAGS | mem.sz, mem.page_dma);
 347                         memset(mem.page, 0, min_t(u16, mem.sz, config_page_sz));
 348                 }
 349         }
 350
 351  retry_config:
 352         if (retry_count) {
 353                 if (retry_count > 2) { /* attempt only 2 retries */
 354                         r = -EFAULT;
 355                         goto free_mem;
 356                 }
 357                 ioc_info(ioc, "%s: attempting retry (%d)\n",
 358                          __func__, retry_count);
 359         }
 360
 361         r = mpt3sas_wait_for_ioc(ioc, MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT);
 362         if (r) {
 363                 if (r == -ETIME)
 364                         issue_host_reset = 1;
 365                 goto free_mem;
 366         }
 367
 368         smid = mpt3sas_base_get_smid(ioc, ioc->config_cb_idx);
 369         if (!smid) {
 370                 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
 371                 ioc->config_cmds.status = MPT3_CMD_NOT_USED;
 372                 r = -EAGAIN;
 373                 goto free_mem;
 374         }
 375
 376         r = 0;
 377         memset(ioc->config_cmds.reply, 0, sizeof(Mpi2ConfigReply_t));
 378         ioc->config_cmds.status = MPT3_CMD_PENDING;
 379         config_request = mpt3sas_base_get_msg_frame(ioc, smid);
 380         ioc->config_cmds.smid = smid;
 381         memcpy(config_request, mpi_request, sizeof(Mpi2ConfigRequest_t));
 382         if (ioc->logging_level & MPT_DEBUG_CONFIG)
 383                 _config_display_some_debug(ioc, smid, "config_request", NULL);
 384         init_completion(&ioc->config_cmds.done);
 385         ioc->put_smid_default(ioc, smid);
 386         wait_for_completion_timeout(&ioc->config_cmds.done, timeout*HZ);
 387         if (!(ioc->config_cmds.status & MPT3_CMD_COMPLETE)) {
 388                 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
 389                         _config_display_some_debug(ioc,
 390                             smid, "config_request", NULL);
 391                 ioc_err(ioc, "%s: command timeout\n", __func__);
 392                 mpt3sas_base_check_cmd_timeout(ioc, ioc->config_cmds.status,
 393                                 mpi_request, sizeof(Mpi2ConfigRequest_t) / 4);
 394                 retry_count++;
 395                 if (ioc->config_cmds.smid == smid)
 396                         mpt3sas_base_free_smid(ioc, smid);
 397                 if (ioc->config_cmds.status & MPT3_CMD_RESET)
 398                         goto retry_config;
 399                 if (ioc->shost_recovery || ioc->pci_error_recovery) {
 400                         issue_host_reset = 0;
 401                         r = -EFAULT;
 402                 } else
 403                         issue_host_reset = 1;
 404                 goto free_mem;
 405         }
 406
 407         if (ioc->config_cmds.status & MPT3_CMD_REPLY_VALID) {
 408                 memcpy(mpi_reply, ioc->config_cmds.reply,
 409                     sizeof(Mpi2ConfigReply_t));
 410
 411                 /* Reply Frame Sanity Checks to workaround FW issues */
 412                 if ((mpi_request->Header.PageType & 0xF) !=
 413                     (mpi_reply->Header.PageType & 0xF)) {
 414                         if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
 415                                 _config_display_some_debug(ioc,
 416                                     smid, "config_request", NULL);
 417                         _debug_dump_mf(mpi_request, ioc->request_sz/4);
 418                         _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
 419                         panic("%s: %s: Firmware BUG: mpi_reply mismatch: Requested PageType(0x%02x) Reply PageType(0x%02x)\n",
 420                               ioc->name, __func__,
 421                               mpi_request->Header.PageType & 0xF,
 422                               mpi_reply->Header.PageType & 0xF);
 423                 }
 424
 425                 if (((mpi_request->Header.PageType & 0xF) ==
 426                     MPI2_CONFIG_PAGETYPE_EXTENDED) &&
 427                     mpi_request->ExtPageType != mpi_reply->ExtPageType) {
 428                         if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
 429                                 _config_display_some_debug(ioc,
 430                                     smid, "config_request", NULL);
 431                         _debug_dump_mf(mpi_request, ioc->request_sz/4);
 432                         _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
 433                         panic("%s: %s: Firmware BUG: mpi_reply mismatch: Requested ExtPageType(0x%02x) Reply ExtPageType(0x%02x)\n",
 434                               ioc->name, __func__,
 435                               mpi_request->ExtPageType,
 436                               mpi_reply->ExtPageType);
 437                 }
 438                 ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
 439                     & MPI2_IOCSTATUS_MASK;
 440         }
 441
 442         if (retry_count)
 443                 ioc_info(ioc, "%s: retry (%d) completed!!\n",
 444                          __func__, retry_count);
 445
 446         if ((ioc_status == MPI2_IOCSTATUS_SUCCESS) &&
 447             config_page && mpi_request->Action ==
 448             MPI2_CONFIG_ACTION_PAGE_READ_CURRENT) {
 449                 u8 *p = (u8 *)mem.page;
 450
 451                 /* Config Page Sanity Checks to workaround FW issues */
 452                 if (p) {
 453                         if ((mpi_request->Header.PageType & 0xF) !=
 454                             (p[3] & 0xF)) {
 455                                 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
 456                                         _config_display_some_debug(ioc,
 457                                             smid, "config_request", NULL);
 458                                 _debug_dump_mf(mpi_request, ioc->request_sz/4);
 459                                 _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
 460                                 _debug_dump_config(p, min_t(u16, mem.sz,
 461                                     config_page_sz)/4);
 462                                 panic("%s: %s: Firmware BUG: config page mismatch: Requested PageType(0x%02x) Reply PageType(0x%02x)\n",
 463                                       ioc->name, __func__,
 464                                       mpi_request->Header.PageType & 0xF,
 465                                       p[3] & 0xF);
 466                         }
 467
 468                         if (((mpi_request->Header.PageType & 0xF) ==
 469                             MPI2_CONFIG_PAGETYPE_EXTENDED) &&
 470                             (mpi_request->ExtPageType != p[6])) {
 471                                 if (!(ioc->logging_level & MPT_DEBUG_CONFIG))
 472                                         _config_display_some_debug(ioc,
 473                                             smid, "config_request", NULL);
 474                                 _debug_dump_mf(mpi_request, ioc->request_sz/4);
 475                                 _debug_dump_reply(mpi_reply, ioc->reply_sz/4);
 476                                 _debug_dump_config(p, min_t(u16, mem.sz,
 477                                     config_page_sz)/4);
 478                                 panic("%s: %s: Firmware BUG: config page mismatch: Requested ExtPageType(0x%02x) Reply ExtPageType(0x%02x)\n",
 479                                       ioc->name, __func__,
 480                                       mpi_request->ExtPageType, p[6]);
 481                         }
 482                 }
 483                 memcpy(config_page, mem.page, min_t(u16, mem.sz,
 484                     config_page_sz));
 485         }
 486
 487  free_mem:
 488         if (config_page)
 489                 _config_free_config_dma_memory(ioc, &mem);
 490  out:
 491         ioc->config_cmds.status = MPT3_CMD_NOT_USED;
 492         mutex_unlock(&ioc->config_cmds.mutex);
 493
 494         if (issue_host_reset) {
 495                 if (ioc->drv_internal_flags & MPT_DRV_INTERNAL_FIRST_PE_ISSUED) {
 496                         mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
 497                         r = -EFAULT;
 498                 } else {
 499                         if (mpt3sas_base_check_for_fault_and_issue_reset(ioc))
 500                                 return -EFAULT;
 501                         r = -EAGAIN;
 502                 }
 503         }
 504         return r;
 505 }
 506
 507 /**
 508  * mpt3sas_config_get_manufacturing_pg0 - obtain manufacturing page 0
 509  * @ioc: per adapter object
 510  * @mpi_reply: reply mf payload returned from firmware
 511  * @config_page: contents of the config page
 512  * Context: sleep.
 513  *
 514  * Return: 0 for success, non-zero for failure.
 515  */
 516 int
 517 mpt3sas_config_get_manufacturing_pg0(struct MPT3SAS_ADAPTER *ioc,
 518         Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage0_t *config_page)
 519 {
 520         Mpi2ConfigRequest_t mpi_request;
 521         int r;
 522
 523         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 524         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 525         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 526         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 527         mpi_request.Header.PageNumber = 0;
 528         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 529         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 530         r = _config_request(ioc, &mpi_request, mpi_reply,
 531             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 532         if (r)
 533                 goto out;
 534
 535         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 536         r = _config_request(ioc, &mpi_request, mpi_reply,
 537             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 538             sizeof(*config_page));
 539  out:
 540         return r;
 541 }
 542
 543 /**
 544  * mpt3sas_config_get_manufacturing_pg1 - obtain manufacturing page 1
 545  * @ioc: per adapter object
 546  * @mpi_reply: reply mf payload returned from firmware
 547  * @config_page: contents of the config page
 548  * Context: sleep.
 549  *
 550  * Return: 0 for success, non-zero for failure.
 551  */
 552 int
 553 mpt3sas_config_get_manufacturing_pg1(struct MPT3SAS_ADAPTER *ioc,
 554         Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage1_t *config_page)
 555 {
 556         Mpi2ConfigRequest_t mpi_request;
 557         int r;
 558
 559         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 560         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 561         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 562         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 563         mpi_request.Header.PageNumber = 1;
 564         mpi_request.Header.PageVersion = MPI2_MANUFACTURING1_PAGEVERSION;
 565         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 566         r = _config_request(ioc, &mpi_request, mpi_reply,
 567                 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 568         if (r)
 569                 goto out;
 570
 571         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 572         r = _config_request(ioc, &mpi_request, mpi_reply,
 573                 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 574                 sizeof(*config_page));
 575  out:
 576         return r;
 577 }
 578
 579 /**
 580  * mpt3sas_config_get_manufacturing_pg7 - obtain manufacturing page 7
 581  * @ioc: per adapter object
 582  * @mpi_reply: reply mf payload returned from firmware
 583  * @config_page: contents of the config page
 584  * @sz: size of buffer passed in config_page
 585  * Context: sleep.
 586  *
 587  * Return: 0 for success, non-zero for failure.
 588  */
 589 int
 590 mpt3sas_config_get_manufacturing_pg7(struct MPT3SAS_ADAPTER *ioc,
 591         Mpi2ConfigReply_t *mpi_reply, Mpi2ManufacturingPage7_t *config_page,
 592         u16 sz)
 593 {
 594         Mpi2ConfigRequest_t mpi_request;
 595         int r;
 596
 597         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 598         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 599         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 600         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 601         mpi_request.Header.PageNumber = 7;
 602         mpi_request.Header.PageVersion = MPI2_MANUFACTURING7_PAGEVERSION;
 603         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 604         r = _config_request(ioc, &mpi_request, mpi_reply,
 605             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 606         if (r)
 607                 goto out;
 608
 609         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 610         r = _config_request(ioc, &mpi_request, mpi_reply,
 611             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 612             sz);
 613  out:
 614         return r;
 615 }
 616
 617 /**
 618  * mpt3sas_config_get_manufacturing_pg10 - obtain manufacturing page 10
 619  * @ioc: per adapter object
 620  * @mpi_reply: reply mf payload returned from firmware
 621  * @config_page: contents of the config page
 622  * Context: sleep.
 623  *
 624  * Return: 0 for success, non-zero for failure.
 625  */
 626 int
 627 mpt3sas_config_get_manufacturing_pg10(struct MPT3SAS_ADAPTER *ioc,
 628         Mpi2ConfigReply_t *mpi_reply,
 629         struct Mpi2ManufacturingPage10_t *config_page)
 630 {
 631         Mpi2ConfigRequest_t mpi_request;
 632         int r;
 633
 634         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 635         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 636         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 637         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 638         mpi_request.Header.PageNumber = 10;
 639         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 640         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 641         r = _config_request(ioc, &mpi_request, mpi_reply,
 642             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 643         if (r)
 644                 goto out;
 645
 646         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 647         r = _config_request(ioc, &mpi_request, mpi_reply,
 648             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 649             sizeof(*config_page));
 650  out:
 651         return r;
 652 }
 653
 654 /**
 655  * mpt3sas_config_get_manufacturing_pg11 - obtain manufacturing page 11
 656  * @ioc: per adapter object
 657  * @mpi_reply: reply mf payload returned from firmware
 658  * @config_page: contents of the config page
 659  * Context: sleep.
 660  *
 661  * Return: 0 for success, non-zero for failure.
 662  */
 663 int
 664 mpt3sas_config_get_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
 665         Mpi2ConfigReply_t *mpi_reply,
 666         struct Mpi2ManufacturingPage11_t *config_page)
 667 {
 668         Mpi2ConfigRequest_t mpi_request;
 669         int r;
 670
 671         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 672         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 673         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 674         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 675         mpi_request.Header.PageNumber = 11;
 676         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 677         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 678         r = _config_request(ioc, &mpi_request, mpi_reply,
 679             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 680         if (r)
 681                 goto out;
 682
 683         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 684         r = _config_request(ioc, &mpi_request, mpi_reply,
 685             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 686             sizeof(*config_page));
 687  out:
 688         return r;
 689 }
 690
 691 /**
 692  * mpt3sas_config_set_manufacturing_pg11 - set manufacturing page 11
 693  * @ioc: per adapter object
 694  * @mpi_reply: reply mf payload returned from firmware
 695  * @config_page: contents of the config page
 696  * Context: sleep.
 697  *
 698  * Return: 0 for success, non-zero for failure.
 699  */
 700 int
 701 mpt3sas_config_set_manufacturing_pg11(struct MPT3SAS_ADAPTER *ioc,
 702         Mpi2ConfigReply_t *mpi_reply,
 703         struct Mpi2ManufacturingPage11_t *config_page)
 704 {
 705         Mpi2ConfigRequest_t mpi_request;
 706         int r;
 707
 708         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 709         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 710         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 711         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 712         mpi_request.Header.PageNumber = 11;
 713         mpi_request.Header.PageVersion = MPI2_MANUFACTURING0_PAGEVERSION;
 714         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 715         r = _config_request(ioc, &mpi_request, mpi_reply,
 716             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 717         if (r)
 718                 goto out;
 719
 720         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 721         r = _config_request(ioc, &mpi_request, mpi_reply,
 722             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 723             sizeof(*config_page));
 724  out:
 725         return r;
 726 }
 727
 728 /**
 729  * mpt3sas_config_get_bios_pg2 - obtain bios page 2
 730  * @ioc: per adapter object
 731  * @mpi_reply: reply mf payload returned from firmware
 732  * @config_page: contents of the config page
 733  * Context: sleep.
 734  *
 735  * Return: 0 for success, non-zero for failure.
 736  */
 737 int
 738 mpt3sas_config_get_bios_pg2(struct MPT3SAS_ADAPTER *ioc,
 739         Mpi2ConfigReply_t *mpi_reply, Mpi2BiosPage2_t *config_page)
 740 {
 741         Mpi2ConfigRequest_t mpi_request;
 742         int r;
 743
 744         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 745         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 746         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 747         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
 748         mpi_request.Header.PageNumber = 2;
 749         mpi_request.Header.PageVersion = MPI2_BIOSPAGE2_PAGEVERSION;
 750         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 751         r = _config_request(ioc, &mpi_request, mpi_reply,
 752             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 753         if (r)
 754                 goto out;
 755
 756         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 757         r = _config_request(ioc, &mpi_request, mpi_reply,
 758             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 759             sizeof(*config_page));
 760  out:
 761         return r;
 762 }
 763
 764 /**
 765  * mpt3sas_config_get_bios_pg3 - obtain bios page 3
 766  * @ioc: per adapter object
 767  * @mpi_reply: reply mf payload returned from firmware
 768  * @config_page: contents of the config page
 769  * Context: sleep.
 770  *
 771  * Return: 0 for success, non-zero for failure.
 772  */
 773 int
 774 mpt3sas_config_get_bios_pg3(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
 775         *mpi_reply, Mpi2BiosPage3_t *config_page)
 776 {
 777         Mpi2ConfigRequest_t mpi_request;
 778         int r;
 779
 780         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 781         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 782         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 783         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
 784         mpi_request.Header.PageNumber = 3;
 785         mpi_request.Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION;
 786         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 787         r = _config_request(ioc, &mpi_request, mpi_reply,
 788             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 789         if (r)
 790                 goto out;
 791
 792         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 793         r = _config_request(ioc, &mpi_request, mpi_reply,
 794             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 795             sizeof(*config_page));
 796
 797  out:
 798         return r;
 799 }
 800
 801 /**
 802  * mpt3sas_config_set_bios_pg4 - write out bios page 4
 803  * @ioc: per adapter object
 804  * @mpi_reply: reply mf payload returned from firmware
 805  * @config_page: contents of the config page
 806  * @sz_config_pg: sizeof the config page
 807  * Context: sleep.
 808  *
 809  * Return: 0 for success, non-zero for failure.
 810  */
 811 int
 812 mpt3sas_config_set_bios_pg4(struct MPT3SAS_ADAPTER *ioc,
 813         Mpi2ConfigReply_t *mpi_reply, Mpi2BiosPage4_t *config_page,
 814         int sz_config_pg)
 815 {
 816         Mpi2ConfigRequest_t mpi_request;
 817         int r;
 818
 819         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 820
 821         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 822         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 823         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
 824         mpi_request.Header.PageNumber = 4;
 825         mpi_request.Header.PageVersion = MPI2_BIOSPAGE4_PAGEVERSION;
 826
 827         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 828
 829         r = _config_request(ioc, &mpi_request, mpi_reply,
 830                 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 831         if (r)
 832                 goto out;
 833
 834         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 835         r = _config_request(ioc, &mpi_request, mpi_reply,
 836                 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 837                 sz_config_pg);
 838  out:
 839         return r;
 840 }
 841
 842 /**
 843  * mpt3sas_config_get_bios_pg4 - read bios page 4
 844  * @ioc: per adapter object
 845  * @mpi_reply: reply mf payload returned from firmware
 846  * @config_page: contents of the config page
 847  * @sz_config_pg: sizeof the config page
 848  * Context: sleep.
 849  *
 850  * Return: 0 for success, non-zero for failure.
 851  */
 852 int
 853 mpt3sas_config_get_bios_pg4(struct MPT3SAS_ADAPTER *ioc,
 854         Mpi2ConfigReply_t *mpi_reply, Mpi2BiosPage4_t *config_page,
 855         int sz_config_pg)
 856 {
 857         Mpi2ConfigRequest_t mpi_request;
 858         int r;
 859
 860         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 861         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 862         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 863         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
 864         mpi_request.Header.PageNumber = 4;
 865         mpi_request.Header.PageVersion =  MPI2_BIOSPAGE4_PAGEVERSION;
 866         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 867         r = _config_request(ioc, &mpi_request, mpi_reply,
 868                 MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 869         if (r)
 870                 goto out;
 871
 872         /*
 873          * The sizeof the page is variable. Allow for just the
 874          * size to be returned
 875          */
 876         if (config_page && sz_config_pg) {
 877                 mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 878
 879                 r = _config_request(ioc, &mpi_request, mpi_reply,
 880                         MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 881                         sz_config_pg);
 882         }
 883
 884 out:
 885         return r;
 886 }
 887
 888 /**
 889  * mpt3sas_config_get_iounit_pg0 - obtain iounit page 0
 890  * @ioc: per adapter object
 891  * @mpi_reply: reply mf payload returned from firmware
 892  * @config_page: contents of the config page
 893  * Context: sleep.
 894  *
 895  * Return: 0 for success, non-zero for failure.
 896  */
 897 int
 898 mpt3sas_config_get_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
 899         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage0_t *config_page)
 900 {
 901         Mpi2ConfigRequest_t mpi_request;
 902         int r;
 903
 904         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 905         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 906         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 907         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 908         mpi_request.Header.PageNumber = 0;
 909         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE0_PAGEVERSION;
 910         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 911         r = _config_request(ioc, &mpi_request, mpi_reply,
 912             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 913         if (r)
 914                 goto out;
 915
 916         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 917         r = _config_request(ioc, &mpi_request, mpi_reply,
 918             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 919             sizeof(*config_page));
 920  out:
 921         return r;
 922 }
 923
 924 /**
 925  * mpt3sas_config_get_iounit_pg1 - obtain iounit page 1
 926  * @ioc: per adapter object
 927  * @mpi_reply: reply mf payload returned from firmware
 928  * @config_page: contents of the config page
 929  * Context: sleep.
 930  *
 931  * Return: 0 for success, non-zero for failure.
 932  */
 933 int
 934 mpt3sas_config_get_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
 935         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
 936 {
 937         Mpi2ConfigRequest_t mpi_request;
 938         int r;
 939
 940         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 941         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 942         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 943         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 944         mpi_request.Header.PageNumber = 1;
 945         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
 946         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 947         r = _config_request(ioc, &mpi_request, mpi_reply,
 948             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 949         if (r)
 950                 goto out;
 951
 952         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 953         r = _config_request(ioc, &mpi_request, mpi_reply,
 954             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 955             sizeof(*config_page));
 956  out:
 957         return r;
 958 }
 959
 960 /**
 961  * mpt3sas_config_set_iounit_pg1 - set iounit page 1
 962  * @ioc: per adapter object
 963  * @mpi_reply: reply mf payload returned from firmware
 964  * @config_page: contents of the config page
 965  * Context: sleep.
 966  *
 967  * Return: 0 for success, non-zero for failure.
 968  */
 969 int
 970 mpt3sas_config_set_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
 971         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage1_t *config_page)
 972 {
 973         Mpi2ConfigRequest_t mpi_request;
 974         int r;
 975
 976         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
 977         mpi_request.Function = MPI2_FUNCTION_CONFIG;
 978         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 979         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
 980         mpi_request.Header.PageNumber = 1;
 981         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE1_PAGEVERSION;
 982         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
 983         r = _config_request(ioc, &mpi_request, mpi_reply,
 984             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
 985         if (r)
 986                 goto out;
 987
 988         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 989         r = _config_request(ioc, &mpi_request, mpi_reply,
 990             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
 991             sizeof(*config_page));
 992  out:
 993         return r;
 994 }
 995
 996 /**
 997  * mpt3sas_config_get_iounit_pg3 - obtain iounit page 3
 998  * @ioc: per adapter object
 999  * @mpi_reply: reply mf payload returned from firmware
1000  * @config_page: contents of the config page
1001  * @sz: size of buffer passed in config_page
1002  * Context: sleep.
1003  *
1004  * Return: 0 for success, non-zero for failure.
1005  */
1006 int
1007 mpt3sas_config_get_iounit_pg3(struct MPT3SAS_ADAPTER *ioc,
1008         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage3_t *config_page, u16 sz)
1009 {
1010         Mpi2ConfigRequest_t mpi_request;
1011         int r;
1012
1013         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1014         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1015         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1016         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
1017         mpi_request.Header.PageNumber = 3;
1018         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE3_PAGEVERSION;
1019         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1020         r = _config_request(ioc, &mpi_request, mpi_reply,
1021             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1022         if (r)
1023                 goto out;
1024
1025         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1026         r = _config_request(ioc, &mpi_request, mpi_reply,
1027             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1028  out:
1029         return r;
1030 }
1031
1032 /**
1033  * mpt3sas_config_get_iounit_pg8 - obtain iounit page 8
1034  * @ioc: per adapter object
1035  * @mpi_reply: reply mf payload returned from firmware
1036  * @config_page: contents of the config page
1037  * Context: sleep.
1038  *
1039  * Return: 0 for success, non-zero for failure.
1040  */
1041 int
1042 mpt3sas_config_get_iounit_pg8(struct MPT3SAS_ADAPTER *ioc,
1043         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage8_t *config_page)
1044 {
1045         Mpi2ConfigRequest_t mpi_request;
1046         int r;
1047
1048         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1049         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1050         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1051         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IO_UNIT;
1052         mpi_request.Header.PageNumber = 8;
1053         mpi_request.Header.PageVersion = MPI2_IOUNITPAGE8_PAGEVERSION;
1054         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1055         r = _config_request(ioc, &mpi_request, mpi_reply,
1056             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1057         if (r)
1058                 goto out;
1059
1060         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1061         r = _config_request(ioc, &mpi_request, mpi_reply,
1062             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1063             sizeof(*config_page));
1064  out:
1065         return r;
1066 }
1067
1068 /**
1069  * mpt3sas_config_get_ioc_pg8 - obtain ioc page 8
1070  * @ioc: per adapter object
1071  * @mpi_reply: reply mf payload returned from firmware
1072  * @config_page: contents of the config page
1073  * Context: sleep.
1074  *
1075  * Return: 0 for success, non-zero for failure.
1076  */
1077 int
1078 mpt3sas_config_get_ioc_pg8(struct MPT3SAS_ADAPTER *ioc,
1079         Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage8_t *config_page)
1080 {
1081         Mpi2ConfigRequest_t mpi_request;
1082         int r;
1083
1084         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1085         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1086         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1087         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
1088         mpi_request.Header.PageNumber = 8;
1089         mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
1090         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1091         r = _config_request(ioc, &mpi_request, mpi_reply,
1092             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1093         if (r)
1094                 goto out;
1095
1096         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1097         r = _config_request(ioc, &mpi_request, mpi_reply,
1098             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1099             sizeof(*config_page));
1100  out:
1101         return r;
1102 }
1103 /**
1104  * mpt3sas_config_get_ioc_pg1 - obtain ioc page 1
1105  * @ioc: per adapter object
1106  * @mpi_reply: reply mf payload returned from firmware
1107  * @config_page: contents of the config page
1108  * Context: sleep.
1109  *
1110  * Return: 0 for success, non-zero for failure.
1111  */
1112 int
1113 mpt3sas_config_get_ioc_pg1(struct MPT3SAS_ADAPTER *ioc,
1114         Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage1_t *config_page)
1115 {
1116         Mpi2ConfigRequest_t mpi_request;
1117         int r;
1118
1119         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1120         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1121         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1122         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
1123         mpi_request.Header.PageNumber = 1;
1124         mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
1125         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1126         r = _config_request(ioc, &mpi_request, mpi_reply,
1127             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1128         if (r)
1129                 goto out;
1130
1131         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1132         r = _config_request(ioc, &mpi_request, mpi_reply,
1133             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1134             sizeof(*config_page));
1135  out:
1136         return r;
1137 }
1138
1139 /**
1140  * mpt3sas_config_set_ioc_pg1 - modify ioc page 1
1141  * @ioc: per adapter object
1142  * @mpi_reply: reply mf payload returned from firmware
1143  * @config_page: contents of the config page
1144  * Context: sleep.
1145  *
1146  * Return: 0 for success, non-zero for failure.
1147  */
1148 int
1149 mpt3sas_config_set_ioc_pg1(struct MPT3SAS_ADAPTER *ioc,
1150         Mpi2ConfigReply_t *mpi_reply, Mpi2IOCPage1_t *config_page)
1151 {
1152         Mpi2ConfigRequest_t mpi_request;
1153         int r;
1154
1155         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1156         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1157         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1158         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
1159         mpi_request.Header.PageNumber = 1;
1160         mpi_request.Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
1161         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1162         r = _config_request(ioc, &mpi_request, mpi_reply,
1163             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1164         if (r)
1165                 goto out;
1166
1167         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
1168         r = _config_request(ioc, &mpi_request, mpi_reply,
1169             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1170             sizeof(*config_page));
1171  out:
1172         return r;
1173 }
1174
1175 /**
1176  * mpt3sas_config_get_sas_device_pg0 - obtain sas device page 0
1177  * @ioc: per adapter object
1178  * @mpi_reply: reply mf payload returned from firmware
1179  * @config_page: contents of the config page
1180  * @form: GET_NEXT_HANDLE or HANDLE
1181  * @handle: device handle
1182  * Context: sleep.
1183  *
1184  * Return: 0 for success, non-zero for failure.
1185  */
1186 int
1187 mpt3sas_config_get_sas_device_pg0(struct MPT3SAS_ADAPTER *ioc,
1188         Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage0_t *config_page,
1189         u32 form, u32 handle)
1190 {
1191         Mpi2ConfigRequest_t mpi_request;
1192         int r;
1193
1194         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1195         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1196         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1197         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1198         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1199         mpi_request.Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION;
1200         mpi_request.Header.PageNumber = 0;
1201         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1202         r = _config_request(ioc, &mpi_request, mpi_reply,
1203             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1204         if (r)
1205                 goto out;
1206
1207         mpi_request.PageAddress = cpu_to_le32(form | handle);
1208         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1209         r = _config_request(ioc, &mpi_request, mpi_reply,
1210             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1211             sizeof(*config_page));
1212  out:
1213         return r;
1214 }
1215
1216 /**
1217  * mpt3sas_config_get_sas_device_pg1 - obtain sas device page 1
1218  * @ioc: per adapter object
1219  * @mpi_reply: reply mf payload returned from firmware
1220  * @config_page: contents of the config page
1221  * @form: GET_NEXT_HANDLE or HANDLE
1222  * @handle: device handle
1223  * Context: sleep.
1224  *
1225  * Return: 0 for success, non-zero for failure.
1226  */
1227 int
1228 mpt3sas_config_get_sas_device_pg1(struct MPT3SAS_ADAPTER *ioc,
1229         Mpi2ConfigReply_t *mpi_reply, Mpi2SasDevicePage1_t *config_page,
1230         u32 form, u32 handle)
1231 {
1232         Mpi2ConfigRequest_t mpi_request;
1233         int r;
1234
1235         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1236         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1237         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1238         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1239         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1240         mpi_request.Header.PageVersion = MPI2_SASDEVICE1_PAGEVERSION;
1241         mpi_request.Header.PageNumber = 1;
1242         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1243         r = _config_request(ioc, &mpi_request, mpi_reply,
1244             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1245         if (r)
1246                 goto out;
1247
1248         mpi_request.PageAddress = cpu_to_le32(form | handle);
1249         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1250         r = _config_request(ioc, &mpi_request, mpi_reply,
1251             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1252             sizeof(*config_page));
1253  out:
1254         return r;
1255 }
1256
1257 /**
1258  * mpt3sas_config_get_pcie_device_pg0 - obtain pcie device page 0
1259  * @ioc: per adapter object
1260  * @mpi_reply: reply mf payload returned from firmware
1261  * @config_page: contents of the config page
1262  * @form: GET_NEXT_HANDLE or HANDLE
1263  * @handle: device handle
1264  * Context: sleep.
1265  *
1266  * Return: 0 for success, non-zero for failure.
1267  */
1268 int
1269 mpt3sas_config_get_pcie_device_pg0(struct MPT3SAS_ADAPTER *ioc,
1270         Mpi2ConfigReply_t *mpi_reply, Mpi26PCIeDevicePage0_t *config_page,
1271         u32 form, u32 handle)
1272 {
1273         Mpi2ConfigRequest_t mpi_request;
1274         int r;
1275
1276         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1277         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1278         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1279         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1280         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_PCIE_DEVICE;
1281         mpi_request.Header.PageVersion = MPI26_PCIEDEVICE0_PAGEVERSION;
1282         mpi_request.Header.PageNumber = 0;
1283         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1284         r = _config_request(ioc, &mpi_request, mpi_reply,
1285                         MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1286         if (r)
1287                 goto out;
1288
1289         mpi_request.PageAddress = cpu_to_le32(form | handle);
1290         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1291         r = _config_request(ioc, &mpi_request, mpi_reply,
1292                         MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1293                         sizeof(*config_page));
1294 out:
1295         return r;
1296 }
1297
1298 /**
1299  * mpt3sas_config_get_pcie_iounit_pg1 - obtain pcie iounit page 1
1300  * @ioc: per adapter object
1301  * @mpi_reply: reply mf payload returned from firmware
1302  * @config_page: contents of the config page
1303  * @sz: size of buffer passed in config_page
1304  * Context: sleep.
1305  *
1306  * Returns 0 for success, non-zero for failure.
1307  */
1308 int
1309 mpt3sas_config_get_pcie_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1310         Mpi2ConfigReply_t *mpi_reply, Mpi26PCIeIOUnitPage1_t *config_page,
1311         u16 sz)
1312 {
1313         Mpi2ConfigRequest_t mpi_request;
1314         int r;
1315
1316         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1317         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1318         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1319         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1320         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_PCIE_IO_UNIT;
1321         mpi_request.Header.PageVersion = MPI26_PCIEIOUNITPAGE1_PAGEVERSION;
1322         mpi_request.Header.PageNumber = 1;
1323         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1324         r = _config_request(ioc, &mpi_request, mpi_reply,
1325             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1326         if (r)
1327                 goto out;
1328         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1329         r = _config_request(ioc, &mpi_request, mpi_reply,
1330             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1331 out:
1332         return r;
1333 }
1334
1335 /**
1336  * mpt3sas_config_get_pcie_device_pg2 - obtain pcie device page 2
1337  * @ioc: per adapter object
1338  * @mpi_reply: reply mf payload returned from firmware
1339  * @config_page: contents of the config page
1340  * @form: GET_NEXT_HANDLE or HANDLE
1341  * @handle: device handle
1342  * Context: sleep.
1343  *
1344  * Return: 0 for success, non-zero for failure.
1345  */
1346 int
1347 mpt3sas_config_get_pcie_device_pg2(struct MPT3SAS_ADAPTER *ioc,
1348         Mpi2ConfigReply_t *mpi_reply, Mpi26PCIeDevicePage2_t *config_page,
1349         u32 form, u32 handle)
1350 {
1351         Mpi2ConfigRequest_t mpi_request;
1352         int r;
1353
1354         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1355         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1356         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1357         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1358         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_PCIE_DEVICE;
1359         mpi_request.Header.PageVersion = MPI26_PCIEDEVICE2_PAGEVERSION;
1360         mpi_request.Header.PageNumber = 2;
1361         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1362         r = _config_request(ioc, &mpi_request, mpi_reply,
1363                         MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1364         if (r)
1365                 goto out;
1366
1367         mpi_request.PageAddress = cpu_to_le32(form | handle);
1368         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1369         r = _config_request(ioc, &mpi_request, mpi_reply,
1370                         MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1371                         sizeof(*config_page));
1372 out:
1373         return r;
1374 }
1375
1376 /**
1377  * mpt3sas_config_get_number_hba_phys - obtain number of phys on the host
1378  * @ioc: per adapter object
1379  * @num_phys: pointer returned with the number of phys
1380  * Context: sleep.
1381  *
1382  * Return: 0 for success, non-zero for failure.
1383  */
1384 int
1385 mpt3sas_config_get_number_hba_phys(struct MPT3SAS_ADAPTER *ioc, u8 *num_phys)
1386 {
1387         Mpi2ConfigRequest_t mpi_request;
1388         int r;
1389         u16 ioc_status;
1390         Mpi2ConfigReply_t mpi_reply;
1391         Mpi2SasIOUnitPage0_t config_page;
1392
1393         *num_phys = 0;
1394         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1395         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1396         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1397         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1398         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1399         mpi_request.Header.PageNumber = 0;
1400         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1401         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1402         r = _config_request(ioc, &mpi_request, &mpi_reply,
1403             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1404         if (r)
1405                 goto out;
1406
1407         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1408         r = _config_request(ioc, &mpi_request, &mpi_reply,
1409             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1410             sizeof(Mpi2SasIOUnitPage0_t));
1411         if (!r) {
1412                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1413                     MPI2_IOCSTATUS_MASK;
1414                 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1415                         *num_phys = config_page.NumPhys;
1416         }
1417  out:
1418         return r;
1419 }
1420
1421 /**
1422  * mpt3sas_config_get_sas_iounit_pg0 - obtain sas iounit page 0
1423  * @ioc: per adapter object
1424  * @mpi_reply: reply mf payload returned from firmware
1425  * @config_page: contents of the config page
1426  * @sz: size of buffer passed in config_page
1427  * Context: sleep.
1428  *
1429  * Calling function should call config_get_number_hba_phys prior to
1430  * this function, so enough memory is allocated for config_page.
1431  *
1432  * Return: 0 for success, non-zero for failure.
1433  */
1434 int
1435 mpt3sas_config_get_sas_iounit_pg0(struct MPT3SAS_ADAPTER *ioc,
1436         Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage0_t *config_page,
1437         u16 sz)
1438 {
1439         Mpi2ConfigRequest_t mpi_request;
1440         int r;
1441
1442         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1443         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1444         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1445         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1446         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1447         mpi_request.Header.PageNumber = 0;
1448         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
1449         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1450         r = _config_request(ioc, &mpi_request, mpi_reply,
1451             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1452         if (r)
1453                 goto out;
1454
1455         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1456         r = _config_request(ioc, &mpi_request, mpi_reply,
1457             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1458  out:
1459         return r;
1460 }
1461
1462 /**
1463  * mpt3sas_config_get_sas_iounit_pg1 - obtain sas iounit page 1
1464  * @ioc: per adapter object
1465  * @mpi_reply: reply mf payload returned from firmware
1466  * @config_page: contents of the config page
1467  * @sz: size of buffer passed in config_page
1468  * Context: sleep.
1469  *
1470  * Calling function should call config_get_number_hba_phys prior to
1471  * this function, so enough memory is allocated for config_page.
1472  *
1473  * Return: 0 for success, non-zero for failure.
1474  */
1475 int
1476 mpt3sas_config_get_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1477         Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1478         u16 sz)
1479 {
1480         Mpi2ConfigRequest_t mpi_request;
1481         int r;
1482
1483         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1484         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1485         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1486         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1487         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1488         mpi_request.Header.PageNumber = 1;
1489         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1490         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1491         r = _config_request(ioc, &mpi_request, mpi_reply,
1492             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1493         if (r)
1494                 goto out;
1495
1496         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1497         r = _config_request(ioc, &mpi_request, mpi_reply,
1498             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1499  out:
1500         return r;
1501 }
1502
1503 /**
1504  * mpt3sas_config_set_sas_iounit_pg1 - send sas iounit page 1
1505  * @ioc: per adapter object
1506  * @mpi_reply: reply mf payload returned from firmware
1507  * @config_page: contents of the config page
1508  * @sz: size of buffer passed in config_page
1509  * Context: sleep.
1510  *
1511  * Calling function should call config_get_number_hba_phys prior to
1512  * this function, so enough memory is allocated for config_page.
1513  *
1514  * Return: 0 for success, non-zero for failure.
1515  */
1516 int
1517 mpt3sas_config_set_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
1518         Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
1519         u16 sz)
1520 {
1521         Mpi2ConfigRequest_t mpi_request;
1522         int r;
1523
1524         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1525         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1526         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1527         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1528         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1529         mpi_request.Header.PageNumber = 1;
1530         mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
1531         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1532         r = _config_request(ioc, &mpi_request, mpi_reply,
1533             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1534         if (r)
1535                 goto out;
1536
1537         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
1538         _config_request(ioc, &mpi_request, mpi_reply,
1539             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1540         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
1541         r = _config_request(ioc, &mpi_request, mpi_reply,
1542             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1543  out:
1544         return r;
1545 }
1546
1547 /**
1548  * mpt3sas_config_get_expander_pg0 - obtain expander page 0
1549  * @ioc: per adapter object
1550  * @mpi_reply: reply mf payload returned from firmware
1551  * @config_page: contents of the config page
1552  * @form: GET_NEXT_HANDLE or HANDLE
1553  * @handle: expander handle
1554  * Context: sleep.
1555  *
1556  * Return: 0 for success, non-zero for failure.
1557  */
1558 int
1559 mpt3sas_config_get_expander_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1560         *mpi_reply, Mpi2ExpanderPage0_t *config_page, u32 form, u32 handle)
1561 {
1562         Mpi2ConfigRequest_t mpi_request;
1563         int r;
1564
1565         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1566         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1567         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1568         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1569         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1570         mpi_request.Header.PageNumber = 0;
1571         mpi_request.Header.PageVersion = MPI2_SASEXPANDER0_PAGEVERSION;
1572         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1573         r = _config_request(ioc, &mpi_request, mpi_reply,
1574             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1575         if (r)
1576                 goto out;
1577
1578         mpi_request.PageAddress = cpu_to_le32(form | handle);
1579         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1580         r = _config_request(ioc, &mpi_request, mpi_reply,
1581             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1582             sizeof(*config_page));
1583  out:
1584         return r;
1585 }
1586
1587 /**
1588  * mpt3sas_config_get_expander_pg1 - obtain expander page 1
1589  * @ioc: per adapter object
1590  * @mpi_reply: reply mf payload returned from firmware
1591  * @config_page: contents of the config page
1592  * @phy_number: phy number
1593  * @handle: expander handle
1594  * Context: sleep.
1595  *
1596  * Return: 0 for success, non-zero for failure.
1597  */
1598 int
1599 mpt3sas_config_get_expander_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1600         *mpi_reply, Mpi2ExpanderPage1_t *config_page, u32 phy_number,
1601         u16 handle)
1602 {
1603         Mpi2ConfigRequest_t mpi_request;
1604         int r;
1605
1606         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1607         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1608         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1609         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1610         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1611         mpi_request.Header.PageNumber = 1;
1612         mpi_request.Header.PageVersion = MPI2_SASEXPANDER1_PAGEVERSION;
1613         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1614         r = _config_request(ioc, &mpi_request, mpi_reply,
1615             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1616         if (r)
1617                 goto out;
1618
1619         mpi_request.PageAddress =
1620             cpu_to_le32(MPI2_SAS_EXPAND_PGAD_FORM_HNDL_PHY_NUM |
1621             (phy_number << MPI2_SAS_EXPAND_PGAD_PHYNUM_SHIFT) | handle);
1622         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1623         r = _config_request(ioc, &mpi_request, mpi_reply,
1624             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1625             sizeof(*config_page));
1626  out:
1627         return r;
1628 }
1629
1630 /**
1631  * mpt3sas_config_get_enclosure_pg0 - obtain enclosure page 0
1632  * @ioc: per adapter object
1633  * @mpi_reply: reply mf payload returned from firmware
1634  * @config_page: contents of the config page
1635  * @form: GET_NEXT_HANDLE or HANDLE
1636  * @handle: expander handle
1637  * Context: sleep.
1638  *
1639  * Return: 0 for success, non-zero for failure.
1640  */
1641 int
1642 mpt3sas_config_get_enclosure_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1643         *mpi_reply, Mpi2SasEnclosurePage0_t *config_page, u32 form, u32 handle)
1644 {
1645         Mpi2ConfigRequest_t mpi_request;
1646         int r;
1647
1648         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1649         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1650         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1651         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1652         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_ENCLOSURE;
1653         mpi_request.Header.PageNumber = 0;
1654         mpi_request.Header.PageVersion = MPI2_SASENCLOSURE0_PAGEVERSION;
1655         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1656         r = _config_request(ioc, &mpi_request, mpi_reply,
1657             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1658         if (r)
1659                 goto out;
1660
1661         mpi_request.PageAddress = cpu_to_le32(form | handle);
1662         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1663         r = _config_request(ioc, &mpi_request, mpi_reply,
1664             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1665             sizeof(*config_page));
1666  out:
1667         return r;
1668 }
1669
1670 /**
1671  * mpt3sas_config_get_phy_pg0 - obtain phy page 0
1672  * @ioc: per adapter object
1673  * @mpi_reply: reply mf payload returned from firmware
1674  * @config_page: contents of the config page
1675  * @phy_number: phy number
1676  * Context: sleep.
1677  *
1678  * Return: 0 for success, non-zero for failure.
1679  */
1680 int
1681 mpt3sas_config_get_phy_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1682         *mpi_reply, Mpi2SasPhyPage0_t *config_page, u32 phy_number)
1683 {
1684         Mpi2ConfigRequest_t mpi_request;
1685         int r;
1686
1687         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1688         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1689         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1690         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1691         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1692         mpi_request.Header.PageNumber = 0;
1693         mpi_request.Header.PageVersion = MPI2_SASPHY0_PAGEVERSION;
1694         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1695         r = _config_request(ioc, &mpi_request, mpi_reply,
1696             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1697         if (r)
1698                 goto out;
1699
1700         mpi_request.PageAddress =
1701             cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1702         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1703         r = _config_request(ioc, &mpi_request, mpi_reply,
1704             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1705             sizeof(*config_page));
1706  out:
1707         return r;
1708 }
1709
1710 /**
1711  * mpt3sas_config_get_phy_pg1 - obtain phy page 1
1712  * @ioc: per adapter object
1713  * @mpi_reply: reply mf payload returned from firmware
1714  * @config_page: contents of the config page
1715  * @phy_number: phy number
1716  * Context: sleep.
1717  *
1718  * Return: 0 for success, non-zero for failure.
1719  */
1720 int
1721 mpt3sas_config_get_phy_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1722         *mpi_reply, Mpi2SasPhyPage1_t *config_page, u32 phy_number)
1723 {
1724         Mpi2ConfigRequest_t mpi_request;
1725         int r;
1726
1727         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1728         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1729         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1730         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1731         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY;
1732         mpi_request.Header.PageNumber = 1;
1733         mpi_request.Header.PageVersion = MPI2_SASPHY1_PAGEVERSION;
1734         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1735         r = _config_request(ioc, &mpi_request, mpi_reply,
1736             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1737         if (r)
1738                 goto out;
1739
1740         mpi_request.PageAddress =
1741             cpu_to_le32(MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | phy_number);
1742         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1743         r = _config_request(ioc, &mpi_request, mpi_reply,
1744             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1745             sizeof(*config_page));
1746  out:
1747         return r;
1748 }
1749
1750 /**
1751  * mpt3sas_config_get_raid_volume_pg1 - obtain raid volume page 1
1752  * @ioc: per adapter object
1753  * @mpi_reply: reply mf payload returned from firmware
1754  * @config_page: contents of the config page
1755  * @form: GET_NEXT_HANDLE or HANDLE
1756  * @handle: volume handle
1757  * Context: sleep.
1758  *
1759  * Return: 0 for success, non-zero for failure.
1760  */
1761 int
1762 mpt3sas_config_get_raid_volume_pg1(struct MPT3SAS_ADAPTER *ioc,
1763         Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage1_t *config_page, u32 form,
1764         u32 handle)
1765 {
1766         Mpi2ConfigRequest_t mpi_request;
1767         int r;
1768
1769         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1770         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1771         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1772         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1773         mpi_request.Header.PageNumber = 1;
1774         mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE1_PAGEVERSION;
1775         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1776         r = _config_request(ioc, &mpi_request, mpi_reply,
1777             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1778         if (r)
1779                 goto out;
1780
1781         mpi_request.PageAddress = cpu_to_le32(form | handle);
1782         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1783         r = _config_request(ioc, &mpi_request, mpi_reply,
1784             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1785             sizeof(*config_page));
1786  out:
1787         return r;
1788 }
1789
1790 /**
1791  * mpt3sas_config_get_number_pds - obtain number of phys disk assigned to volume
1792  * @ioc: per adapter object
1793  * @handle: volume handle
1794  * @num_pds: returns pds count
1795  * Context: sleep.
1796  *
1797  * Return: 0 for success, non-zero for failure.
1798  */
1799 int
1800 mpt3sas_config_get_number_pds(struct MPT3SAS_ADAPTER *ioc, u16 handle,
1801         u8 *num_pds)
1802 {
1803         Mpi2ConfigRequest_t mpi_request;
1804         Mpi2RaidVolPage0_t config_page;
1805         Mpi2ConfigReply_t mpi_reply;
1806         int r;
1807         u16 ioc_status;
1808
1809         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1810         *num_pds = 0;
1811         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1812         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1813         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1814         mpi_request.Header.PageNumber = 0;
1815         mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1816         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1817         r = _config_request(ioc, &mpi_request, &mpi_reply,
1818             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1819         if (r)
1820                 goto out;
1821
1822         mpi_request.PageAddress =
1823             cpu_to_le32(MPI2_RAID_VOLUME_PGAD_FORM_HANDLE | handle);
1824         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1825         r = _config_request(ioc, &mpi_request, &mpi_reply,
1826             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, &config_page,
1827             sizeof(Mpi2RaidVolPage0_t));
1828         if (!r) {
1829                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1830                     MPI2_IOCSTATUS_MASK;
1831                 if (ioc_status == MPI2_IOCSTATUS_SUCCESS)
1832                         *num_pds = config_page.NumPhysDisks;
1833         }
1834
1835  out:
1836         return r;
1837 }
1838
1839 /**
1840  * mpt3sas_config_get_raid_volume_pg0 - obtain raid volume page 0
1841  * @ioc: per adapter object
1842  * @mpi_reply: reply mf payload returned from firmware
1843  * @config_page: contents of the config page
1844  * @form: GET_NEXT_HANDLE or HANDLE
1845  * @handle: volume handle
1846  * @sz: size of buffer passed in config_page
1847  * Context: sleep.
1848  *
1849  * Return: 0 for success, non-zero for failure.
1850  */
1851 int
1852 mpt3sas_config_get_raid_volume_pg0(struct MPT3SAS_ADAPTER *ioc,
1853         Mpi2ConfigReply_t *mpi_reply, Mpi2RaidVolPage0_t *config_page, u32 form,
1854         u32 handle, u16 sz)
1855 {
1856         Mpi2ConfigRequest_t mpi_request;
1857         int r;
1858
1859         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1860         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1861         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1862         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1863         mpi_request.Header.PageNumber = 0;
1864         mpi_request.Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1865         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1866         r = _config_request(ioc, &mpi_request, mpi_reply,
1867             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1868         if (r)
1869                 goto out;
1870
1871         mpi_request.PageAddress = cpu_to_le32(form | handle);
1872         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1873         r = _config_request(ioc, &mpi_request, mpi_reply,
1874             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
1875  out:
1876         return r;
1877 }
1878
1879 /**
1880  * mpt3sas_config_get_phys_disk_pg0 - obtain phys disk page 0
1881  * @ioc: per adapter object
1882  * @mpi_reply: reply mf payload returned from firmware
1883  * @config_page: contents of the config page
1884  * @form: GET_NEXT_PHYSDISKNUM, PHYSDISKNUM, DEVHANDLE
1885  * @form_specific: specific to the form
1886  * Context: sleep.
1887  *
1888  * Return: 0 for success, non-zero for failure.
1889  */
1890 int
1891 mpt3sas_config_get_phys_disk_pg0(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
1892         *mpi_reply, Mpi2RaidPhysDiskPage0_t *config_page, u32 form,
1893         u32 form_specific)
1894 {
1895         Mpi2ConfigRequest_t mpi_request;
1896         int r;
1897
1898         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1899         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1900         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1901         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK;
1902         mpi_request.Header.PageNumber = 0;
1903         mpi_request.Header.PageVersion = MPI2_RAIDPHYSDISKPAGE0_PAGEVERSION;
1904         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1905         r = _config_request(ioc, &mpi_request, mpi_reply,
1906             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1907         if (r)
1908                 goto out;
1909
1910         mpi_request.PageAddress = cpu_to_le32(form | form_specific);
1911         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1912         r = _config_request(ioc, &mpi_request, mpi_reply,
1913             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1914             sizeof(*config_page));
1915  out:
1916         return r;
1917 }
1918
1919 /**
1920  * mpt3sas_config_get_driver_trigger_pg0 - obtain driver trigger page 0
1921  * @ioc: per adapter object
1922  * @mpi_reply: reply mf payload returned from firmware
1923  * @config_page: contents of the config page
1924  * Context: sleep.
1925  *
1926  * Returns 0 for success, non-zero for failure.
1927  */
1928 int
1929 mpt3sas_config_get_driver_trigger_pg0(struct MPT3SAS_ADAPTER *ioc,
1930         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage0_t *config_page)
1931 {
1932         Mpi2ConfigRequest_t mpi_request;
1933         int r;
1934
1935         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1936         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1937         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1938         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1939         mpi_request.ExtPageType =
1940             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
1941         mpi_request.Header.PageNumber = 0;
1942         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE0_PAGEVERSION;
1943         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1944         r = _config_request(ioc, &mpi_request, mpi_reply,
1945             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1946         if (r)
1947                 goto out;
1948
1949         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1950         r = _config_request(ioc, &mpi_request, mpi_reply,
1951             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1952             sizeof(*config_page));
1953  out:
1954         return r;
1955 }
1956
1957 /**
1958  * _config_set_driver_trigger_pg0 - write driver trigger page 0
1959  * @ioc: per adapter object
1960  * @mpi_reply: reply mf payload returned from firmware
1961  * @config_page: contents of the config page
1962  * Context: sleep.
1963  *
1964  * Returns 0 for success, non-zero for failure.
1965  */
1966 static int
1967 _config_set_driver_trigger_pg0(struct MPT3SAS_ADAPTER *ioc,
1968         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage0_t *config_page)
1969 {
1970         Mpi2ConfigRequest_t mpi_request;
1971         int r;
1972
1973         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
1974         mpi_request.Function = MPI2_FUNCTION_CONFIG;
1975         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1976         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
1977         mpi_request.ExtPageType =
1978             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
1979         mpi_request.Header.PageNumber = 0;
1980         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE0_PAGEVERSION;
1981         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
1982         r = _config_request(ioc, &mpi_request, mpi_reply,
1983             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
1984         if (r)
1985                 goto out;
1986
1987         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
1988         _config_request(ioc, &mpi_request, mpi_reply,
1989             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1990             sizeof(*config_page));
1991         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
1992         r = _config_request(ioc, &mpi_request, mpi_reply,
1993             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
1994             sizeof(*config_page));
1995  out:
1996         return r;
1997 }
1998
1999 /**
2000  * mpt3sas_config_update_driver_trigger_pg0 - update driver trigger page 0
2001  * @ioc: per adapter object
2002  * @trigger_flag: trigger type bit map
2003  * @set: set ot clear trigger values
2004  * Context: sleep.
2005  *
2006  * Returns 0 for success, non-zero for failure.
2007  */
2008 static int
2009 mpt3sas_config_update_driver_trigger_pg0(struct MPT3SAS_ADAPTER *ioc,
2010         u16 trigger_flag, bool set)
2011 {
2012         Mpi26DriverTriggerPage0_t tg_pg0;
2013         Mpi2ConfigReply_t mpi_reply;
2014         int rc;
2015         u16 flags, ioc_status;
2016
2017         rc = mpt3sas_config_get_driver_trigger_pg0(ioc, &mpi_reply, &tg_pg0);
2018         if (rc)
2019                 return rc;
2020         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2021             MPI2_IOCSTATUS_MASK;
2022         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2023                 dcprintk(ioc,
2024                     ioc_err(ioc,
2025                     "%s: Failed to get trigger pg0, ioc_status(0x%04x)\n",
2026                     __func__, ioc_status));
2027                 return -EFAULT;
2028         }
2029
2030         if (set)
2031                 flags = le16_to_cpu(tg_pg0.TriggerFlags) | trigger_flag;
2032         else
2033                 flags = le16_to_cpu(tg_pg0.TriggerFlags) & ~trigger_flag;
2034
2035         tg_pg0.TriggerFlags = cpu_to_le16(flags);
2036
2037         rc = _config_set_driver_trigger_pg0(ioc, &mpi_reply, &tg_pg0);
2038         if (rc)
2039                 return rc;
2040         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2041             MPI2_IOCSTATUS_MASK;
2042         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2043                 dcprintk(ioc,
2044                     ioc_err(ioc,
2045                     "%s: Failed to update trigger pg0, ioc_status(0x%04x)\n",
2046                     __func__, ioc_status));
2047                 return -EFAULT;
2048         }
2049
2050         return 0;
2051 }
2052
2053 /**
2054  * mpt3sas_config_get_driver_trigger_pg1 - obtain driver trigger page 1
2055  * @ioc: per adapter object
2056  * @mpi_reply: reply mf payload returned from firmware
2057  * @config_page: contents of the config page
2058  * Context: sleep.
2059  *
2060  * Returns 0 for success, non-zero for failure.
2061  */
2062 int
2063 mpt3sas_config_get_driver_trigger_pg1(struct MPT3SAS_ADAPTER *ioc,
2064         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage1_t *config_page)
2065 {
2066         Mpi2ConfigRequest_t mpi_request;
2067         int r;
2068
2069         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2070         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2071         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2072         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2073         mpi_request.ExtPageType =
2074             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2075         mpi_request.Header.PageNumber = 1;
2076         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE1_PAGEVERSION;
2077         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2078         r = _config_request(ioc, &mpi_request, mpi_reply,
2079             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2080         if (r)
2081                 goto out;
2082
2083         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
2084         r = _config_request(ioc, &mpi_request, mpi_reply,
2085             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2086             sizeof(*config_page));
2087  out:
2088         return r;
2089 }
2090
2091 /**
2092  * _config_set_driver_trigger_pg1 - write driver trigger page 1
2093  * @ioc: per adapter object
2094  * @mpi_reply: reply mf payload returned from firmware
2095  * @config_page: contents of the config page
2096  * Context: sleep.
2097  *
2098  * Returns 0 for success, non-zero for failure.
2099  */
2100 static int
2101 _config_set_driver_trigger_pg1(struct MPT3SAS_ADAPTER *ioc,
2102         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage1_t *config_page)
2103 {
2104         Mpi2ConfigRequest_t mpi_request;
2105         int r;
2106
2107         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2108         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2109         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2110         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2111         mpi_request.ExtPageType =
2112             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2113         mpi_request.Header.PageNumber = 1;
2114         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE1_PAGEVERSION;
2115         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2116         r = _config_request(ioc, &mpi_request, mpi_reply,
2117             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2118         if (r)
2119                 goto out;
2120
2121         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
2122         _config_request(ioc, &mpi_request, mpi_reply,
2123             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2124             sizeof(*config_page));
2125         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
2126         r = _config_request(ioc, &mpi_request, mpi_reply,
2127             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2128             sizeof(*config_page));
2129  out:
2130         return r;
2131 }
2132
2133 /**
2134  * mpt3sas_config_update_driver_trigger_pg1 - update driver trigger page 1
2135  * @ioc: per adapter object
2136  * @master_tg: Master trigger bit map
2137  * @set: set ot clear trigger values
2138  * Context: sleep.
2139  *
2140  * Returns 0 for success, non-zero for failure.
2141  */
2142 int
2143 mpt3sas_config_update_driver_trigger_pg1(struct MPT3SAS_ADAPTER *ioc,
2144         struct SL_WH_MASTER_TRIGGER_T *master_tg, bool set)
2145 {
2146         Mpi26DriverTriggerPage1_t tg_pg1;
2147         Mpi2ConfigReply_t mpi_reply;
2148         int rc;
2149         u16 ioc_status;
2150
2151         rc = mpt3sas_config_update_driver_trigger_pg0(ioc,
2152             MPI26_DRIVER_TRIGGER0_FLAG_MASTER_TRIGGER_VALID, set);
2153         if (rc)
2154                 return rc;
2155
2156         rc = mpt3sas_config_get_driver_trigger_pg1(ioc, &mpi_reply, &tg_pg1);
2157         if (rc)
2158                 goto out;
2159
2160         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2161             MPI2_IOCSTATUS_MASK;
2162         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2163                 dcprintk(ioc,
2164                     ioc_err(ioc,
2165                     "%s: Failed to get trigger pg1, ioc_status(0x%04x)\n",
2166                     __func__, ioc_status));
2167                 rc = -EFAULT;
2168                 goto out;
2169         }
2170
2171         if (set) {
2172                 tg_pg1.NumMasterTrigger = cpu_to_le16(1);
2173                 tg_pg1.MasterTriggers[0].MasterTriggerFlags = cpu_to_le32(
2174                     master_tg->MasterData);
2175         } else {
2176                 tg_pg1.NumMasterTrigger = 0;
2177                 tg_pg1.MasterTriggers[0].MasterTriggerFlags = 0;
2178         }
2179
2180         rc = _config_set_driver_trigger_pg1(ioc, &mpi_reply, &tg_pg1);
2181         if (rc)
2182                 goto out;
2183
2184         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2185             MPI2_IOCSTATUS_MASK;
2186         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2187                 dcprintk(ioc,
2188                     ioc_err(ioc,
2189                     "%s: Failed to get trigger pg1, ioc_status(0x%04x)\n",
2190                     __func__, ioc_status));
2191                 rc = -EFAULT;
2192                 goto out;
2193         }
2194
2195         return 0;
2196
2197 out:
2198         mpt3sas_config_update_driver_trigger_pg0(ioc,
2199             MPI26_DRIVER_TRIGGER0_FLAG_MASTER_TRIGGER_VALID, !set);
2200
2201         return rc;
2202 }
2203
2204 /**
2205  * mpt3sas_config_get_driver_trigger_pg2 - obtain driver trigger page 2
2206  * @ioc: per adapter object
2207  * @mpi_reply: reply mf payload returned from firmware
2208  * @config_page: contents of the config page
2209  * Context: sleep.
2210  *
2211  * Returns 0 for success, non-zero for failure.
2212  */
2213 int
2214 mpt3sas_config_get_driver_trigger_pg2(struct MPT3SAS_ADAPTER *ioc,
2215         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage2_t *config_page)
2216 {
2217         Mpi2ConfigRequest_t mpi_request;
2218         int r;
2219
2220         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2221         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2222         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2223         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2224         mpi_request.ExtPageType =
2225             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2226         mpi_request.Header.PageNumber = 2;
2227         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE2_PAGEVERSION;
2228         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2229         r = _config_request(ioc, &mpi_request, mpi_reply,
2230             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2231         if (r)
2232                 goto out;
2233
2234         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
2235         r = _config_request(ioc, &mpi_request, mpi_reply,
2236             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2237             sizeof(*config_page));
2238  out:
2239         return r;
2240 }
2241
2242 /**
2243  * _config_set_driver_trigger_pg2 - write driver trigger page 2
2244  * @ioc: per adapter object
2245  * @mpi_reply: reply mf payload returned from firmware
2246  * @config_page: contents of the config page
2247  * Context: sleep.
2248  *
2249  * Returns 0 for success, non-zero for failure.
2250  */
2251 static int
2252 _config_set_driver_trigger_pg2(struct MPT3SAS_ADAPTER *ioc,
2253         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage2_t *config_page)
2254 {
2255         Mpi2ConfigRequest_t mpi_request;
2256         int r;
2257
2258         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2259         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2260         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2261         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2262         mpi_request.ExtPageType =
2263             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2264         mpi_request.Header.PageNumber = 2;
2265         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE2_PAGEVERSION;
2266         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2267         r = _config_request(ioc, &mpi_request, mpi_reply,
2268             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2269         if (r)
2270                 goto out;
2271
2272         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
2273         _config_request(ioc, &mpi_request, mpi_reply,
2274             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2275             sizeof(*config_page));
2276         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
2277         r = _config_request(ioc, &mpi_request, mpi_reply,
2278             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2279             sizeof(*config_page));
2280  out:
2281         return r;
2282 }
2283
2284 /**
2285  * mpt3sas_config_update_driver_trigger_pg2 - update driver trigger page 2
2286  * @ioc: per adapter object
2287  * @event_tg: list of Event Triggers
2288  * @set: set ot clear trigger values
2289  * Context: sleep.
2290  *
2291  * Returns 0 for success, non-zero for failure.
2292  */
2293 int
2294 mpt3sas_config_update_driver_trigger_pg2(struct MPT3SAS_ADAPTER *ioc,
2295         struct SL_WH_EVENT_TRIGGERS_T *event_tg, bool set)
2296 {
2297         Mpi26DriverTriggerPage2_t tg_pg2;
2298         Mpi2ConfigReply_t mpi_reply;
2299         int rc, i, count;
2300         u16 ioc_status;
2301
2302         rc = mpt3sas_config_update_driver_trigger_pg0(ioc,
2303             MPI26_DRIVER_TRIGGER0_FLAG_MPI_EVENT_TRIGGER_VALID, set);
2304         if (rc)
2305                 return rc;
2306
2307         rc = mpt3sas_config_get_driver_trigger_pg2(ioc, &mpi_reply, &tg_pg2);
2308         if (rc)
2309                 goto out;
2310
2311         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2312             MPI2_IOCSTATUS_MASK;
2313         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2314                 dcprintk(ioc,
2315                     ioc_err(ioc,
2316                     "%s: Failed to get trigger pg2, ioc_status(0x%04x)\n",
2317                     __func__, ioc_status));
2318                 rc = -EFAULT;
2319                 goto out;
2320         }
2321
2322         if (set) {
2323                 count = event_tg->ValidEntries;
2324                 tg_pg2.NumMPIEventTrigger = cpu_to_le16(count);
2325                 for (i = 0; i < count; i++) {
2326                         tg_pg2.MPIEventTriggers[i].MPIEventCode =
2327                             cpu_to_le16(
2328                             event_tg->EventTriggerEntry[i].EventValue);
2329                         tg_pg2.MPIEventTriggers[i].MPIEventCodeSpecific =
2330                             cpu_to_le16(
2331                             event_tg->EventTriggerEntry[i].LogEntryQualifier);
2332                 }
2333         } else {
2334                 tg_pg2.NumMPIEventTrigger = 0;
2335                 memset(&tg_pg2.MPIEventTriggers[0], 0,
2336                     NUM_VALID_ENTRIES * sizeof(
2337                     MPI26_DRIVER_MPI_EVENT_TRIGGER_ENTRY));
2338         }
2339
2340         rc = _config_set_driver_trigger_pg2(ioc, &mpi_reply, &tg_pg2);
2341         if (rc)
2342                 goto out;
2343
2344         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2345             MPI2_IOCSTATUS_MASK;
2346         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2347                 dcprintk(ioc,
2348                     ioc_err(ioc,
2349                     "%s: Failed to get trigger pg2, ioc_status(0x%04x)\n",
2350                     __func__, ioc_status));
2351                 rc = -EFAULT;
2352                 goto out;
2353         }
2354
2355         return 0;
2356
2357 out:
2358         mpt3sas_config_update_driver_trigger_pg0(ioc,
2359             MPI26_DRIVER_TRIGGER0_FLAG_MPI_EVENT_TRIGGER_VALID, !set);
2360
2361         return rc;
2362 }
2363
2364 /**
2365  * mpt3sas_config_get_driver_trigger_pg3 - obtain driver trigger page 3
2366  * @ioc: per adapter object
2367  * @mpi_reply: reply mf payload returned from firmware
2368  * @config_page: contents of the config page
2369  * Context: sleep.
2370  *
2371  * Returns 0 for success, non-zero for failure.
2372  */
2373 int
2374 mpt3sas_config_get_driver_trigger_pg3(struct MPT3SAS_ADAPTER *ioc,
2375         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage3_t *config_page)
2376 {
2377         Mpi2ConfigRequest_t mpi_request;
2378         int r;
2379
2380         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2381         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2382         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2383         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2384         mpi_request.ExtPageType =
2385             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2386         mpi_request.Header.PageNumber = 3;
2387         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE3_PAGEVERSION;
2388         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2389         r = _config_request(ioc, &mpi_request, mpi_reply,
2390             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2391         if (r)
2392                 goto out;
2393
2394         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
2395         r = _config_request(ioc, &mpi_request, mpi_reply,
2396             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2397             sizeof(*config_page));
2398  out:
2399         return r;
2400 }
2401
2402 /**
2403  * _config_set_driver_trigger_pg3 - write driver trigger page 3
2404  * @ioc: per adapter object
2405  * @mpi_reply: reply mf payload returned from firmware
2406  * @config_page: contents of the config page
2407  * Context: sleep.
2408  *
2409  * Returns 0 for success, non-zero for failure.
2410  */
2411 static int
2412 _config_set_driver_trigger_pg3(struct MPT3SAS_ADAPTER *ioc,
2413         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage3_t *config_page)
2414 {
2415         Mpi2ConfigRequest_t mpi_request;
2416         int r;
2417
2418         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2419         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2420         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2421         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2422         mpi_request.ExtPageType =
2423             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2424         mpi_request.Header.PageNumber = 3;
2425         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE3_PAGEVERSION;
2426         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2427         r = _config_request(ioc, &mpi_request, mpi_reply,
2428             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2429         if (r)
2430                 goto out;
2431
2432         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
2433         _config_request(ioc, &mpi_request, mpi_reply,
2434             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2435             sizeof(*config_page));
2436         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
2437         r = _config_request(ioc, &mpi_request, mpi_reply,
2438             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2439             sizeof(*config_page));
2440  out:
2441         return r;
2442 }
2443
2444 /**
2445  * mpt3sas_config_update_driver_trigger_pg3 - update driver trigger page 3
2446  * @ioc: per adapter object
2447  * @scsi_tg: scsi trigger list
2448  * @set: set ot clear trigger values
2449  * Context: sleep.
2450  *
2451  * Returns 0 for success, non-zero for failure.
2452  */
2453 int
2454 mpt3sas_config_update_driver_trigger_pg3(struct MPT3SAS_ADAPTER *ioc,
2455         struct SL_WH_SCSI_TRIGGERS_T *scsi_tg, bool set)
2456 {
2457         Mpi26DriverTriggerPage3_t tg_pg3;
2458         Mpi2ConfigReply_t mpi_reply;
2459         int rc, i, count;
2460         u16 ioc_status;
2461
2462         rc = mpt3sas_config_update_driver_trigger_pg0(ioc,
2463             MPI26_DRIVER_TRIGGER0_FLAG_SCSI_SENSE_TRIGGER_VALID, set);
2464         if (rc)
2465                 return rc;
2466
2467         rc = mpt3sas_config_get_driver_trigger_pg3(ioc, &mpi_reply, &tg_pg3);
2468         if (rc)
2469                 goto out;
2470
2471         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2472             MPI2_IOCSTATUS_MASK;
2473         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2474                 dcprintk(ioc,
2475                     ioc_err(ioc,
2476                     "%s: Failed to get trigger pg3, ioc_status(0x%04x)\n",
2477                     __func__, ioc_status));
2478                 return -EFAULT;
2479         }
2480
2481         if (set) {
2482                 count = scsi_tg->ValidEntries;
2483                 tg_pg3.NumSCSISenseTrigger = cpu_to_le16(count);
2484                 for (i = 0; i < count; i++) {
2485                         tg_pg3.SCSISenseTriggers[i].ASCQ =
2486                             scsi_tg->SCSITriggerEntry[i].ASCQ;
2487                         tg_pg3.SCSISenseTriggers[i].ASC =
2488                             scsi_tg->SCSITriggerEntry[i].ASC;
2489                         tg_pg3.SCSISenseTriggers[i].SenseKey =
2490                             scsi_tg->SCSITriggerEntry[i].SenseKey;
2491                 }
2492         } else {
2493                 tg_pg3.NumSCSISenseTrigger = 0;
2494                 memset(&tg_pg3.SCSISenseTriggers[0], 0,
2495                     NUM_VALID_ENTRIES * sizeof(
2496                     MPI26_DRIVER_SCSI_SENSE_TRIGGER_ENTRY));
2497         }
2498
2499         rc = _config_set_driver_trigger_pg3(ioc, &mpi_reply, &tg_pg3);
2500         if (rc)
2501                 goto out;
2502
2503         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2504             MPI2_IOCSTATUS_MASK;
2505         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2506                 dcprintk(ioc,
2507                     ioc_err(ioc,
2508                     "%s: Failed to get trigger pg3, ioc_status(0x%04x)\n",
2509                      __func__, ioc_status));
2510                 return -EFAULT;
2511         }
2512
2513         return 0;
2514 out:
2515         mpt3sas_config_update_driver_trigger_pg0(ioc,
2516             MPI26_DRIVER_TRIGGER0_FLAG_SCSI_SENSE_TRIGGER_VALID, !set);
2517
2518         return rc;
2519 }
2520
2521 /**
2522  * mpt3sas_config_get_driver_trigger_pg4 - obtain driver trigger page 4
2523  * @ioc: per adapter object
2524  * @mpi_reply: reply mf payload returned from firmware
2525  * @config_page: contents of the config page
2526  * Context: sleep.
2527  *
2528  * Returns 0 for success, non-zero for failure.
2529  */
2530 int
2531 mpt3sas_config_get_driver_trigger_pg4(struct MPT3SAS_ADAPTER *ioc,
2532         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage4_t *config_page)
2533 {
2534         Mpi2ConfigRequest_t mpi_request;
2535         int r;
2536
2537         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2538         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2539         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2540         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2541         mpi_request.ExtPageType =
2542             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2543         mpi_request.Header.PageNumber = 4;
2544         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE4_PAGEVERSION;
2545         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2546         r = _config_request(ioc, &mpi_request, mpi_reply,
2547             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2548         if (r)
2549                 goto out;
2550
2551         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
2552         r = _config_request(ioc, &mpi_request, mpi_reply,
2553             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2554             sizeof(*config_page));
2555  out:
2556         return r;
2557 }
2558
2559 /**
2560  * _config_set_driver_trigger_pg4 - write driver trigger page 4
2561  * @ioc: per adapter object
2562  * @mpi_reply: reply mf payload returned from firmware
2563  * @config_page: contents of the config page
2564  * Context: sleep.
2565  *
2566  * Returns 0 for success, non-zero for failure.
2567  */
2568 static int
2569 _config_set_driver_trigger_pg4(struct MPT3SAS_ADAPTER *ioc,
2570         Mpi2ConfigReply_t *mpi_reply, Mpi26DriverTriggerPage4_t *config_page)
2571 {
2572         Mpi2ConfigRequest_t mpi_request;
2573         int r;
2574
2575         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2576         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2577         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2578         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2579         mpi_request.ExtPageType =
2580             MPI2_CONFIG_EXTPAGETYPE_DRIVER_PERSISTENT_TRIGGER;
2581         mpi_request.Header.PageNumber = 4;
2582         mpi_request.Header.PageVersion = MPI26_DRIVER_TRIGGER_PAGE4_PAGEVERSION;
2583         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2584         r = _config_request(ioc, &mpi_request, mpi_reply,
2585             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2586         if (r)
2587                 goto out;
2588
2589         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
2590         _config_request(ioc, &mpi_request, mpi_reply,
2591             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2592             sizeof(*config_page));
2593         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
2594         r = _config_request(ioc, &mpi_request, mpi_reply,
2595             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2596             sizeof(*config_page));
2597  out:
2598         return r;
2599 }
2600
2601 /**
2602  * mpt3sas_config_update_driver_trigger_pg4 - update driver trigger page 4
2603  * @ioc: per adapter object
2604  * @mpi_tg: mpi trigger list
2605  * @set: set ot clear trigger values
2606  * Context: sleep.
2607  *
2608  * Returns 0 for success, non-zero for failure.
2609  */
2610 int
2611 mpt3sas_config_update_driver_trigger_pg4(struct MPT3SAS_ADAPTER *ioc,
2612         struct SL_WH_MPI_TRIGGERS_T *mpi_tg, bool set)
2613 {
2614         Mpi26DriverTriggerPage4_t tg_pg4;
2615         Mpi2ConfigReply_t mpi_reply;
2616         int rc, i, count;
2617         u16 ioc_status;
2618
2619         rc = mpt3sas_config_update_driver_trigger_pg0(ioc,
2620             MPI26_DRIVER_TRIGGER0_FLAG_LOGINFO_TRIGGER_VALID, set);
2621         if (rc)
2622                 return rc;
2623
2624         rc = mpt3sas_config_get_driver_trigger_pg4(ioc, &mpi_reply, &tg_pg4);
2625         if (rc)
2626                 goto out;
2627
2628         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2629             MPI2_IOCSTATUS_MASK;
2630         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2631                 dcprintk(ioc,
2632                     ioc_err(ioc,
2633                     "%s: Failed to get trigger pg4, ioc_status(0x%04x)\n",
2634                     __func__, ioc_status));
2635                 rc = -EFAULT;
2636                 goto out;
2637         }
2638
2639         if (set) {
2640                 count = mpi_tg->ValidEntries;
2641                 tg_pg4.NumIOCStatusLogInfoTrigger = cpu_to_le16(count);
2642                 for (i = 0; i < count; i++) {
2643                         tg_pg4.IOCStatusLoginfoTriggers[i].IOCStatus =
2644                             cpu_to_le16(mpi_tg->MPITriggerEntry[i].IOCStatus);
2645                         tg_pg4.IOCStatusLoginfoTriggers[i].LogInfo =
2646                             cpu_to_le32(mpi_tg->MPITriggerEntry[i].IocLogInfo);
2647                 }
2648         } else {
2649                 tg_pg4.NumIOCStatusLogInfoTrigger = 0;
2650                 memset(&tg_pg4.IOCStatusLoginfoTriggers[0], 0,
2651                     NUM_VALID_ENTRIES * sizeof(
2652                     MPI26_DRIVER_IOCSTATUS_LOGINFO_TRIGGER_ENTRY));
2653         }
2654
2655         rc = _config_set_driver_trigger_pg4(ioc, &mpi_reply, &tg_pg4);
2656         if (rc)
2657                 goto out;
2658
2659         ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2660             MPI2_IOCSTATUS_MASK;
2661         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
2662                 dcprintk(ioc,
2663                     ioc_err(ioc,
2664                     "%s: Failed to get trigger pg4, ioc_status(0x%04x)\n",
2665                     __func__, ioc_status));
2666                 rc = -EFAULT;
2667                 goto out;
2668         }
2669
2670         return 0;
2671
2672 out:
2673         mpt3sas_config_update_driver_trigger_pg0(ioc,
2674             MPI26_DRIVER_TRIGGER0_FLAG_LOGINFO_TRIGGER_VALID, !set);
2675
2676         return rc;
2677 }
2678
2679 /**
2680  * mpt3sas_config_get_volume_handle - returns volume handle for give hidden
2681  * raid components
2682  * @ioc: per adapter object
2683  * @pd_handle: phys disk handle
2684  * @volume_handle: volume handle
2685  * Context: sleep.
2686  *
2687  * Return: 0 for success, non-zero for failure.
2688  */
2689 int
2690 mpt3sas_config_get_volume_handle(struct MPT3SAS_ADAPTER *ioc, u16 pd_handle,
2691         u16 *volume_handle)
2692 {
2693         Mpi2RaidConfigurationPage0_t *config_page = NULL;
2694         Mpi2ConfigRequest_t mpi_request;
2695         Mpi2ConfigReply_t mpi_reply;
2696         int r, i, config_page_sz;
2697         u16 ioc_status;
2698         int config_num;
2699         u16 element_type;
2700         u16 phys_disk_dev_handle;
2701
2702         *volume_handle = 0;
2703         memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
2704         mpi_request.Function = MPI2_FUNCTION_CONFIG;
2705         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
2706         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
2707         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG;
2708         mpi_request.Header.PageVersion = MPI2_RAIDCONFIG0_PAGEVERSION;
2709         mpi_request.Header.PageNumber = 0;
2710         ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
2711         r = _config_request(ioc, &mpi_request, &mpi_reply,
2712             MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
2713         if (r)
2714                 goto out;
2715
2716         mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
2717         config_page_sz = (le16_to_cpu(mpi_reply.ExtPageLength) * 4);
2718         config_page = kmalloc(config_page_sz, GFP_KERNEL);
2719         if (!config_page) {
2720                 r = -1;
2721                 goto out;
2722         }
2723
2724         config_num = 0xff;
2725         while (1) {
2726                 mpi_request.PageAddress = cpu_to_le32(config_num +
2727                     MPI2_RAID_PGAD_FORM_GET_NEXT_CONFIGNUM);
2728                 r = _config_request(ioc, &mpi_request, &mpi_reply,
2729                     MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
2730                     config_page_sz);
2731                 if (r)
2732                         goto out;
2733                 r = -1;
2734                 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
2735                     MPI2_IOCSTATUS_MASK;
2736                 if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
2737                         goto out;
2738                 for (i = 0; i < config_page->NumElements; i++) {
2739                         element_type = le16_to_cpu(config_page->
2740                             ConfigElement[i].ElementFlags) &
2741                             MPI2_RAIDCONFIG0_EFLAGS_MASK_ELEMENT_TYPE;
2742                         if (element_type ==
2743                             MPI2_RAIDCONFIG0_EFLAGS_VOL_PHYS_DISK_ELEMENT ||
2744                             element_type ==
2745                             MPI2_RAIDCONFIG0_EFLAGS_OCE_ELEMENT) {
2746                                 phys_disk_dev_handle =
2747                                     le16_to_cpu(config_page->ConfigElement[i].
2748                                     PhysDiskDevHandle);
2749                                 if (phys_disk_dev_handle == pd_handle) {
2750                                         *volume_handle =
2751                                             le16_to_cpu(config_page->
2752                                             ConfigElement[i].VolDevHandle);
2753                                         r = 0;
2754                                         goto out;
2755                                 }
2756                         } else if (element_type ==
2757                             MPI2_RAIDCONFIG0_EFLAGS_HOT_SPARE_ELEMENT) {
2758                                 *volume_handle = 0;
2759                                 r = 0;
2760                                 goto out;
2761                         }
2762                 }
2763                 config_num = config_page->ConfigNum;
2764         }
2765  out:
2766         kfree(config_page);
2767         return r;
2768 }
2769
2770 /**
2771  * mpt3sas_config_get_volume_wwid - returns wwid given the volume handle
2772  * @ioc: per adapter object
2773  * @volume_handle: volume handle
2774  * @wwid: volume wwid
2775  * Context: sleep.
2776  *
2777  * Return: 0 for success, non-zero for failure.
2778  */
2779 int
2780 mpt3sas_config_get_volume_wwid(struct MPT3SAS_ADAPTER *ioc, u16 volume_handle,
2781         u64 *wwid)
2782 {
2783         Mpi2ConfigReply_t mpi_reply;
2784         Mpi2RaidVolPage1_t raid_vol_pg1;
2785
2786         *wwid = 0;
2787         if (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
2788             &raid_vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE,
2789             volume_handle))) {
2790                 *wwid = le64_to_cpu(raid_vol_pg1.WWID);
2791                 return 0;
2792         } else
2793                 return -1;
2794 }