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