usr.sbin/mpsutil/mps_cmd.c

   1 /*-
   2  * Copyright (c) 2015 Baptiste Daroussin <bapt@FreeBSD.org>
   3  *
   4  * Copyright (c) 2015 Netflix, Inc.
   5  * Written by: Scott Long <scottl@freebsd.org>
   6  *
   7  * Copyright (c) 2008 Yahoo!, Inc.
   8  * All rights reserved.
   9  * Written by: John Baldwin <jhb@FreeBSD.org>
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the author nor the names of any co-contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __RCSID("$FreeBSD$");
  38
  39 #include <sys/param.h>
  40 #include <sys/errno.h>
  41 #include <sys/ioctl.h>
  42 #if 0
  43 #include <sys/mps_ioctl.h>
  44 #else
  45 #include "mps_ioctl.h"
  46 #include "mpr_ioctl.h"
  47 #endif
  48 #include <sys/sysctl.h>
  49 #include <sys/uio.h>
  50
  51 #include <err.h>
  52 #include <fcntl.h>
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <unistd.h>
  57
  58 #include "mpsutil.h"
  59
  60 #ifndef USE_MPT_IOCTLS
  61 #define USE_MPT_IOCTLS
  62 #endif
  63
  64 static const char *mps_ioc_status_codes[] = {
  65         "Success",                              /* 0x0000 */
  66         "Invalid function",
  67         "Busy",
  68         "Invalid scatter-gather list",
  69         "Internal error",
  70         "Reserved",
  71         "Insufficient resources",
  72         "Invalid field",
  73         "Invalid state",                        /* 0x0008 */
  74         "Operation state not supported",
  75         NULL,
  76         NULL,
  77         NULL,
  78         NULL,
  79         NULL,
  80         NULL,
  81         NULL,                                   /* 0x0010 */
  82         NULL,
  83         NULL,
  84         NULL,
  85         NULL,
  86         NULL,
  87         NULL,
  88         NULL,
  89         NULL,                                   /* 0x0018 */
  90         NULL,
  91         NULL,
  92         NULL,
  93         NULL,
  94         NULL,
  95         NULL,
  96         NULL,
  97         "Invalid configuration action",         /* 0x0020 */
  98         "Invalid configuration type",
  99         "Invalid configuration page",
 100         "Invalid configuration data",
 101         "No configuration defaults",
 102         "Unable to commit configuration change",
 103         NULL,
 104         NULL,
 105         NULL,                                   /* 0x0028 */
 106         NULL,
 107         NULL,
 108         NULL,
 109         NULL,
 110         NULL,
 111         NULL,
 112         NULL,
 113         NULL,                                   /* 0x0030 */
 114         NULL,
 115         NULL,
 116         NULL,
 117         NULL,
 118         NULL,
 119         NULL,
 120         NULL,
 121         NULL,                                   /* 0x0038 */
 122         NULL,
 123         NULL,
 124         NULL,
 125         NULL,
 126         NULL,
 127         NULL,
 128         NULL,
 129         "Recovered SCSI error",                 /* 0x0040 */
 130         "Invalid SCSI bus",
 131         "Invalid SCSI target ID",
 132         "SCSI device not there",
 133         "SCSI data overrun",
 134         "SCSI data underrun",
 135         "SCSI I/O error",
 136         "SCSI protocol error",
 137         "SCSI task terminated",                 /* 0x0048 */
 138         "SCSI residual mismatch",
 139         "SCSI task management failed",
 140         "SCSI I/O controller terminated",
 141         "SCSI external controller terminated",
 142         "EEDP guard error",
 143         "EEDP reference tag error",
 144         "EEDP application tag error",
 145         NULL,                                   /* 0x0050 */
 146         NULL,
 147         NULL,
 148         NULL,
 149         NULL,
 150         NULL,
 151         NULL,
 152         NULL,
 153         NULL,                                   /* 0x0058 */
 154         NULL,
 155         NULL,
 156         NULL,
 157         NULL,
 158         NULL,
 159         NULL,
 160         NULL,
 161         "SCSI target priority I/O",             /* 0x0060 */
 162         "Invalid SCSI target port",
 163         "Invalid SCSI target I/O index",
 164         "SCSI target aborted",
 165         "No connection retryable",
 166         "No connection",
 167         "FC aborted",
 168         "Invalid FC receive ID",
 169         "FC did invalid",                       /* 0x0068 */
 170         "FC node logged out",
 171         "Transfer count mismatch",
 172         "STS data not set",
 173         "FC exchange canceled",
 174         "Data offset error",
 175         "Too much write data",
 176         "IU too short",
 177         "ACK NAK timeout",                      /* 0x0070 */
 178         "NAK received",
 179         NULL,
 180         NULL,
 181         NULL,
 182         NULL,
 183         NULL,
 184         NULL,
 185         NULL,                                   /* 0x0078 */
 186         NULL,
 187         NULL,
 188         NULL,
 189         NULL,
 190         NULL,
 191         NULL,
 192         NULL,
 193         "LAN device not found",                 /* 0x0080 */
 194         "LAN device failure",
 195         "LAN transmit error",
 196         "LAN transmit aborted",
 197         "LAN receive error",
 198         "LAN receive aborted",
 199         "LAN partial packet",
 200         "LAN canceled",
 201         NULL,                                   /* 0x0088 */
 202         NULL,
 203         NULL,
 204         NULL,
 205         NULL,
 206         NULL,
 207         NULL,
 208         NULL,
 209         "SAS SMP request failed",               /* 0x0090 */
 210         "SAS SMP data overrun",
 211         NULL,
 212         NULL,
 213         NULL,
 214         NULL,
 215         NULL,
 216         NULL,
 217         "Inband aborted",                       /* 0x0098 */
 218         "No inband connection",
 219         NULL,
 220         NULL,
 221         NULL,
 222         NULL,
 223         NULL,
 224         NULL,
 225         "Diagnostic released",                  /* 0x00A0 */
 226 };
 227
 228 struct mprs_pass_thru {
 229         uint64_t        PtrRequest;
 230         uint64_t        PtrReply;
 231         uint64_t        PtrData;
 232         uint32_t        RequestSize;
 233         uint32_t        ReplySize;
 234         uint32_t        DataSize;
 235         uint32_t        DataDirection;
 236         uint64_t        PtrDataOut;
 237         uint32_t        DataOutSize;
 238         uint32_t        Timeout;
 239 };
 240
 241 struct mprs_btdh_mapping {
 242         uint16_t        TargetID;
 243         uint16_t        Bus;
 244         uint16_t        DevHandle;
 245         uint16_t        Reserved;
 246 };
 247
 248 const char *
 249 mps_ioc_status(U16 IOCStatus)
 250 {
 251         static char buffer[16];
 252
 253         IOCStatus &= MPI2_IOCSTATUS_MASK;
 254         if (IOCStatus < sizeof(mps_ioc_status_codes) / sizeof(char *) &&
 255             mps_ioc_status_codes[IOCStatus] != NULL)
 256                 return (mps_ioc_status_codes[IOCStatus]);
 257         snprintf(buffer, sizeof(buffer), "Status: 0x%04x", IOCStatus);
 258         return (buffer);
 259 }
 260
 261 #ifdef USE_MPT_IOCTLS
 262 int
 263 mps_map_btdh(int fd, uint16_t *devhandle, uint16_t *bus, uint16_t *target)
 264 {
 265         int error;
 266         struct mprs_btdh_mapping map;
 267
 268         map.Bus = *bus;
 269         map.TargetID = *target;
 270         map.DevHandle = *devhandle;
 271
 272         if ((error = ioctl(fd, MPTIOCTL_BTDH_MAPPING, &map)) != 0) {
 273                 error = errno;
 274                 warn("Failed to map bus/target/device");
 275                 return (error);
 276         }
 277
 278         *bus = map.Bus;
 279         *target = map.TargetID;
 280         *devhandle = map.DevHandle;
 281
 282         return (0);
 283 }
 284
 285 int
 286 mps_read_config_page_header(int fd, U8 PageType, U8 PageNumber, U32 PageAddress,
 287     MPI2_CONFIG_PAGE_HEADER *header, U16 *IOCStatus)
 288 {
 289         MPI2_CONFIG_REQUEST req;
 290         MPI2_CONFIG_REPLY reply;
 291
 292         bzero(&req, sizeof(req));
 293         req.Function = MPI2_FUNCTION_CONFIG;
 294         req.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 295         req.Header.PageType = PageType;
 296         req.Header.PageNumber = PageNumber;
 297         req.PageAddress = PageAddress;
 298
 299         if (mps_pass_command(fd, &req, sizeof(req), &reply, sizeof(reply),
 300             NULL, 0, NULL, 0, 30))
 301                 return (errno);
 302
 303         if (!IOC_STATUS_SUCCESS(reply.IOCStatus)) {
 304                 if (IOCStatus != NULL)
 305                         *IOCStatus = reply.IOCStatus;
 306                 return (EIO);
 307         }
 308         if (header == NULL)
 309                 return (EINVAL);
 310         *header = reply.Header;
 311         return (0);
 312 }
 313
 314 int
 315 mps_read_ext_config_page_header(int fd, U8 ExtPageType, U8 PageNumber, U32 PageAddress, MPI2_CONFIG_PAGE_HEADER *header, U16 *ExtPageLength, U16 *IOCStatus)
 316 {
 317         MPI2_CONFIG_REQUEST req;
 318         MPI2_CONFIG_REPLY reply;
 319
 320         bzero(&req, sizeof(req));
 321         req.Function = MPI2_FUNCTION_CONFIG;
 322         req.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
 323         req.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
 324         req.ExtPageType = ExtPageType;
 325         req.Header.PageNumber = PageNumber;
 326         req.PageAddress = PageAddress;
 327
 328         if (mps_pass_command(fd, &req, sizeof(req), &reply, sizeof(reply),
 329             NULL, 0, NULL, 0, 30))
 330                 return (errno);
 331
 332         if (!IOC_STATUS_SUCCESS(reply.IOCStatus)) {
 333                 if (IOCStatus != NULL)
 334                         *IOCStatus = reply.IOCStatus;
 335                 return (EIO);
 336         }
 337         if ((header == NULL) || (ExtPageLength == NULL))
 338                 return (EINVAL);
 339         *header = reply.Header;
 340         *ExtPageLength = reply.ExtPageLength;
 341         return (0);
 342 }
 343
 344 void *
 345 mps_read_config_page(int fd, U8 PageType, U8 PageNumber, U32 PageAddress,
 346     U16 *IOCStatus)
 347 {
 348         MPI2_CONFIG_REQUEST req;
 349         MPI2_CONFIG_PAGE_HEADER header;
 350         MPI2_CONFIG_REPLY reply;
 351         void *buf;
 352         int error, len;
 353
 354         bzero(&header, sizeof(header));
 355         error = mps_read_config_page_header(fd, PageType, PageNumber,
 356             PageAddress, &header, IOCStatus);
 357         if (error) {
 358                 errno = error;
 359                 return (NULL);
 360         }
 361
 362         bzero(&req, sizeof(req));
 363         req.Function = MPI2_FUNCTION_CONFIG;
 364         req.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 365         req.PageAddress = PageAddress;
 366         req.Header = header;
 367         if (req.Header.PageLength == 0)
 368                 req.Header.PageLength = 4;
 369
 370         len = req.Header.PageLength * 4;
 371         buf = malloc(len);
 372         if (mps_pass_command(fd, &req, sizeof(req), &reply, sizeof(reply),
 373             buf, len, NULL, 0, 30)) {
 374                 error = errno;
 375                 free(buf);
 376                 errno = error;
 377                 return (NULL);
 378         }
 379         if (!IOC_STATUS_SUCCESS(reply.IOCStatus)) {
 380                 if (IOCStatus != NULL)
 381                         *IOCStatus = reply.IOCStatus;
 382                 else
 383                         warnx("Reading config page failed: 0x%x %s",
 384                             reply.IOCStatus, mps_ioc_status(reply.IOCStatus));
 385                 free(buf);
 386                 errno = EIO;
 387                 return (NULL);
 388         }
 389         return (buf);
 390 }
 391
 392 void *
 393 mps_read_extended_config_page(int fd, U8 ExtPageType, U8 PageVersion,
 394     U8 PageNumber, U32 PageAddress, U16 *IOCStatus)
 395 {
 396         MPI2_CONFIG_REQUEST req;
 397         MPI2_CONFIG_PAGE_HEADER header;
 398         MPI2_CONFIG_REPLY reply;
 399         U16 pagelen;
 400         void *buf;
 401         int error, len;
 402
 403         if (IOCStatus != NULL)
 404                 *IOCStatus = MPI2_IOCSTATUS_SUCCESS;
 405         bzero(&header, sizeof(header));
 406         error = mps_read_ext_config_page_header(fd, ExtPageType, PageNumber,
 407             PageAddress, &header, &pagelen, IOCStatus);
 408         if (error) {
 409                 errno = error;
 410                 return (NULL);
 411         }
 412
 413         bzero(&req, sizeof(req));
 414         req.Function = MPI2_FUNCTION_CONFIG;
 415         req.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
 416         req.PageAddress = PageAddress;
 417         req.Header = header;
 418         if (pagelen == 0)
 419                 pagelen = 4;
 420         req.ExtPageLength = pagelen;
 421         req.ExtPageType = ExtPageType;
 422
 423         len = pagelen * 4;
 424         buf = malloc(len);
 425         if (mps_pass_command(fd, &req, sizeof(req), &reply, sizeof(reply),
 426             buf, len, NULL, 0, 30)) {
 427                 error = errno;
 428                 free(buf);
 429                 errno = error;
 430                 return (NULL);
 431         }
 432         if (!IOC_STATUS_SUCCESS(reply.IOCStatus)) {
 433                 if (IOCStatus != NULL)
 434                         *IOCStatus = reply.IOCStatus;
 435                 else
 436                         warnx("Reading extended config page failed: %s",
 437                             mps_ioc_status(reply.IOCStatus));
 438                 free(buf);
 439                 errno = EIO;
 440                 return (NULL);
 441         }
 442         return (buf);
 443 }
 444
 445 int
 446 mps_firmware_send(int fd, unsigned char *fw, uint32_t len, bool bios)
 447 {
 448         MPI2_FW_DOWNLOAD_REQUEST req;
 449         MPI2_FW_DOWNLOAD_REPLY reply;
 450
 451         bzero(&req, sizeof(req));
 452         bzero(&reply, sizeof(reply));
 453         req.Function = MPI2_FUNCTION_FW_DOWNLOAD;
 454         req.ImageType = bios ? MPI2_FW_DOWNLOAD_ITYPE_BIOS : MPI2_FW_DOWNLOAD_ITYPE_FW;
 455         req.TotalImageSize = len;
 456         req.MsgFlags = MPI2_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
 457
 458         if (mps_user_command(fd, &req, sizeof(req), &reply, sizeof(reply),
 459             fw, len, 0)) {
 460                 return (-1);
 461         }
 462         return (0);
 463 }
 464
 465 int
 466 mps_firmware_get(int fd, unsigned char **firmware, bool bios)
 467 {
 468         MPI2_FW_UPLOAD_REQUEST req;
 469         MPI2_FW_UPLOAD_REPLY reply;
 470         int size;
 471
 472         *firmware = NULL;
 473         bzero(&req, sizeof(req));
 474         bzero(&reply, sizeof(reply));
 475         req.Function = MPI2_FUNCTION_FW_UPLOAD;
 476         req.ImageType = bios ? MPI2_FW_DOWNLOAD_ITYPE_BIOS : MPI2_FW_DOWNLOAD_ITYPE_FW;
 477
 478         if (mps_user_command(fd, &req, sizeof(req), &reply, sizeof(reply),
 479             NULL, 0, 0)) {
 480                 return (-1);
 481         }
 482         if (reply.ActualImageSize == 0) {
 483                 return (-1);
 484         }
 485
 486         size = reply.ActualImageSize;
 487         *firmware = calloc(size, sizeof(unsigned char));
 488         if (*firmware == NULL) {
 489                 warn("calloc");
 490                 return (-1);
 491         }
 492         if (mps_user_command(fd, &req, sizeof(req), &reply, sizeof(reply),
 493             *firmware, size, 0)) {
 494                 free(*firmware);
 495                 return (-1);
 496         }
 497
 498         return (size);
 499 }
 500
 501 #else
 502
 503 int
 504 mps_read_config_page_header(int fd, U8 PageType, U8 PageNumber, U32 PageAddress,
 505     MPI2_CONFIG_PAGE_HEADER *header, U16 *IOCStatus)
 506 {
 507         struct mps_cfg_page_req req;
 508
 509         if (IOCStatus != NULL)
 510                 *IOCStatus = MPI2_IOCSTATUS_SUCCESS;
 511         if (header == NULL)
 512                 return (EINVAL);
 513         bzero(&req, sizeof(req));
 514         req.header.PageType = PageType;
 515         req.header.PageNumber = PageNumber;
 516         req.page_address = PageAddress;
 517         if (ioctl(fd, MPSIO_READ_CFG_HEADER, &req) < 0)
 518                 return (errno);
 519         if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
 520                 if (IOCStatus != NULL)
 521                         *IOCStatus = req.ioc_status;
 522                 return (EIO);
 523         }
 524         bcopy(&req.header, header, sizeof(*header));
 525         return (0);
 526 }
 527
 528 void *
 529 mps_read_config_page(int fd, U8 PageType, U8 PageNumber, U32 PageAddress,
 530     U16 *IOCStatus)
 531 {
 532         struct mps_cfg_page_req req;
 533         void *buf;
 534         int error;
 535
 536         error = mps_read_config_page_header(fd, PageType, PageNumber,
 537             PageAddress, &req.header, IOCStatus);
 538         if (error) {
 539                 errno = error;
 540                 return (NULL);
 541         }
 542
 543         if (req.header.PageLength == 0)
 544                 req.header.PageLength = 4;
 545         req.len = req.header.PageLength * 4;
 546         buf = malloc(req.len);
 547         req.buf = buf;
 548         bcopy(&req.header, buf, sizeof(req.header));
 549         if (ioctl(fd, MPSIO_READ_CFG_PAGE, &req) < 0) {
 550                 error = errno;
 551                 free(buf);
 552                 errno = error;
 553                 return (NULL);
 554         }
 555         if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
 556                 if (IOCStatus != NULL)
 557                         *IOCStatus = req.ioc_status;
 558                 else
 559                         warnx("Reading config page failed: 0x%x %s",
 560                             req.ioc_status, mps_ioc_status(req.ioc_status));
 561                 free(buf);
 562                 errno = EIO;
 563                 return (NULL);
 564         }
 565         return (buf);
 566 }
 567
 568 void *
 569 mps_read_extended_config_page(int fd, U8 ExtPageType, U8 PageVersion,
 570     U8 PageNumber, U32 PageAddress, U16 *IOCStatus)
 571 {
 572         struct mps_ext_cfg_page_req req;
 573         void *buf;
 574         int error;
 575
 576         if (IOCStatus != NULL)
 577                 *IOCStatus = MPI2_IOCSTATUS_SUCCESS;
 578         bzero(&req, sizeof(req));
 579         req.header.PageVersion = PageVersion;
 580         req.header.PageNumber = PageNumber;
 581         req.header.ExtPageType = ExtPageType;
 582         req.page_address = PageAddress;
 583         if (ioctl(fd, MPSIO_READ_EXT_CFG_HEADER, &req) < 0)
 584                 return (NULL);
 585         if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
 586                 if (IOCStatus != NULL)
 587                         *IOCStatus = req.ioc_status;
 588                 else
 589                         warnx("Reading extended config page header failed: %s",
 590                             mps_ioc_status(req.ioc_status));
 591                 errno = EIO;
 592                 return (NULL);
 593         }
 594         req.len = req.header.ExtPageLength * 4;
 595         buf = malloc(req.len);
 596         req.buf = buf;
 597         bcopy(&req.header, buf, sizeof(req.header));
 598         if (ioctl(fd, MPSIO_READ_EXT_CFG_PAGE, &req) < 0) {
 599                 error = errno;
 600                 free(buf);
 601                 errno = error;
 602                 return (NULL);
 603         }
 604         if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
 605                 if (IOCStatus != NULL)
 606                         *IOCStatus = req.ioc_status;
 607                 else
 608                         warnx("Reading extended config page failed: %s",
 609                             mps_ioc_status(req.ioc_status));
 610                 free(buf);
 611                 errno = EIO;
 612                 return (NULL);
 613         }
 614         return (buf);
 615 }
 616 #endif
 617
 618 int
 619 mps_open(int unit)
 620 {
 621         char path[MAXPATHLEN];
 622
 623         snprintf(path, sizeof(path), "/dev/mp%s%d", is_mps ? "s": "r", unit);
 624         return (open(path, O_RDWR));
 625 }
 626
 627 int
 628 mps_user_command(int fd, void *req, uint32_t req_len, void *reply,
 629         uint32_t reply_len, void *buffer, int len, uint32_t flags)
 630 {
 631         struct mps_usr_command cmd;
 632
 633         bzero(&cmd, sizeof(struct mps_usr_command));
 634         cmd.req = req;
 635         cmd.req_len = req_len;
 636         cmd.rpl = reply;
 637         cmd.rpl_len = reply_len;
 638         cmd.buf = buffer;
 639         cmd.len = len;
 640         cmd.flags = flags;
 641
 642         if (ioctl(fd, is_mps ? MPSIO_MPS_COMMAND : MPRIO_MPR_COMMAND, &cmd) < 0)
 643                 return (errno);
 644         return (0);
 645 }
 646
 647 int
 648 mps_pass_command(int fd, void *req, uint32_t req_len, void *reply,
 649         uint32_t reply_len, void *data_in, uint32_t datain_len, void *data_out,
 650         uint32_t dataout_len, uint32_t timeout)
 651 {
 652         struct mprs_pass_thru pass;
 653
 654         pass.PtrRequest = (uint64_t)(uintptr_t)req;
 655         pass.PtrReply = (uint64_t)(uintptr_t)reply;
 656         pass.PtrData = (uint64_t)(uintptr_t)data_in;
 657         pass.PtrDataOut = (uint64_t)(uintptr_t)data_out;
 658         pass.RequestSize = req_len;
 659         pass.ReplySize = reply_len;
 660         pass.DataSize = datain_len;
 661         pass.DataOutSize = dataout_len;
 662         if (datain_len && dataout_len) {
 663                 if (is_mps) {
 664                         pass.DataDirection = MPS_PASS_THRU_DIRECTION_BOTH;
 665                 } else {
 666                         pass.DataDirection = MPR_PASS_THRU_DIRECTION_BOTH;
 667                 }
 668         } else if (datain_len) {
 669                 if (is_mps) {
 670                         pass.DataDirection = MPS_PASS_THRU_DIRECTION_READ;
 671                 } else {
 672                         pass.DataDirection = MPR_PASS_THRU_DIRECTION_READ;
 673                 }
 674         } else if (dataout_len) {
 675                 if (is_mps) {
 676                         pass.DataDirection = MPS_PASS_THRU_DIRECTION_WRITE;
 677                 } else {
 678                         pass.DataDirection = MPR_PASS_THRU_DIRECTION_WRITE;
 679                 }
 680         } else {
 681                 if (is_mps) {
 682                         pass.DataDirection = MPS_PASS_THRU_DIRECTION_NONE;
 683                 } else {
 684                         pass.DataDirection = MPR_PASS_THRU_DIRECTION_NONE;
 685                 }
 686         }
 687         pass.Timeout = timeout;
 688
 689         if (ioctl(fd, MPTIOCTL_PASS_THRU, &pass) < 0)
 690                 return (errno);
 691         return (0);
 692 }
 693
 694 MPI2_IOC_FACTS_REPLY *
 695 mps_get_iocfacts(int fd)
 696 {
 697         MPI2_IOC_FACTS_REPLY *facts;
 698         MPI2_IOC_FACTS_REQUEST req;
 699         int error;
 700
 701         facts = malloc(sizeof(MPI2_IOC_FACTS_REPLY));
 702         if (facts == NULL) {
 703                 errno = ENOMEM;
 704                 return (NULL);
 705         }
 706
 707         bzero(&req, sizeof(MPI2_IOC_FACTS_REQUEST));
 708         req.Function = MPI2_FUNCTION_IOC_FACTS;
 709
 710 #if 1
 711         error = mps_pass_command(fd, &req, sizeof(MPI2_IOC_FACTS_REQUEST),
 712             facts, sizeof(MPI2_IOC_FACTS_REPLY), NULL, 0, NULL, 0, 10);
 713 #else
 714         error = mps_user_command(fd, &req, sizeof(MPI2_IOC_FACTS_REQUEST),
 715             facts, sizeof(MPI2_IOC_FACTS_REPLY), NULL, 0, 0);
 716 #endif
 717         if (error) {
 718                 free(facts);
 719                 return (NULL);
 720         }
 721
 722         if (!IOC_STATUS_SUCCESS(facts->IOCStatus)) {
 723                 free(facts);
 724                 errno = EINVAL;
 725                 return (NULL);
 726         }
 727         return (facts);
 728 }
 729