sys/dev/mps/mps_config.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2011-2015 LSI Corp.
   5  * Copyright (c) 2013-2015 Avago Technologies
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * Avago Technologies (LSI) MPT-Fusion Host Adapter FreeBSD
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 /* TODO Move headers to mpsvar */
  36 #include <sys/types.h>
  37 #include <sys/param.h>
  38 #include <sys/lock.h>
  39 #include <sys/mutex.h>
  40 #include <sys/systm.h>
  41 #include <sys/kernel.h>
  42 #include <sys/malloc.h>
  43 #include <sys/kthread.h>
  44 #include <sys/taskqueue.h>
  45 #include <sys/bus.h>
  46 #include <sys/endian.h>
  47 #include <sys/sysctl.h>
  48 #include <sys/eventhandler.h>
  49 #include <sys/uio.h>
  50 #include <machine/bus.h>
  51 #include <machine/resource.h>
  52 #include <dev/mps/mpi/mpi2_type.h>
  53 #include <dev/mps/mpi/mpi2.h>
  54 #include <dev/mps/mpi/mpi2_ioc.h>
  55 #include <dev/mps/mpi/mpi2_sas.h>
  56 #include <dev/mps/mpi/mpi2_cnfg.h>
  57 #include <dev/mps/mpi/mpi2_init.h>
  58 #include <dev/mps/mpi/mpi2_tool.h>
  59 #include <dev/mps/mps_ioctl.h>
  60 #include <dev/mps/mpsvar.h>
  61
  62 /**
  63  * mps_config_get_ioc_pg8 - obtain ioc page 8
  64  * @sc: per adapter object
  65  * @mpi_reply: reply mf payload returned from firmware
  66  * @config_page: contents of the config page
  67  * Context: sleep.
  68  *
  69  * Returns 0 for success, non-zero for failure.
  70  */
  71 int
  72 mps_config_get_ioc_pg8(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply,
  73     Mpi2IOCPage8_t *config_page)
  74 {
  75         MPI2_CONFIG_REQUEST *request;
  76         MPI2_CONFIG_REPLY *reply = NULL;
  77         struct mps_command *cm;
  78         MPI2_CONFIG_PAGE_IOC_8 *page = NULL;
  79         int error = 0;
  80         u16 ioc_status;
  81
  82         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
  83
  84         if ((cm = mps_alloc_command(sc)) == NULL) {
  85                 printf("%s: command alloc failed @ line %d\n", __func__,
  86                     __LINE__);
  87                 error = EBUSY;
  88                 goto out;
  89         }
  90         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
  91         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
  92         request->Function = MPI2_FUNCTION_CONFIG;
  93         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
  94         request->Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
  95         request->Header.PageNumber = 8;
  96         request->Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
  97         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
  98         cm->cm_data = NULL;
  99         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 100         if (cm != NULL)
 101                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 102         if (error || (reply == NULL)) {
 103                 /* FIXME */
 104                 /*
 105                  * If the request returns an error then we need to do a diag
 106                  * reset
 107                  */
 108                 printf("%s: request for header completed with error %d",
 109                     __func__, error);
 110                 error = ENXIO;
 111                 goto out;
 112         }
 113         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 114         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 115         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 116                 /* FIXME */
 117                 /*
 118                  * If the request returns an error then we need to do a diag
 119                  * reset
 120                  */
 121                 printf("%s: header read with error; iocstatus = 0x%x\n",
 122                     __func__, ioc_status);
 123                 error = ENXIO;
 124                 goto out;
 125         }
 126         /* We have to do free and alloc for the reply-free and reply-post
 127          * counters to match - Need to review the reply FIFO handling.
 128          */
 129         mps_free_command(sc, cm);
 130
 131         if ((cm = mps_alloc_command(sc)) == NULL) {
 132                 printf("%s: command alloc failed @ line %d\n", __func__,
 133                     __LINE__);
 134                 error = EBUSY;
 135                 goto out;
 136         }
 137         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 138         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 139         request->Function = MPI2_FUNCTION_CONFIG;
 140         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 141         request->Header.PageType = MPI2_CONFIG_PAGETYPE_IOC;
 142         request->Header.PageNumber = 8;
 143         request->Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION;
 144         request->Header.PageLength = mpi_reply->Header.PageLength;
 145         cm->cm_length =  le16toh(mpi_reply->Header.PageLength) * 4;
 146         cm->cm_sge = &request->PageBufferSGE;
 147         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
 148         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
 149         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 150         page = malloc((cm->cm_length), M_MPT2, M_ZERO | M_NOWAIT);
 151         if (!page) {
 152                 printf("%s: page alloc failed\n", __func__);
 153                 error = ENOMEM;
 154                 goto out;
 155         }
 156         cm->cm_data = page;
 157
 158         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 159         if (cm != NULL)
 160                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 161         if (error || (reply == NULL)) {
 162                 /* FIXME */
 163                 /*
 164                  * If the request returns an error then we need to do a diag
 165                  * reset
 166                  */
 167                 printf("%s: request for page completed with error %d",
 168                     __func__, error);
 169                 error = ENXIO;
 170                 goto out;
 171         }
 172         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 173         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 174         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 175                 /* FIXME */
 176                 /*
 177                  * If the request returns an error then we need to do a diag
 178                  * reset
 179                  */
 180                 printf("%s: page read with error; iocstatus = 0x%x\n",
 181                     __func__, ioc_status);
 182                 error = ENXIO;
 183                 goto out;
 184         }
 185         bcopy(page, config_page, MIN(cm->cm_length, (sizeof(Mpi2IOCPage8_t))));
 186
 187 out:
 188         free(page, M_MPT2);
 189         if (cm)
 190                 mps_free_command(sc, cm);
 191         return (error);
 192 }
 193
 194 /**
 195  * mps_config_get_man_pg10 - obtain Manufacturing Page 10 data and set flags
 196  *   accordingly.  Currently, this page does not need to return to caller.
 197  * @sc: per adapter object
 198  * @mpi_reply: reply mf payload returned from firmware
 199  * Context: sleep.
 200  *
 201  * Returns 0 for success, non-zero for failure.
 202  */
 203 int
 204 mps_config_get_man_pg10(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply)
 205 {
 206         MPI2_CONFIG_REQUEST *request;
 207         MPI2_CONFIG_REPLY *reply = NULL;
 208         struct mps_command *cm;
 209         pMpi2ManufacturingPagePS_t page = NULL;
 210         uint32_t *pPS_info;
 211         uint8_t OEM_Value = 0;
 212         int error = 0;
 213         u16 ioc_status;
 214
 215         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
 216
 217         if ((cm = mps_alloc_command(sc)) == NULL) {
 218                 printf("%s: command alloc failed @ line %d\n", __func__,
 219                     __LINE__);
 220                 error = EBUSY;
 221                 goto out;
 222         }
 223         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 224         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 225         request->Function = MPI2_FUNCTION_CONFIG;
 226         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 227         request->Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 228         request->Header.PageNumber = 10;
 229         request->Header.PageVersion = MPI2_MANUFACTURING10_PAGEVERSION;
 230         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 231         cm->cm_data = NULL;
 232
 233         /*
 234          * This page must be polled because the IOC isn't ready yet when this
 235          * page is needed.
 236          */
 237         error = mps_wait_command(sc, &cm, 60, 0);
 238         if (cm != NULL)
 239                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 240         if (error || (reply == NULL)) {
 241                 /* FIXME */
 242                 /* If the poll returns error then we need to do diag reset */
 243                 printf("%s: poll for header completed with error %d",
 244                     __func__, error);
 245                 error = ENXIO;
 246                 goto out;
 247         }
 248         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 249         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 250         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 251                 /* FIXME */
 252                 /* If the poll returns error then we need to do diag reset */
 253                 printf("%s: header read with error; iocstatus = 0x%x\n",
 254                     __func__, ioc_status);
 255                 error = ENXIO;
 256                 goto out;
 257         }
 258         /* We have to do free and alloc for the reply-free and reply-post
 259          * counters to match - Need to review the reply FIFO handling.
 260          */
 261         mps_free_command(sc, cm);
 262
 263         if ((cm = mps_alloc_command(sc)) == NULL) {
 264                 printf("%s: command alloc failed @ line %d\n", __func__,
 265                     __LINE__);
 266                 error = EBUSY;
 267                 goto out;
 268         }
 269         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 270         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 271         request->Function = MPI2_FUNCTION_CONFIG;
 272         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 273         request->Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING;
 274         request->Header.PageNumber = 10;
 275         request->Header.PageVersion = MPI2_MANUFACTURING10_PAGEVERSION;
 276         request->Header.PageLength = mpi_reply->Header.PageLength;
 277         cm->cm_length =  le16toh(mpi_reply->Header.PageLength) * 4;
 278         cm->cm_sge = &request->PageBufferSGE;
 279         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
 280         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
 281         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 282         page = malloc(MPS_MAN_PAGE10_SIZE, M_MPT2, M_ZERO | M_NOWAIT);
 283         if (!page) {
 284                 printf("%s: page alloc failed\n", __func__);
 285                 error = ENOMEM;
 286                 goto out;
 287         }
 288         cm->cm_data = page;
 289
 290         /*
 291          * This page must be polled because the IOC isn't ready yet when this
 292          * page is needed.
 293          */
 294         error = mps_wait_command(sc, &cm, 60, 0);
 295         if (cm != NULL)
 296                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 297         if (error || (reply == NULL)) {
 298                 /* FIXME */
 299                 /* If the poll returns error then we need to do diag reset */
 300                 printf("%s: poll for page completed with error %d",
 301                     __func__, error);
 302                 error = ENXIO;
 303                 goto out;
 304         }
 305         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 306         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 307         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 308                 /* FIXME */
 309                 /* If the poll returns error then we need to do diag reset */
 310                 printf("%s: page read with error; iocstatus = 0x%x\n",
 311                     __func__, ioc_status);
 312                 error = ENXIO;
 313                 goto out;
 314         }
 315
 316         /*
 317          * If OEM ID is unknown, fail the request.
 318          */
 319         sc->WD_hide_expose = MPS_WD_HIDE_ALWAYS;
 320         OEM_Value = (uint8_t)(page->ProductSpecificInfo & 0x000000FF);
 321         if (OEM_Value != MPS_WD_LSI_OEM) {
 322                 mps_dprint(sc, MPS_FAULT, "Unknown OEM value for WarpDrive "
 323                     "(0x%x)\n", OEM_Value);
 324                 error = ENXIO;
 325                 goto out;
 326         }
 327
 328         /*
 329          * Set the phys disks hide/expose value.
 330          */
 331         pPS_info = &page->ProductSpecificInfo;
 332         sc->WD_hide_expose = (uint8_t)(pPS_info[5]);
 333         sc->WD_hide_expose &= MPS_WD_HIDE_EXPOSE_MASK;
 334         if ((sc->WD_hide_expose != MPS_WD_HIDE_ALWAYS) &&
 335             (sc->WD_hide_expose != MPS_WD_EXPOSE_ALWAYS) &&
 336             (sc->WD_hide_expose != MPS_WD_HIDE_IF_VOLUME)) {
 337                 mps_dprint(sc, MPS_FAULT, "Unknown value for WarpDrive "
 338                     "hide/expose: 0x%x\n", sc->WD_hide_expose);
 339                 error = ENXIO;
 340                 goto out;
 341         }
 342
 343 out:
 344         free(page, M_MPT2);
 345         if (cm)
 346                 mps_free_command(sc, cm);
 347         return (error);
 348 }
 349
 350 /**
 351  * mps_base_static_config_pages - static start of day config pages.
 352  * @sc: per adapter object
 353  *
 354  * Return nothing.
 355  */
 356 void
 357 mps_base_static_config_pages(struct mps_softc *sc)
 358 {
 359         Mpi2ConfigReply_t       mpi_reply;
 360         int                     retry;
 361
 362         retry = 0;
 363         while (mps_config_get_ioc_pg8(sc, &mpi_reply, &sc->ioc_pg8)) {
 364                 retry++;
 365                 if (retry > 5) {
 366                         /* We need to Handle this situation */
 367                         /*FIXME*/
 368                         break;
 369                 }
 370         }
 371 }
 372
 373 /**
 374  * mps_wd_config_pages - get info required to support WarpDrive.  This needs to
 375  *    be called after discovery is complete to guarantee that IR info is there.
 376  * @sc: per adapter object
 377  *
 378  * Return nothing.
 379  */
 380 void
 381 mps_wd_config_pages(struct mps_softc *sc)
 382 {
 383         Mpi2ConfigReply_t       mpi_reply;
 384         pMpi2RaidVolPage0_t     raid_vol_pg0 = NULL;
 385         Mpi2RaidPhysDiskPage0_t phys_disk_pg0;
 386         pMpi2RaidVol0PhysDisk_t pRVPD;
 387         uint32_t                stripe_size, phys_disk_page_address;
 388         uint16_t                block_size;
 389         uint8_t                 index, stripe_exp = 0, block_exp = 0;
 390
 391         /*
 392          * Get the WD settings from manufacturing page 10 if using a WD HBA.
 393          * This will be used to determine if phys disks should always be
 394          * hidden, hidden only if part of a WD volume, or never hidden.  Also,
 395          * get the WD RAID Volume info and fail if volume does not exist or if
 396          * volume does not meet the requirements for a WD volume.  No retry
 397          * here.  Just default to HIDE ALWAYS if man Page10 fails, or clear WD
 398          * Valid flag if Volume info fails.
 399          */
 400         sc->WD_valid_config = FALSE;
 401         if (sc->mps_flags & MPS_FLAGS_WD_AVAILABLE) {
 402                 if (mps_config_get_man_pg10(sc, &mpi_reply)) {
 403                         mps_dprint(sc, MPS_FAULT,
 404                             "mps_config_get_man_pg10 failed! Using 0 (Hide "
 405                             "Always) for WarpDrive hide/expose value.\n");
 406                         sc->WD_hide_expose = MPS_WD_HIDE_ALWAYS;
 407                 }
 408
 409                 /*
 410                  * Get first RAID Volume Page0 using GET_NEXT_HANDLE.
 411                  */
 412                 raid_vol_pg0 = malloc(sizeof(Mpi2RaidVolPage0_t) +
 413                     (sizeof(Mpi2RaidVol0PhysDisk_t) * MPS_MAX_DISKS_IN_VOL),
 414                     M_MPT2, M_ZERO | M_NOWAIT);
 415                 if (!raid_vol_pg0) {
 416                         printf("%s: page alloc failed\n", __func__);
 417                         goto out;
 418                 }
 419
 420                 if (mps_config_get_raid_volume_pg0(sc, &mpi_reply, raid_vol_pg0,
 421                     0x0000FFFF)) {
 422                         mps_dprint(sc, MPS_INFO,
 423                             "mps_config_get_raid_volume_pg0 failed! Assuming "
 424                             "WarpDrive IT mode.\n");
 425                         goto out;
 426                 }
 427
 428                 /*
 429                  * Check for valid WD configuration:
 430                  *   volume type is RAID0
 431                  *   number of phys disks in the volume is no more than 8
 432                  */
 433                 if ((raid_vol_pg0->VolumeType != MPI2_RAID_VOL_TYPE_RAID0) ||
 434                     (raid_vol_pg0->NumPhysDisks > 8)) {
 435                         mps_dprint(sc, MPS_FAULT,
 436                             "Invalid WarpDrive configuration. Direct Drive I/O "
 437                             "will not be used.\n");
 438                         goto out;
 439                 }
 440
 441                 /*
 442                  * Save the WD RAID data to be used during WD I/O.
 443                  */
 444                 sc->DD_max_lba = le64toh((uint64_t)raid_vol_pg0->MaxLBA.High <<
 445                     32 | (uint64_t)raid_vol_pg0->MaxLBA.Low);
 446                 sc->DD_num_phys_disks = raid_vol_pg0->NumPhysDisks;
 447                 sc->DD_dev_handle = raid_vol_pg0->DevHandle;
 448                 sc->DD_stripe_size = raid_vol_pg0->StripeSize;
 449                 sc->DD_block_size = raid_vol_pg0->BlockSize;
 450
 451                 /*
 452                  * Find power of 2 of stripe size and set this as the exponent.
 453                  * Fail if stripe size is 0.
 454                  */
 455                 stripe_size = raid_vol_pg0->StripeSize;
 456                 for (index = 0; index < 32; index++) {
 457                         if (stripe_size & 1)
 458                                 break;
 459                         stripe_exp++;
 460                         stripe_size >>= 1;
 461                 }
 462                 if (index == 32) {
 463                         mps_dprint(sc, MPS_FAULT,
 464                             "RAID Volume's stripe size is 0. Direct Drive I/O "
 465                             "will not be used.\n");
 466                         goto out;
 467                 }
 468                 sc->DD_stripe_exponent = stripe_exp;
 469
 470                 /*
 471                  * Find power of 2 of block size and set this as the exponent.
 472                  * Fail if block size is 0.
 473                  */
 474                 block_size = raid_vol_pg0->BlockSize;
 475                 for (index = 0; index < 16; index++) {
 476                         if (block_size & 1)
 477                                 break;
 478                         block_exp++;
 479                         block_size >>= 1;
 480                 }
 481                 if (index == 16) {
 482                         mps_dprint(sc, MPS_FAULT,
 483                             "RAID Volume's block size is 0. Direct Drive I/O "
 484                             "will not be used.\n");
 485                         goto out;
 486                 }
 487                 sc->DD_block_exponent = block_exp;
 488
 489                 /*
 490                  * Loop through all of the volume's Phys Disks to map the phys
 491                  * disk number into the columm map.  This is used during Direct
 492                  * Drive I/O to send the request to the correct SSD.
 493                  */
 494                 pRVPD = (pMpi2RaidVol0PhysDisk_t)&raid_vol_pg0->PhysDisk;
 495                 for (index = 0; index < raid_vol_pg0->NumPhysDisks; index++) {
 496                         sc->DD_column_map[pRVPD->PhysDiskMap].phys_disk_num =
 497                             pRVPD->PhysDiskNum;
 498                         pRVPD++;
 499                 }
 500
 501                 /*
 502                  * Get second RAID Volume Page0 using previous handle.  This
 503                  * page should not exist.  If it does, must not proceed with WD
 504                  * handling.
 505                  */
 506                 if (mps_config_get_raid_volume_pg0(sc, &mpi_reply,
 507                     raid_vol_pg0, (u32)raid_vol_pg0->DevHandle)) {
 508                         if ((le16toh(mpi_reply.IOCStatus) &
 509                             MPI2_IOCSTATUS_MASK) !=
 510                             MPI2_IOCSTATUS_CONFIG_INVALID_PAGE) {
 511                                 mps_dprint(sc, MPS_FAULT,
 512                                     "Multiple RAID Volume Page0! Direct Drive "
 513                                     "I/O will not be used.\n");
 514                                 goto out;
 515                         }
 516                 } else {
 517                         mps_dprint(sc, MPS_FAULT,
 518                             "Multiple volumes! Direct Drive I/O will not be "
 519                             "used.\n");
 520                         goto out;
 521                 }
 522
 523                 /*
 524                  * Get RAID Volume Phys Disk Page 0 for all SSDs in the volume.
 525                  */
 526                 for (index = 0; index < raid_vol_pg0->NumPhysDisks; index++) {
 527                         phys_disk_page_address =
 528                             MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM +
 529                             sc->DD_column_map[index].phys_disk_num;
 530                         if (mps_config_get_raid_pd_pg0(sc, &mpi_reply,
 531                             &phys_disk_pg0, phys_disk_page_address)) {
 532                                 mps_dprint(sc, MPS_FAULT,
 533                                     "mps_config_get_raid_pd_pg0 failed! Direct "
 534                                     "Drive I/O will not be used.\n");
 535                                 goto out;
 536                         }
 537                         if (phys_disk_pg0.DevHandle == 0xFFFF) {
 538                                 mps_dprint(sc, MPS_FAULT,
 539                                     "Invalid Phys Disk DevHandle! Direct Drive "
 540                                     "I/O will not be used.\n");
 541                                 goto out;
 542                         }
 543                         sc->DD_column_map[index].dev_handle =
 544                             phys_disk_pg0.DevHandle;
 545                 }
 546                 sc->WD_valid_config = TRUE;
 547 out:
 548                 if (raid_vol_pg0)
 549                         free(raid_vol_pg0, M_MPT2);
 550         }
 551 }
 552
 553 /**
 554  * mps_config_get_dpm_pg0 - obtain driver persistent mapping page0
 555  * @sc: per adapter object
 556  * @mpi_reply: reply mf payload returned from firmware
 557  * @config_page: contents of the config page
 558  * @sz: size of buffer passed in config_page
 559  * Context: sleep.
 560  *
 561  * Returns 0 for success, non-zero for failure.
 562  */
 563 int
 564 mps_config_get_dpm_pg0(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply,
 565     Mpi2DriverMappingPage0_t *config_page, u16 sz)
 566 {
 567         MPI2_CONFIG_REQUEST *request;
 568         MPI2_CONFIG_REPLY *reply = NULL;
 569         struct mps_command *cm;
 570         Mpi2DriverMappingPage0_t *page = NULL;
 571         int error = 0;
 572         u16 ioc_status;
 573
 574         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
 575
 576         memset(config_page, 0, sz);
 577         if ((cm = mps_alloc_command(sc)) == NULL) {
 578                 printf("%s: command alloc failed @ line %d\n", __func__,
 579                     __LINE__);
 580                 error = EBUSY;
 581                 goto out;
 582         }
 583         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 584         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 585         request->Function = MPI2_FUNCTION_CONFIG;
 586         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 587         request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 588         request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING;
 589         request->Header.PageNumber = 0;
 590         request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION;
 591         request->PageAddress = sc->max_dpm_entries <<
 592             MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT;
 593         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 594         cm->cm_data = NULL;
 595         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 596         if (cm != NULL)
 597                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 598         if (error || (reply == NULL)) {
 599                 /* FIXME */
 600                 /*
 601                  * If the request returns an error then we need to do a diag
 602                  * reset
 603                  */
 604                 printf("%s: request for header completed with error %d",
 605                     __func__, error);
 606                 error = ENXIO;
 607                 goto out;
 608         }
 609         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 610         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 611         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 612                 /* FIXME */
 613                 /*
 614                  * If the request returns an error then we need to do a diag
 615                  * reset
 616                  */
 617                 printf("%s: header read with error; iocstatus = 0x%x\n",
 618                     __func__, ioc_status);
 619                 error = ENXIO;
 620                 goto out;
 621         }
 622         /* We have to do free and alloc for the reply-free and reply-post
 623          * counters to match - Need to review the reply FIFO handling.
 624          */
 625         mps_free_command(sc, cm);
 626
 627         if ((cm = mps_alloc_command(sc)) == NULL) {
 628                 printf("%s: command alloc failed @ line %d\n", __func__,
 629                     __LINE__);
 630                 error = EBUSY;
 631                 goto out;
 632         }
 633         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 634         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 635         request->Function = MPI2_FUNCTION_CONFIG;
 636         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_NVRAM;
 637         request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 638         request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING;
 639         request->Header.PageNumber = 0;
 640         request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION;
 641         request->PageAddress = sc->max_dpm_entries <<
 642             MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT;
 643         request->ExtPageLength = mpi_reply->ExtPageLength;
 644         cm->cm_length =  le16toh(request->ExtPageLength) * 4;
 645         cm->cm_sge = &request->PageBufferSGE;
 646         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
 647         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
 648         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 649         page = malloc(cm->cm_length, M_MPT2, M_ZERO|M_NOWAIT);
 650         if (!page) {
 651                 printf("%s: page alloc failed\n", __func__);
 652                 error = ENOMEM;
 653                 goto out;
 654         }
 655         cm->cm_data = page;
 656         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 657         if (cm != NULL)
 658                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 659         if (error || (reply == NULL)) {
 660                 /* FIXME */
 661                 /*
 662                  * If the request returns an error then we need to do a diag
 663                  * reset
 664                  */
 665                 printf("%s: request for page completed with error %d",
 666                     __func__, error);
 667                 error = ENXIO;
 668                 goto out;
 669         }
 670         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 671         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 672         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 673                 /* FIXME */
 674                 /*
 675                  * If the request returns an error then we need to do a diag
 676                  * reset
 677                  */
 678                 printf("%s: page read with error; iocstatus = 0x%x\n",
 679                     __func__, ioc_status);
 680                 error = ENXIO;
 681                 goto out;
 682         }
 683         bcopy(page, config_page, MIN(cm->cm_length, sz));
 684 out:
 685         free(page, M_MPT2);
 686         if (cm)
 687                 mps_free_command(sc, cm);
 688         return (error);
 689 }
 690
 691 /**
 692  * mps_config_set_dpm_pg0 - write an entry in driver persistent mapping page0
 693  * @sc: per adapter object
 694  * @mpi_reply: reply mf payload returned from firmware
 695  * @config_page: contents of the config page
 696  * @entry_idx: entry index in DPM Page0 to be modified
 697  * Context: sleep.
 698  *
 699  * Returns 0 for success, non-zero for failure.
 700  */
 701
 702 int mps_config_set_dpm_pg0(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply,
 703     Mpi2DriverMappingPage0_t *config_page, u16 entry_idx)
 704 {
 705         MPI2_CONFIG_REQUEST *request;
 706         MPI2_CONFIG_REPLY *reply = NULL;
 707         struct mps_command *cm;
 708         MPI2_CONFIG_PAGE_DRIVER_MAPPING_0 *page = NULL;
 709         int error = 0;
 710         u16 ioc_status;
 711
 712         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
 713
 714         if ((cm = mps_alloc_command(sc)) == NULL) {
 715                 printf("%s: command alloc failed @ line %d\n", __func__,
 716                     __LINE__);
 717                 error = EBUSY;
 718                 goto out;
 719         }
 720         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 721         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 722         request->Function = MPI2_FUNCTION_CONFIG;
 723         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 724         request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 725         request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING;
 726         request->Header.PageNumber = 0;
 727         request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION;
 728         /* We can remove below two lines ????*/
 729         request->PageAddress = 1 << MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT;
 730         request->PageAddress |= htole16(entry_idx);
 731         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 732         cm->cm_data = NULL;
 733         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 734         if (cm != NULL)
 735                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 736         if (error || (reply == NULL)) {
 737                 /* FIXME */
 738                 /*
 739                  * If the request returns an error then we need to do a diag
 740                  * reset
 741                  */
 742                 printf("%s: request for header completed with error %d",
 743                     __func__, error);
 744                 error = ENXIO;
 745                 goto out;
 746         }
 747         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 748         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 749         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 750                 /* FIXME */
 751                 /*
 752                  * If the request returns an error then we need to do a diag
 753                  * reset
 754                  */
 755                 printf("%s: header read with error; iocstatus = 0x%x\n",
 756                     __func__, ioc_status);
 757                 error = ENXIO;
 758                 goto out;
 759         }
 760         /* We have to do free and alloc for the reply-free and reply-post
 761          * counters to match - Need to review the reply FIFO handling.
 762          */
 763         mps_free_command(sc, cm);
 764
 765         if ((cm = mps_alloc_command(sc)) == NULL) {
 766                 printf("%s: command alloc failed @ line %d\n", __func__,
 767                     __LINE__);
 768                 error = EBUSY;
 769                 goto out;
 770         }
 771         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 772         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 773         request->Function = MPI2_FUNCTION_CONFIG;
 774         request->Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
 775         request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 776         request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING;
 777         request->Header.PageNumber = 0;
 778         request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION;
 779         request->ExtPageLength = mpi_reply->ExtPageLength;
 780         request->PageAddress = 1 << MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT;
 781         request->PageAddress |= htole16(entry_idx);
 782         cm->cm_length = le16toh(mpi_reply->ExtPageLength) * 4;
 783         cm->cm_sge = &request->PageBufferSGE;
 784         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
 785         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAOUT;
 786         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 787         page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT);
 788         if (!page) {
 789                 printf("%s: page alloc failed\n", __func__);
 790                 error = ENOMEM;
 791                 goto out;
 792         }
 793         bcopy(config_page, page, MIN(cm->cm_length,
 794             (sizeof(Mpi2DriverMappingPage0_t))));
 795         cm->cm_data = page;
 796         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 797         if (cm != NULL)
 798                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 799         if (error || (reply == NULL)) {
 800                 /* FIXME */
 801                 /*
 802                  * If the request returns an error then we need to do a diag
 803                  * reset
 804                  */
 805                 printf("%s: request to write page completed with error %d",
 806                     __func__, error);
 807                 error = ENXIO;
 808                 goto out;
 809         }
 810         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 811         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 812         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 813                 /* FIXME */
 814                 /*
 815                  * If the request returns an error then we need to do a diag
 816                  * reset
 817                  */
 818                 printf("%s: page written with error; iocstatus = 0x%x\n",
 819                     __func__, ioc_status);
 820                 error = ENXIO;
 821                 goto out;
 822         }
 823 out:
 824         free(page, M_MPT2);
 825         if (cm)
 826                 mps_free_command(sc, cm);
 827         return (error);
 828 }
 829
 830 /**
 831  * mps_config_get_sas_device_pg0 - obtain sas device page 0
 832  * @sc: per adapter object
 833  * @mpi_reply: reply mf payload returned from firmware
 834  * @config_page: contents of the config page
 835  * @form: GET_NEXT_HANDLE or HANDLE
 836  * @handle: device handle
 837  * Context: sleep.
 838  *
 839  * Returns 0 for success, non-zero for failure.
 840  */
 841 int
 842 mps_config_get_sas_device_pg0(struct mps_softc *sc, Mpi2ConfigReply_t
 843     *mpi_reply, Mpi2SasDevicePage0_t *config_page, u32 form, u16 handle)
 844 {
 845         MPI2_CONFIG_REQUEST *request;
 846         MPI2_CONFIG_REPLY *reply = NULL;
 847         struct mps_command *cm;
 848         Mpi2SasDevicePage0_t *page = NULL;
 849         int error = 0;
 850         u16 ioc_status;
 851
 852         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
 853
 854         if ((cm = mps_alloc_command(sc)) == NULL) {
 855                 printf("%s: command alloc failed @ line %d\n", __func__,
 856                     __LINE__);
 857                 error = EBUSY;
 858                 goto out;
 859         }
 860         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 861         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 862         request->Function = MPI2_FUNCTION_CONFIG;
 863         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 864         request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 865         request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
 866         request->Header.PageNumber = 0;
 867         request->Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION;
 868         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 869         cm->cm_data = NULL;
 870         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 871         if (cm != NULL)
 872                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 873         if (error || (reply == NULL)) {
 874                 /* FIXME */
 875                 /*
 876                  * If the request returns an error then we need to do a diag
 877                  * reset
 878                  */
 879                 printf("%s: request for header completed with error %d",
 880                     __func__, error);
 881                 error = ENXIO;
 882                 goto out;
 883         }
 884         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 885         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 886         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 887                 /* FIXME */
 888                 /*
 889                  * If the request returns an error then we need to do a diag
 890                  * reset
 891                  */
 892                 printf("%s: header read with error; iocstatus = 0x%x\n",
 893                     __func__, ioc_status);
 894                 error = ENXIO;
 895                 goto out;
 896         }
 897         /* We have to do free and alloc for the reply-free and reply-post
 898          * counters to match - Need to review the reply FIFO handling.
 899          */
 900         mps_free_command(sc, cm);
 901
 902         if ((cm = mps_alloc_command(sc)) == NULL) {
 903                 printf("%s: command alloc failed @ line %d\n", __func__,
 904                     __LINE__);
 905                 error = EBUSY;
 906                 goto out;
 907         }
 908         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 909         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 910         request->Function = MPI2_FUNCTION_CONFIG;
 911         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 912         request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 913         request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE;
 914         request->Header.PageNumber = 0;
 915         request->Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION;
 916         request->ExtPageLength = mpi_reply->ExtPageLength;
 917         request->PageAddress = htole32(form | handle);
 918         cm->cm_length = le16toh(mpi_reply->ExtPageLength) * 4;
 919         cm->cm_sge = &request->PageBufferSGE;
 920         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
 921         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
 922         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 923         page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT);
 924         if (!page) {
 925                 printf("%s: page alloc failed\n", __func__);
 926                 error = ENOMEM;
 927                 goto out;
 928         }
 929         cm->cm_data = page;
 930
 931         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
 932         if (cm != NULL)
 933                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
 934         if (error || (reply == NULL)) {
 935                 /* FIXME */
 936                 /*
 937                  * If the request returns an error then we need to do a diag
 938                  * reset
 939                  */
 940                 printf("%s: request for page completed with error %d",
 941                     __func__, error);
 942                 error = ENXIO;
 943                 goto out;
 944         }
 945         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
 946         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
 947         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
 948                 /* FIXME */
 949                 /*
 950                  * If the request returns an error then we need to do a diag
 951                  * reset
 952                  */
 953                 printf("%s: page read with error; iocstatus = 0x%x\n",
 954                     __func__, ioc_status);
 955                 error = ENXIO;
 956                 goto out;
 957         }
 958         bcopy(page, config_page, MIN(cm->cm_length,
 959             sizeof(Mpi2SasDevicePage0_t)));
 960 out:
 961         free(page, M_MPT2);
 962         if (cm)
 963                 mps_free_command(sc, cm);
 964         return (error);
 965 }
 966
 967 /**
 968  * mps_config_get_bios_pg3 - obtain BIOS page 3
 969  * @sc: per adapter object
 970  * @mpi_reply: reply mf payload returned from firmware
 971  * @config_page: contents of the config page
 972  * Context: sleep.
 973  *
 974  * Returns 0 for success, non-zero for failure.
 975  */
 976 int
 977 mps_config_get_bios_pg3(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply,
 978     Mpi2BiosPage3_t *config_page)
 979 {
 980         MPI2_CONFIG_REQUEST *request;
 981         MPI2_CONFIG_REPLY *reply = NULL;
 982         struct mps_command *cm;
 983         Mpi2BiosPage3_t *page = NULL;
 984         int error = 0;
 985         u16 ioc_status;
 986
 987         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
 988
 989         if ((cm = mps_alloc_command(sc)) == NULL) {
 990                 printf("%s: command alloc failed @ line %d\n", __func__,
 991                     __LINE__);
 992                 error = EBUSY;
 993                 goto out;
 994         }
 995         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
 996         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
 997         request->Function = MPI2_FUNCTION_CONFIG;
 998         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 999         request->Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
1000         request->Header.PageNumber = 3;
1001         request->Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION;
1002         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1003         cm->cm_data = NULL;
1004         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
1005         if (cm != NULL)
1006                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1007         if (error || (reply == NULL)) {
1008                 /* FIXME */
1009                 /*
1010                  * If the request returns an error then we need to do a diag
1011                  * reset
1012                  */
1013                 printf("%s: request for header completed with error %d",
1014                     __func__, error);
1015                 error = ENXIO;
1016                 goto out;
1017         }
1018         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1019         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1020         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1021                 /* FIXME */
1022                 /*
1023                  * If the request returns an error then we need to do a diag
1024                  * reset
1025                  */
1026                 printf("%s: header read with error; iocstatus = 0x%x\n",
1027                     __func__, ioc_status);
1028                 error = ENXIO;
1029                 goto out;
1030         }
1031         /* We have to do free and alloc for the reply-free and reply-post
1032          * counters to match - Need to review the reply FIFO handling.
1033          */
1034         mps_free_command(sc, cm);
1035
1036         if ((cm = mps_alloc_command(sc)) == NULL) {
1037                 printf("%s: command alloc failed @ line %d\n", __func__,
1038                     __LINE__);
1039                 error = EBUSY;
1040                 goto out;
1041         }
1042         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
1043         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
1044         request->Function = MPI2_FUNCTION_CONFIG;
1045         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1046         request->Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS;
1047         request->Header.PageNumber = 3;
1048         request->Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION;
1049         request->Header.PageLength = mpi_reply->Header.PageLength;
1050         cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4;
1051         cm->cm_sge = &request->PageBufferSGE;
1052         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
1053         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
1054         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1055         page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT);
1056         if (!page) {
1057                 printf("%s: page alloc failed\n", __func__);
1058                 error = ENOMEM;
1059                 goto out;
1060         }
1061         cm->cm_data = page;
1062
1063         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
1064         if (cm != NULL)
1065                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1066         if (error || (reply == NULL)) {
1067                 /* FIXME */
1068                 /*
1069                  * If the request returns an error then we need to do a diag
1070                  * reset
1071                  */
1072                 printf("%s: request for page completed with error %d",
1073                     __func__, error);
1074                 error = ENXIO;
1075                 goto out;
1076         }
1077         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1078         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1079         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1080                 /* FIXME */
1081                 /*
1082                  * If the request returns an error then we need to do a diag
1083                  * reset
1084                  */
1085                 printf("%s: page read with error; iocstatus = 0x%x\n",
1086                     __func__, ioc_status);
1087                 error = ENXIO;
1088                 goto out;
1089         }
1090         bcopy(page, config_page, MIN(cm->cm_length, sizeof(Mpi2BiosPage3_t)));
1091 out:
1092         free(page, M_MPT2);
1093         if (cm)
1094                 mps_free_command(sc, cm);
1095         return (error);
1096 }
1097
1098 /**
1099  * mps_config_get_raid_volume_pg0 - obtain raid volume page 0
1100  * @sc: per adapter object
1101  * @mpi_reply: reply mf payload returned from firmware
1102  * @config_page: contents of the config page
1103  * @page_address: form and handle value used to get page
1104  * Context: sleep.
1105  *
1106  * Returns 0 for success, non-zero for failure.
1107  */
1108 int
1109 mps_config_get_raid_volume_pg0(struct mps_softc *sc, Mpi2ConfigReply_t
1110     *mpi_reply, Mpi2RaidVolPage0_t *config_page, u32 page_address)
1111 {
1112         MPI2_CONFIG_REQUEST *request;
1113         MPI2_CONFIG_REPLY *reply = NULL;
1114         struct mps_command *cm;
1115         Mpi2RaidVolPage0_t *page = NULL;
1116         int error = 0;
1117         u16 ioc_status;
1118
1119         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
1120
1121         if ((cm = mps_alloc_command(sc)) == NULL) {
1122                 printf("%s: command alloc failed @ line %d\n", __func__,
1123                     __LINE__);
1124                 error = EBUSY;
1125                 goto out;
1126         }
1127         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
1128         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
1129         request->Function = MPI2_FUNCTION_CONFIG;
1130         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1131         request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1132         request->Header.PageNumber = 0;
1133         request->Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION;
1134         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1135         cm->cm_data = NULL;
1136
1137         /*
1138          * This page must be polled because the IOC isn't ready yet when this
1139          * page is needed.
1140          */
1141         error = mps_wait_command(sc, &cm, 60, 0);
1142         if (cm != NULL)
1143                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1144         if (error || (reply == NULL)) {
1145                 /* FIXME */
1146                 /* If the poll returns error then we need to do diag reset */
1147                 printf("%s: poll for header completed with error %d",
1148                     __func__, error);
1149                 error = ENXIO;
1150                 goto out;
1151         }
1152         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1153         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1154         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1155                 /* FIXME */
1156                 /* If the poll returns error then we need to do diag reset */
1157                 printf("%s: header read with error; iocstatus = 0x%x\n",
1158                     __func__, ioc_status);
1159                 error = ENXIO;
1160                 goto out;
1161         }
1162         /* We have to do free and alloc for the reply-free and reply-post
1163          * counters to match - Need to review the reply FIFO handling.
1164          */
1165         mps_free_command(sc, cm);
1166
1167         if ((cm = mps_alloc_command(sc)) == NULL) {
1168                 printf("%s: command alloc failed @ line %d\n", __func__,
1169                     __LINE__);
1170                 error = EBUSY;
1171                 goto out;
1172         }
1173         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
1174         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
1175         request->Function = MPI2_FUNCTION_CONFIG;
1176         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1177         request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1178         request->Header.PageNumber = 0;
1179         request->Header.PageLength = mpi_reply->Header.PageLength;
1180         request->Header.PageVersion = mpi_reply->Header.PageVersion;
1181         request->PageAddress = page_address;
1182         cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4;
1183         cm->cm_sge = &request->PageBufferSGE;
1184         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
1185         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
1186         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1187         page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT);
1188         if (!page) {
1189                 printf("%s: page alloc failed\n", __func__);
1190                 error = ENOMEM;
1191                 goto out;
1192         }
1193         cm->cm_data = page;
1194
1195         /*
1196          * This page must be polled because the IOC isn't ready yet when this
1197          * page is needed.
1198          */
1199         error = mps_wait_command(sc, &cm, 60, 0);
1200         if (cm != NULL)
1201                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1202         if (error || (reply == NULL)) {
1203                 /* FIXME */
1204                 /* If the poll returns error then we need to do diag reset */
1205                 printf("%s: poll for page completed with error %d",
1206                     __func__, error);
1207                 error = ENXIO;
1208                 goto out;
1209         }
1210         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1211         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1212         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1213                 /* FIXME */
1214                 /* If the poll returns error then we need to do diag reset */
1215                 printf("%s: page read with error; iocstatus = 0x%x\n",
1216                     __func__, ioc_status);
1217                 error = ENXIO;
1218                 goto out;
1219         }
1220         bcopy(page, config_page, cm->cm_length);
1221 out:
1222         free(page, M_MPT2);
1223         if (cm)
1224                 mps_free_command(sc, cm);
1225         return (error);
1226 }
1227
1228 /**
1229  * mps_config_get_raid_volume_pg1 - obtain raid volume page 1
1230  * @sc: per adapter object
1231  * @mpi_reply: reply mf payload returned from firmware
1232  * @config_page: contents of the config page
1233  * @form: GET_NEXT_HANDLE or HANDLE
1234  * @handle: volume handle
1235  * Context: sleep.
1236  *
1237  * Returns 0 for success, non-zero for failure.
1238  */
1239 int
1240 mps_config_get_raid_volume_pg1(struct mps_softc *sc, Mpi2ConfigReply_t
1241     *mpi_reply, Mpi2RaidVolPage1_t *config_page, u32 form, u16 handle)
1242 {
1243         MPI2_CONFIG_REQUEST *request;
1244         MPI2_CONFIG_REPLY *reply = NULL;
1245         struct mps_command *cm;
1246         Mpi2RaidVolPage1_t *page = NULL;
1247         int error = 0;
1248         u16 ioc_status;
1249
1250         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
1251
1252         if ((cm = mps_alloc_command(sc)) == NULL) {
1253                 printf("%s: command alloc failed @ line %d\n", __func__,
1254                     __LINE__);
1255                 error = EBUSY;
1256                 goto out;
1257         }
1258         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
1259         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
1260         request->Function = MPI2_FUNCTION_CONFIG;
1261         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1262         request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1263         request->Header.PageNumber = 1;
1264         request->Header.PageVersion = MPI2_RAIDVOLPAGE1_PAGEVERSION;
1265         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1266         cm->cm_data = NULL;
1267         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
1268         if (cm != NULL)
1269                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1270         if (error || (reply == NULL)) {
1271                 /* FIXME */
1272                 /*
1273                  * If the request returns an error then we need to do a diag
1274                  * reset
1275                  */
1276                 printf("%s: request for header completed with error %d",
1277                     __func__, error);
1278                 error = ENXIO;
1279                 goto out;
1280         }
1281         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1282         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1283         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1284                 /* FIXME */
1285                 /*
1286                  * If the request returns an error then we need to do a diag
1287                  * reset
1288                  */
1289                 printf("%s: header read with error; iocstatus = 0x%x\n",
1290                     __func__, ioc_status);
1291                 error = ENXIO;
1292                 goto out;
1293         }
1294         /* We have to do free and alloc for the reply-free and reply-post
1295          * counters to match - Need to review the reply FIFO handling.
1296          */
1297         mps_free_command(sc, cm);
1298
1299         if ((cm = mps_alloc_command(sc)) == NULL) {
1300                 printf("%s: command alloc failed @ line %d\n", __func__,
1301                     __LINE__);
1302                 error = EBUSY;
1303                 goto out;
1304         }
1305         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
1306         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
1307         request->Function = MPI2_FUNCTION_CONFIG;
1308         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1309         request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME;
1310         request->Header.PageNumber = 1;
1311         request->Header.PageLength = mpi_reply->Header.PageLength;
1312         request->Header.PageVersion = mpi_reply->Header.PageVersion;
1313         request->PageAddress = htole32(form | handle);
1314         cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4;
1315         cm->cm_sge = &request->PageBufferSGE;
1316         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
1317         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
1318         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1319         page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT);
1320         if (!page) {
1321                 printf("%s: page alloc failed\n", __func__);
1322                 error = ENOMEM;
1323                 goto out;
1324         }
1325         cm->cm_data = page;
1326
1327         error = mps_wait_command(sc, &cm, 60, CAN_SLEEP);
1328         if (cm != NULL)
1329                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1330         if (error || (reply == NULL)) {
1331                 /* FIXME */
1332                 /*
1333                  * If the request returns an error then we need to do a diag
1334                  * reset
1335                  */
1336                 printf("%s: request for page completed with error %d",
1337                     __func__, error);
1338                 error = ENXIO;
1339                 goto out;
1340         }
1341         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1342         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1343         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1344                 /* FIXME */
1345                 /*
1346                  * If the request returns an error then we need to do a diag
1347                  * reset
1348                  */
1349                 printf("%s: page read with error; iocstatus = 0x%x\n",
1350                     __func__, ioc_status);
1351                 error = ENXIO;
1352                 goto out;
1353         }
1354         bcopy(page, config_page, MIN(cm->cm_length,
1355             sizeof(Mpi2RaidVolPage1_t)));
1356 out:
1357         free(page, M_MPT2);
1358         if (cm)
1359                 mps_free_command(sc, cm);
1360         return (error);
1361 }
1362
1363 /**
1364  * mps_config_get_volume_wwid - returns wwid given the volume handle
1365  * @sc: per adapter object
1366  * @volume_handle: volume handle
1367  * @wwid: volume wwid
1368  * Context: sleep.
1369  *
1370  * Returns 0 for success, non-zero for failure.
1371  */
1372 int
1373 mps_config_get_volume_wwid(struct mps_softc *sc, u16 volume_handle, u64 *wwid)
1374 {
1375         Mpi2ConfigReply_t mpi_reply;
1376         Mpi2RaidVolPage1_t raid_vol_pg1;
1377
1378         *wwid = 0;
1379         if (!(mps_config_get_raid_volume_pg1(sc, &mpi_reply, &raid_vol_pg1,
1380             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, volume_handle))) {
1381                 *wwid = le64toh((u64)raid_vol_pg1.WWID.High << 32 |
1382                     raid_vol_pg1.WWID.Low);
1383                 return 0;
1384         } else
1385                 return -1;
1386 }
1387
1388 /**
1389  * mps_config_get_pd_pg0 - obtain raid phys disk page 0
1390  * @sc: per adapter object
1391  * @mpi_reply: reply mf payload returned from firmware
1392  * @config_page: contents of the config page
1393  * @page_address: form and handle value used to get page
1394  * Context: sleep.
1395  *
1396  * Returns 0 for success, non-zero for failure.
1397  */
1398 int
1399 mps_config_get_raid_pd_pg0(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply,
1400     Mpi2RaidPhysDiskPage0_t *config_page, u32 page_address)
1401 {
1402         MPI2_CONFIG_REQUEST *request;
1403         MPI2_CONFIG_REPLY *reply = NULL;
1404         struct mps_command *cm;
1405         Mpi2RaidPhysDiskPage0_t *page = NULL;
1406         int error = 0;
1407         u16 ioc_status;
1408
1409         mps_dprint(sc, MPS_TRACE, "%s\n", __func__);
1410
1411         if ((cm = mps_alloc_command(sc)) == NULL) {
1412                 printf("%s: command alloc failed @ line %d\n", __func__,
1413                     __LINE__);
1414                 error = EBUSY;
1415                 goto out;
1416         }
1417         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
1418         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
1419         request->Function = MPI2_FUNCTION_CONFIG;
1420         request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
1421         request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK;
1422         request->Header.PageNumber = 0;
1423         request->Header.PageVersion = MPI2_RAIDPHYSDISKPAGE0_PAGEVERSION;
1424         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1425         cm->cm_data = NULL;
1426
1427         /*
1428          * This page must be polled because the IOC isn't ready yet when this
1429          * page is needed.
1430          */
1431         error = mps_wait_command(sc, &cm, 60, 0);
1432         if (cm != NULL)
1433                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1434         if (error || (reply == NULL)) {
1435                 /* FIXME */
1436                 /* If the poll returns error then we need to do diag reset */
1437                 printf("%s: poll for header completed with error %d",
1438                     __func__, error);
1439                 error = ENXIO;
1440                 goto out;
1441         }
1442         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1443         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1444         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1445                 /* FIXME */
1446                 /* If the poll returns error then we need to do diag reset */
1447                 printf("%s: header read with error; iocstatus = 0x%x\n",
1448                     __func__, ioc_status);
1449                 error = ENXIO;
1450                 goto out;
1451         }
1452         /* We have to do free and alloc for the reply-free and reply-post
1453          * counters to match - Need to review the reply FIFO handling.
1454          */
1455         mps_free_command(sc, cm);
1456
1457         if ((cm = mps_alloc_command(sc)) == NULL) {
1458                 printf("%s: command alloc failed @ line %d\n", __func__,
1459                     __LINE__);
1460                 error = EBUSY;
1461                 goto out;
1462         }
1463         request = (MPI2_CONFIG_REQUEST *)cm->cm_req;
1464         bzero(request, sizeof(MPI2_CONFIG_REQUEST));
1465         request->Function = MPI2_FUNCTION_CONFIG;
1466         request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
1467         request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK;
1468         request->Header.PageNumber = 0;
1469         request->Header.PageLength = mpi_reply->Header.PageLength;
1470         request->Header.PageVersion = mpi_reply->Header.PageVersion;
1471         request->PageAddress = page_address;
1472         cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4;
1473         cm->cm_sge = &request->PageBufferSGE;
1474         cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION);
1475         cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN;
1476         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
1477         page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT);
1478         if (!page) {
1479                 printf("%s: page alloc failed\n", __func__);
1480                 error = ENOMEM;
1481                 goto out;
1482         }
1483         cm->cm_data = page;
1484
1485         /*
1486          * This page must be polled because the IOC isn't ready yet when this
1487          * page is needed.
1488          */
1489         error = mps_wait_command(sc, &cm, 60, 0);
1490         if (cm != NULL)
1491                 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply;
1492         if (error || (reply == NULL)) {
1493                 /* FIXME */
1494                 /* If the poll returns error then we need to do diag reset */
1495                 printf("%s: poll for page completed with error %d",
1496                     __func__, error);
1497                 error = ENXIO;
1498                 goto out;
1499         }
1500         ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK;
1501         bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY));
1502         if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1503                 /* FIXME */
1504                 /* If the poll returns error then we need to do diag reset */
1505                 printf("%s: page read with error; iocstatus = 0x%x\n",
1506                     __func__, ioc_status);
1507                 error = ENXIO;
1508                 goto out;
1509         }
1510         bcopy(page, config_page, MIN(cm->cm_length,
1511             sizeof(Mpi2RaidPhysDiskPage0_t)));
1512 out:
1513         free(page, M_MPT2);
1514         if (cm)
1515                 mps_free_command(sc, cm);
1516         return (error);
1517 }