xref: /dragonfly/usr.sbin/mpsutil/mps_cmd.c (revision e6d22e9b) 
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: head/usr.sbin/mpsutil/mps_cmd.c 321604 2017-07-27 05:31:48Z scottl $");
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 	if (req.Header.PageLength == 0)
369 		req.Header.PageLength = 4;
370 
371 	len = req.Header.PageLength * 4;
372 	buf = malloc(len);
373 	if (mps_pass_command(fd, &req, sizeof(req), &reply, sizeof(reply),
374 	    buf, len, NULL, 0, 30)) {
375 		error = errno;
376 		free(buf);
377 		errno = error;
378 		return (NULL);
379 	}
380 	if (!IOC_STATUS_SUCCESS(reply.IOCStatus)) {
381 		if (IOCStatus != NULL)
382 			*IOCStatus = reply.IOCStatus;
383 		else
384 			warnx("Reading config page failed: 0x%x %s",
385 			    reply.IOCStatus, mps_ioc_status(reply.IOCStatus));
386 		free(buf);
387 		errno = EIO;
388 		return (NULL);
389 	}
390 	return (buf);
391 }
392 
393 void *
394 mps_read_extended_config_page(int fd, U8 ExtPageType, U8 PageVersion,
395     U8 PageNumber, U32 PageAddress, U16 *IOCStatus)
396 {
397 	MPI2_CONFIG_REQUEST req;
398 	MPI2_CONFIG_PAGE_HEADER header;
399 	MPI2_CONFIG_REPLY reply;
400 	U16 pagelen;
401 	void *buf;
402 	int error, len;
403 
404 	if (IOCStatus != NULL)
405 		*IOCStatus = MPI2_IOCSTATUS_SUCCESS;
406 	bzero(&header, sizeof(header));
407 	error = mps_read_ext_config_page_header(fd, ExtPageType, PageNumber,
408 	    PageAddress, &header, &pagelen, IOCStatus);
409 	if (error) {
410 		errno = error;
411 		return (NULL);
412 	}
413 
414 	bzero(&req, sizeof(req));
415 	req.Function = MPI2_FUNCTION_CONFIG;
416 	req.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
417 	req.PageAddress = PageAddress;
418 	req.Header = header;
419 	if (pagelen == 0)
420 		pagelen = 4;
421 	req.ExtPageLength = pagelen;
422 	req.ExtPageType = ExtPageType;
423 
424 	len = pagelen * 4;
425 	buf = malloc(len);
426 	if (mps_pass_command(fd, &req, sizeof(req), &reply, sizeof(reply),
427 	    buf, len, NULL, 0, 30)) {
428 		error = errno;
429 		free(buf);
430 		errno = error;
431 		return (NULL);
432 	}
433 	if (!IOC_STATUS_SUCCESS(reply.IOCStatus)) {
434 		if (IOCStatus != NULL)
435 			*IOCStatus = reply.IOCStatus;
436 		else
437 			warnx("Reading extended config page failed: %s",
438 			    mps_ioc_status(reply.IOCStatus));
439 		free(buf);
440 		errno = EIO;
441 		return (NULL);
442 	}
443 	return (buf);
444 }
445 
446 int
447 mps_firmware_send(int fd, unsigned char *fw, uint32_t len, bool bios)
448 {
449 	MPI2_FW_DOWNLOAD_REQUEST req;
450 	MPI2_FW_DOWNLOAD_REPLY reply;
451 
452 	bzero(&req, sizeof(req));
453 	bzero(&reply, sizeof(reply));
454 	req.Function = MPI2_FUNCTION_FW_DOWNLOAD;
455 	req.ImageType = bios ? MPI2_FW_DOWNLOAD_ITYPE_BIOS : MPI2_FW_DOWNLOAD_ITYPE_FW;
456 	req.TotalImageSize = len;
457 	req.MsgFlags = MPI2_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT;
458 
459 	if (mps_user_command(fd, &req, sizeof(req), &reply, sizeof(reply),
460 	    fw, len, 0)) {
461 		return (-1);
462 	}
463 	return (0);
464 }
465 
466 int
467 mps_firmware_get(int fd, unsigned char **firmware, bool bios)
468 {
469 	MPI2_FW_UPLOAD_REQUEST req;
470 	MPI2_FW_UPLOAD_REPLY reply;
471 	int size;
472 
473 	*firmware = NULL;
474 	bzero(&req, sizeof(req));
475 	bzero(&reply, sizeof(reply));
476 	req.Function = MPI2_FUNCTION_FW_UPLOAD;
477 	req.ImageType = bios ? MPI2_FW_DOWNLOAD_ITYPE_BIOS : MPI2_FW_DOWNLOAD_ITYPE_FW;
478 
479 	if (mps_user_command(fd, &req, sizeof(req), &reply, sizeof(reply),
480 	    NULL, 0, 0)) {
481 		return (-1);
482 	}
483 	if (reply.ActualImageSize == 0) {
484 		return (-1);
485 	}
486 
487 	size = reply.ActualImageSize;
488 	*firmware = calloc(size, sizeof(unsigned char));
489 	if (*firmware == NULL) {
490 		warn("calloc");
491 		return (-1);
492 	}
493 	if (mps_user_command(fd, &req, sizeof(req), &reply, sizeof(reply),
494 	    *firmware, size, 0)) {
495 		free(*firmware);
496 		return (-1);
497 	}
498 
499 	return (size);
500 }
501 
502 #else
503 
504 int
505 mps_read_config_page_header(int fd, U8 PageType, U8 PageNumber, U32 PageAddress,
506     MPI2_CONFIG_PAGE_HEADER *header, U16 *IOCStatus)
507 {
508 	struct mps_cfg_page_req req;
509 
510 	if (IOCStatus != NULL)
511 		*IOCStatus = MPI2_IOCSTATUS_SUCCESS;
512 	if (header == NULL)
513 		return (EINVAL);
514 	bzero(&req, sizeof(req));
515 	req.header.PageType = PageType;
516 	req.header.PageNumber = PageNumber;
517 	req.page_address = PageAddress;
518 	if (ioctl(fd, MPSIO_READ_CFG_HEADER, &req) < 0)
519 		return (errno);
520 	if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
521 		if (IOCStatus != NULL)
522 			*IOCStatus = req.ioc_status;
523 		return (EIO);
524 	}
525 	bcopy(&req.header, header, sizeof(*header));
526 	return (0);
527 }
528 
529 void *
530 mps_read_config_page(int fd, U8 PageType, U8 PageNumber, U32 PageAddress,
531     U16 *IOCStatus)
532 {
533 	struct mps_cfg_page_req req;
534 	void *buf;
535 	int error;
536 
537 	error = mps_read_config_page_header(fd, PageType, PageNumber,
538 	    PageAddress, &req.header, IOCStatus);
539 	if (error) {
540 		errno = error;
541 		return (NULL);
542 	}
543 
544 	if (req.header.PageLength == 0)
545 		req.header.PageLength = 4;
546 	req.len = req.header.PageLength * 4;
547 	buf = malloc(req.len);
548 	req.buf = buf;
549 	bcopy(&req.header, buf, sizeof(req.header));
550 	if (ioctl(fd, MPSIO_READ_CFG_PAGE, &req) < 0) {
551 		error = errno;
552 		free(buf);
553 		errno = error;
554 		return (NULL);
555 	}
556 	if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
557 		if (IOCStatus != NULL)
558 			*IOCStatus = req.ioc_status;
559 		else
560 			warnx("Reading config page failed: 0x%x %s",
561 			    req.ioc_status, mps_ioc_status(req.ioc_status));
562 		free(buf);
563 		errno = EIO;
564 		return (NULL);
565 	}
566 	return (buf);
567 }
568 
569 void *
570 mps_read_extended_config_page(int fd, U8 ExtPageType, U8 PageVersion,
571     U8 PageNumber, U32 PageAddress, U16 *IOCStatus)
572 {
573 	struct mps_ext_cfg_page_req req;
574 	void *buf;
575 	int error;
576 
577 	if (IOCStatus != NULL)
578 		*IOCStatus = MPI2_IOCSTATUS_SUCCESS;
579 	bzero(&req, sizeof(req));
580 	req.header.PageVersion = PageVersion;
581 	req.header.PageNumber = PageNumber;
582 	req.header.ExtPageType = ExtPageType;
583 	req.page_address = PageAddress;
584 	if (ioctl(fd, MPSIO_READ_EXT_CFG_HEADER, &req) < 0)
585 		return (NULL);
586 	if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
587 		if (IOCStatus != NULL)
588 			*IOCStatus = req.ioc_status;
589 		else
590 			warnx("Reading extended config page header failed: %s",
591 			    mps_ioc_status(req.ioc_status));
592 		errno = EIO;
593 		return (NULL);
594 	}
595 	req.len = req.header.ExtPageLength * 4;
596 	buf = malloc(req.len);
597 	req.buf = buf;
598 	bcopy(&req.header, buf, sizeof(req.header));
599 	if (ioctl(fd, MPSIO_READ_EXT_CFG_PAGE, &req) < 0) {
600 		error = errno;
601 		free(buf);
602 		errno = error;
603 		return (NULL);
604 	}
605 	if (!IOC_STATUS_SUCCESS(req.ioc_status)) {
606 		if (IOCStatus != NULL)
607 			*IOCStatus = req.ioc_status;
608 		else
609 			warnx("Reading extended config page failed: %s",
610 			    mps_ioc_status(req.ioc_status));
611 		free(buf);
612 		errno = EIO;
613 		return (NULL);
614 	}
615 	return (buf);
616 }
617 #endif
618 
619 int
620 mps_open(int unit)
621 {
622 	char path[MAXPATHLEN];
623 
624 	snprintf(path, sizeof(path), "/dev/mp%s%d", is_mps ? "s": "r", unit);
625 	return (open(path, O_RDWR));
626 }
627 
628 int
629 mps_user_command(int fd, void *req, uint32_t req_len, void *reply,
630         uint32_t reply_len, void *buffer, int len, uint32_t flags)
631 {
632 	struct mps_usr_command cmd;
633 
634 	bzero(&cmd, sizeof(struct mps_usr_command));
635 	cmd.req = req;
636 	cmd.req_len = req_len;
637 	cmd.rpl = reply;
638 	cmd.rpl_len = reply_len;
639 	cmd.buf = buffer;
640 	cmd.len = len;
641 	cmd.flags = flags;
642 
643 	if (ioctl(fd, is_mps ? MPSIO_MPS_COMMAND : MPRIO_MPR_COMMAND, &cmd) < 0)
644 		return (errno);
645 	return (0);
646 }
647 
648 int
649 mps_pass_command(int fd, void *req, uint32_t req_len, void *reply,
650 	uint32_t reply_len, void *data_in, uint32_t datain_len, void *data_out,
651 	uint32_t dataout_len, uint32_t timeout)
652 {
653 	struct mprs_pass_thru pass;
654 
655 	pass.PtrRequest = (uint64_t)(uintptr_t)req;
656 	pass.PtrReply = (uint64_t)(uintptr_t)reply;
657 	pass.PtrData = (uint64_t)(uintptr_t)data_in;
658 	pass.PtrDataOut = (uint64_t)(uintptr_t)data_out;
659 	pass.RequestSize = req_len;
660 	pass.ReplySize = reply_len;
661 	pass.DataSize = datain_len;
662 	pass.DataOutSize = dataout_len;
663 	if (datain_len && dataout_len) {
664 		if (is_mps) {
665 			pass.DataDirection = MPS_PASS_THRU_DIRECTION_BOTH;
666 		} else {
667 			pass.DataDirection = MPR_PASS_THRU_DIRECTION_BOTH;
668 		}
669 	} else if (datain_len) {
670 		if (is_mps) {
671 			pass.DataDirection = MPS_PASS_THRU_DIRECTION_READ;
672 		} else {
673 			pass.DataDirection = MPR_PASS_THRU_DIRECTION_READ;
674 		}
675 	} else if (dataout_len) {
676 		if (is_mps) {
677 			pass.DataDirection = MPS_PASS_THRU_DIRECTION_WRITE;
678 		} else {
679 			pass.DataDirection = MPR_PASS_THRU_DIRECTION_WRITE;
680 		}
681 	} else {
682 		if (is_mps) {
683 			pass.DataDirection = MPS_PASS_THRU_DIRECTION_NONE;
684 		} else {
685 			pass.DataDirection = MPR_PASS_THRU_DIRECTION_NONE;
686 		}
687 	}
688 	pass.Timeout = timeout;
689 
690 	if (ioctl(fd, MPTIOCTL_PASS_THRU, &pass) < 0)
691 		return (errno);
692 	return (0);
693 }
694 
695 MPI2_IOC_FACTS_REPLY *
696 mps_get_iocfacts(int fd)
697 {
698 	MPI2_IOC_FACTS_REPLY *facts;
699 	MPI2_IOC_FACTS_REQUEST req;
700 	int error;
701 
702 	facts = malloc(sizeof(MPI2_IOC_FACTS_REPLY));
703 	if (facts == NULL) {
704 		errno = ENOMEM;
705 		return (NULL);
706 	}
707 
708 	bzero(&req, sizeof(MPI2_IOC_FACTS_REQUEST));
709 	req.Function = MPI2_FUNCTION_IOC_FACTS;
710 
711 #if 1
712 	error = mps_pass_command(fd, &req, sizeof(MPI2_IOC_FACTS_REQUEST),
713 	    facts, sizeof(MPI2_IOC_FACTS_REPLY), NULL, 0, NULL, 0, 10);
714 #else
715 	error = mps_user_command(fd, &req, sizeof(MPI2_IOC_FACTS_REQUEST),
716 	    facts, sizeof(MPI2_IOC_FACTS_REPLY), NULL, 0, 0);
717 #endif
718 	if (error) {
719 		free(facts);
720 		return (NULL);
721 	}
722 
723 	if (!IOC_STATUS_SUCCESS(facts->IOCStatus)) {
724 		free(facts);
725 		errno = EINVAL;
726 		return (NULL);
727 	}
728 	return (facts);
729 }
730 
731