2 * Copyright (c) 2008 Yahoo!, Inc.
4 * Written by: John Baldwin <jhb@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of the author nor the names of any co-contributors
15 * may be used to endorse or promote products derived from this software
16 * without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * LSI MPS-Fusion Host Adapter FreeBSD userland interface
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
36 #include "opt_compat.h"
38 #include <sys/types.h>
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/kernel.h>
42 #include <sys/selinfo.h>
43 #include <sys/module.h>
47 #include <sys/malloc.h>
49 #include <sys/sysctl.h>
50 #include <sys/ioccom.h>
51 #include <sys/endian.h>
53 #include <sys/sysent.h>
55 #include <machine/bus.h>
56 #include <machine/resource.h>
59 #include <cam/scsi/scsi_all.h>
61 #include <dev/mps/mpi/mpi2_type.h>
62 #include <dev/mps/mpi/mpi2.h>
63 #include <dev/mps/mpi/mpi2_ioc.h>
64 #include <dev/mps/mpi/mpi2_cnfg.h>
65 #include <dev/mps/mpsvar.h>
66 #include <dev/mps/mps_table.h>
67 #include <dev/mps/mps_ioctl.h>
69 static d_open_t mps_open;
70 static d_close_t mps_close;
71 static d_ioctl_t mps_ioctl_devsw;
73 static struct cdevsw mps_cdevsw = {
74 .d_version = D_VERSION,
78 .d_ioctl = mps_ioctl_devsw,
82 typedef int (mps_user_f)(struct mps_command *, struct mps_usr_command *);
83 static mps_user_f mpi_pre_ioc_facts;
84 static mps_user_f mpi_pre_port_facts;
85 static mps_user_f mpi_pre_fw_download;
86 static mps_user_f mpi_pre_fw_upload;
87 static mps_user_f mpi_pre_sata_passthrough;
88 static mps_user_f mpi_pre_smp_passthrough;
89 static mps_user_f mpi_pre_config;
90 static mps_user_f mpi_pre_sas_io_unit_control;
92 static int mps_user_read_cfg_header(struct mps_softc *,
93 struct mps_cfg_page_req *);
94 static int mps_user_read_cfg_page(struct mps_softc *,
95 struct mps_cfg_page_req *, void *);
96 static int mps_user_read_extcfg_header(struct mps_softc *,
97 struct mps_ext_cfg_page_req *);
98 static int mps_user_read_extcfg_page(struct mps_softc *,
99 struct mps_ext_cfg_page_req *, void *);
100 static int mps_user_write_cfg_page(struct mps_softc *,
101 struct mps_cfg_page_req *, void *);
102 static int mps_user_setup_request(struct mps_command *,
103 struct mps_usr_command *);
104 static int mps_user_command(struct mps_softc *, struct mps_usr_command *);
106 static MALLOC_DEFINE(M_MPSUSER, "mps_user", "Buffers for mps(4) ioctls");
109 mps_attach_user(struct mps_softc *sc)
113 unit = device_get_unit(sc->mps_dev);
114 sc->mps_cdev = make_dev(&mps_cdevsw, unit, UID_ROOT, GID_OPERATOR, 0640,
116 if (sc->mps_cdev == NULL) {
119 sc->mps_cdev->si_drv1 = sc;
124 mps_detach_user(struct mps_softc *sc)
127 /* XXX: do a purge of pending requests? */
128 destroy_dev(sc->mps_cdev);
133 mps_open(struct cdev *dev, int flags, int fmt, struct thread *td)
140 mps_close(struct cdev *dev, int flags, int fmt, struct thread *td)
147 mps_user_read_cfg_header(struct mps_softc *sc,
148 struct mps_cfg_page_req *page_req)
150 MPI2_CONFIG_PAGE_HEADER *hdr;
151 struct mps_config_params params;
154 hdr = ¶ms.hdr.Struct;
155 params.action = MPI2_CONFIG_ACTION_PAGE_HEADER;
156 params.page_address = le32toh(page_req->page_address);
157 hdr->PageVersion = 0;
159 hdr->PageNumber = page_req->header.PageNumber;
160 hdr->PageType = page_req->header.PageType;
161 params.buffer = NULL;
163 params.callback = NULL;
165 if ((error = mps_read_config_page(sc, ¶ms)) != 0) {
167 * Leave the request. Without resetting the chip, it's
168 * still owned by it and we'll just get into trouble
169 * freeing it now. Mark it as abandoned so that if it
170 * shows up later it can be freed.
172 mps_printf(sc, "read_cfg_header timed out\n");
176 page_req->ioc_status = htole16(params.status);
177 if ((page_req->ioc_status & MPI2_IOCSTATUS_MASK) ==
178 MPI2_IOCSTATUS_SUCCESS) {
179 bcopy(hdr, &page_req->header, sizeof(page_req->header));
186 mps_user_read_cfg_page(struct mps_softc *sc, struct mps_cfg_page_req *page_req,
189 MPI2_CONFIG_PAGE_HEADER *reqhdr, *hdr;
190 struct mps_config_params params;
194 hdr = ¶ms.hdr.Struct;
195 hdr->PageVersion = reqhdr->PageVersion;
196 hdr->PageLength = reqhdr->PageLength;
197 hdr->PageNumber = reqhdr->PageNumber;
198 hdr->PageType = reqhdr->PageType & MPI2_CONFIG_PAGETYPE_MASK;
199 params.action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
200 params.page_address = le32toh(page_req->page_address);
202 params.length = le32toh(page_req->len);
203 params.callback = NULL;
205 if ((error = mps_read_config_page(sc, ¶ms)) != 0) {
206 mps_printf(sc, "mps_user_read_cfg_page timed out\n");
210 page_req->ioc_status = htole16(params.status);
215 mps_user_read_extcfg_header(struct mps_softc *sc,
216 struct mps_ext_cfg_page_req *ext_page_req)
218 MPI2_CONFIG_EXTENDED_PAGE_HEADER *hdr;
219 struct mps_config_params params;
222 hdr = ¶ms.hdr.Ext;
223 params.action = MPI2_CONFIG_ACTION_PAGE_HEADER;
224 hdr->PageVersion = ext_page_req->header.PageVersion;
225 hdr->ExtPageLength = 0;
226 hdr->PageNumber = ext_page_req->header.PageNumber;
227 hdr->ExtPageType = ext_page_req->header.ExtPageType;
228 params.page_address = le32toh(ext_page_req->page_address);
229 if ((error = mps_read_config_page(sc, ¶ms)) != 0) {
231 * Leave the request. Without resetting the chip, it's
232 * still owned by it and we'll just get into trouble
233 * freeing it now. Mark it as abandoned so that if it
234 * shows up later it can be freed.
236 mps_printf(sc, "mps_user_read_extcfg_header timed out\n");
240 ext_page_req->ioc_status = htole16(params.status);
241 if ((ext_page_req->ioc_status & MPI2_IOCSTATUS_MASK) ==
242 MPI2_IOCSTATUS_SUCCESS) {
243 ext_page_req->header.PageVersion = hdr->PageVersion;
244 ext_page_req->header.PageNumber = hdr->PageNumber;
245 ext_page_req->header.PageType = hdr->PageType;
246 ext_page_req->header.ExtPageLength = hdr->ExtPageLength;
247 ext_page_req->header.ExtPageType = hdr->ExtPageType;
254 mps_user_read_extcfg_page(struct mps_softc *sc,
255 struct mps_ext_cfg_page_req *ext_page_req, void *buf)
257 MPI2_CONFIG_EXTENDED_PAGE_HEADER *reqhdr, *hdr;
258 struct mps_config_params params;
262 hdr = ¶ms.hdr.Ext;
263 params.action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
264 params.page_address = le32toh(ext_page_req->page_address);
265 hdr->PageVersion = reqhdr->PageVersion;
266 hdr->PageNumber = reqhdr->PageNumber;
267 hdr->ExtPageType = reqhdr->ExtPageType;
268 hdr->ExtPageLength = reqhdr->ExtPageLength;
270 params.length = le32toh(ext_page_req->len);
271 params.callback = NULL;
273 if ((error = mps_read_config_page(sc, ¶ms)) != 0) {
274 mps_printf(sc, "mps_user_read_extcfg_page timed out\n");
278 ext_page_req->ioc_status = htole16(params.status);
283 mps_user_write_cfg_page(struct mps_softc *sc,
284 struct mps_cfg_page_req *page_req, void *buf)
286 MPI2_CONFIG_PAGE_HEADER *reqhdr, *hdr;
287 struct mps_config_params params;
292 hdr = ¶ms.hdr.Struct;
293 hdr_attr = reqhdr->PageType & MPI2_CONFIG_PAGEATTR_MASK;
294 if (hdr_attr != MPI2_CONFIG_PAGEATTR_CHANGEABLE &&
295 hdr_attr != MPI2_CONFIG_PAGEATTR_PERSISTENT) {
296 mps_printf(sc, "page type 0x%x not changeable\n",
297 reqhdr->PageType & MPI2_CONFIG_PAGETYPE_MASK);
302 * There isn't any point in restoring stripped out attributes
303 * if you then mask them going down to issue the request.
306 hdr->PageVersion = reqhdr->PageVersion;
307 hdr->PageLength = reqhdr->PageLength;
308 hdr->PageNumber = reqhdr->PageNumber;
309 hdr->PageType = reqhdr->PageType;
310 params.action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
311 params.page_address = le32toh(page_req->page_address);
313 params.length = le32toh(page_req->len);
314 params.callback = NULL;
316 if ((error = mps_write_config_page(sc, ¶ms)) != 0) {
317 mps_printf(sc, "mps_write_cfg_page timed out\n");
321 page_req->ioc_status = htole16(params.status);
326 mpi_init_sge(struct mps_command *cm, void *req, void *sge)
330 space = (int)cm->cm_sc->facts->IOCRequestFrameSize * 4;
331 off = (uintptr_t)sge - (uintptr_t)req;
333 KASSERT(off < space, ("bad pointers %p %p, off %d, space %d",
334 req, sge, off, space));
337 cm->cm_sglsize = space - off;
341 * Prepare the mps_command for an IOC_FACTS request.
344 mpi_pre_ioc_facts(struct mps_command *cm, struct mps_usr_command *cmd)
346 MPI2_IOC_FACTS_REQUEST *req = (void *)cm->cm_req;
347 MPI2_IOC_FACTS_REPLY *rpl;
349 if (cmd->req_len != sizeof *req)
351 if (cmd->rpl_len != sizeof *rpl)
360 * Prepare the mps_command for a PORT_FACTS request.
363 mpi_pre_port_facts(struct mps_command *cm, struct mps_usr_command *cmd)
365 MPI2_PORT_FACTS_REQUEST *req = (void *)cm->cm_req;
366 MPI2_PORT_FACTS_REPLY *rpl;
368 if (cmd->req_len != sizeof *req)
370 if (cmd->rpl_len != sizeof *rpl)
379 * Prepare the mps_command for a FW_DOWNLOAD request.
382 mpi_pre_fw_download(struct mps_command *cm, struct mps_usr_command *cmd)
384 MPI2_FW_DOWNLOAD_REQUEST *req = (void *)cm->cm_req;
385 MPI2_FW_DOWNLOAD_REPLY *rpl;
386 MPI2_FW_DOWNLOAD_TCSGE tc;
390 * This code assumes there is room in the request's SGL for
391 * the TransactionContext plus at least a SGL chain element.
393 CTASSERT(sizeof req->SGL >= sizeof tc + MPS_SGC_SIZE);
395 if (cmd->req_len != sizeof *req)
397 if (cmd->rpl_len != sizeof *rpl)
403 error = copyin(cmd->buf, cm->cm_data, cmd->len);
407 mpi_init_sge(cm, req, &req->SGL);
408 bzero(&tc, sizeof tc);
411 * For now, the F/W image must be provided in a single request.
413 if ((req->MsgFlags & MPI2_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT) == 0)
415 if (req->TotalImageSize != cmd->len)
419 * The value of the first two elements is specified in the
420 * Fusion-MPT Message Passing Interface document.
423 tc.DetailsLength = 12;
425 tc.ImageSize = cmd->len;
427 cm->cm_flags |= MPS_CM_FLAGS_DATAOUT;
429 return (mps_push_sge(cm, &tc, sizeof tc, 0));
433 * Prepare the mps_command for a FW_UPLOAD request.
436 mpi_pre_fw_upload(struct mps_command *cm, struct mps_usr_command *cmd)
438 MPI2_FW_UPLOAD_REQUEST *req = (void *)cm->cm_req;
439 MPI2_FW_UPLOAD_REPLY *rpl;
440 MPI2_FW_UPLOAD_TCSGE tc;
443 * This code assumes there is room in the request's SGL for
444 * the TransactionContext plus at least a SGL chain element.
446 CTASSERT(sizeof req->SGL >= sizeof tc + MPS_SGC_SIZE);
448 if (cmd->req_len != sizeof *req)
450 if (cmd->rpl_len != sizeof *rpl)
453 mpi_init_sge(cm, req, &req->SGL);
455 /* Perhaps just asking what the size of the fw is? */
459 bzero(&tc, sizeof tc);
462 * The value of the first two elements is specified in the
463 * Fusion-MPT Message Passing Interface document.
466 tc.DetailsLength = 12;
468 * XXX Is there any reason to fetch a partial image? I.e. to
469 * set ImageOffset to something other than 0?
472 tc.ImageSize = cmd->len;
474 return (mps_push_sge(cm, &tc, sizeof tc, 0));
478 * Prepare the mps_command for a SATA_PASSTHROUGH request.
481 mpi_pre_sata_passthrough(struct mps_command *cm, struct mps_usr_command *cmd)
483 MPI2_SATA_PASSTHROUGH_REQUEST *req = (void *)cm->cm_req;
484 MPI2_SATA_PASSTHROUGH_REPLY *rpl;
486 if (cmd->req_len != sizeof *req)
488 if (cmd->rpl_len != sizeof *rpl)
491 mpi_init_sge(cm, req, &req->SGL);
496 * Prepare the mps_command for a SMP_PASSTHROUGH request.
499 mpi_pre_smp_passthrough(struct mps_command *cm, struct mps_usr_command *cmd)
501 MPI2_SMP_PASSTHROUGH_REQUEST *req = (void *)cm->cm_req;
502 MPI2_SMP_PASSTHROUGH_REPLY *rpl;
504 if (cmd->req_len != sizeof *req)
506 if (cmd->rpl_len != sizeof *rpl)
509 mpi_init_sge(cm, req, &req->SGL);
514 * Prepare the mps_command for a CONFIG request.
517 mpi_pre_config(struct mps_command *cm, struct mps_usr_command *cmd)
519 MPI2_CONFIG_REQUEST *req = (void *)cm->cm_req;
520 MPI2_CONFIG_REPLY *rpl;
522 if (cmd->req_len != sizeof *req)
524 if (cmd->rpl_len != sizeof *rpl)
527 mpi_init_sge(cm, req, &req->PageBufferSGE);
532 * Prepare the mps_command for a SAS_IO_UNIT_CONTROL request.
535 mpi_pre_sas_io_unit_control(struct mps_command *cm,
536 struct mps_usr_command *cmd)
545 * A set of functions to prepare an mps_command for the various
546 * supported requests.
548 struct mps_user_func {
551 } mps_user_func_list[] = {
552 { MPI2_FUNCTION_IOC_FACTS, mpi_pre_ioc_facts },
553 { MPI2_FUNCTION_PORT_FACTS, mpi_pre_port_facts },
554 { MPI2_FUNCTION_FW_DOWNLOAD, mpi_pre_fw_download },
555 { MPI2_FUNCTION_FW_UPLOAD, mpi_pre_fw_upload },
556 { MPI2_FUNCTION_SATA_PASSTHROUGH, mpi_pre_sata_passthrough },
557 { MPI2_FUNCTION_SMP_PASSTHROUGH, mpi_pre_smp_passthrough},
558 { MPI2_FUNCTION_CONFIG, mpi_pre_config},
559 { MPI2_FUNCTION_SAS_IO_UNIT_CONTROL, mpi_pre_sas_io_unit_control },
560 { 0xFF, NULL } /* list end */
564 mps_user_setup_request(struct mps_command *cm, struct mps_usr_command *cmd)
566 MPI2_REQUEST_HEADER *hdr = (MPI2_REQUEST_HEADER *)cm->cm_req;
567 struct mps_user_func *f;
569 for (f = mps_user_func_list; f->f_pre != NULL; f++) {
570 if (hdr->Function == f->Function)
571 return (f->f_pre(cm, cmd));
577 mps_user_command(struct mps_softc *sc, struct mps_usr_command *cmd)
579 MPI2_REQUEST_HEADER *hdr;
580 MPI2_DEFAULT_REPLY *rpl;
582 struct mps_command *cm = NULL;
587 cm = mps_alloc_command(sc);
590 mps_printf(sc, "mps_user_command: no mps requests\n");
596 hdr = (MPI2_REQUEST_HEADER *)cm->cm_req;
598 mps_dprint(sc, MPS_INFO, "mps_user_command: req %p %d rpl %p %d\n",
599 cmd->req, cmd->req_len, cmd->rpl, cmd->rpl_len );
601 if (cmd->req_len > (int)sc->facts->IOCRequestFrameSize * 4) {
603 goto RetFreeUnlocked;
605 err = copyin(cmd->req, hdr, cmd->req_len);
607 goto RetFreeUnlocked;
609 mps_dprint(sc, MPS_INFO, "mps_user_command: Function %02X "
610 "MsgFlags %02X\n", hdr->Function, hdr->MsgFlags );
612 err = mps_user_setup_request(cm, cmd);
614 mps_printf(sc, "mps_user_command: unsupported function 0x%X\n",
616 goto RetFreeUnlocked;
620 buf = malloc(cmd->len, M_MPSUSER, M_WAITOK|M_ZERO);
622 cm->cm_length = cmd->len;
628 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_WAKEUP;
629 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
632 err = mps_map_command(sc, cm);
634 if (err != 0 && err != EINPROGRESS) {
635 mps_printf(sc, "%s: invalid request: error %d\n",
639 msleep(cm, &sc->mps_mtx, 0, "mpsuser", 0);
641 rpl = (MPI2_DEFAULT_REPLY *)cm->cm_reply;
642 sz = rpl->MsgLength * 4;
644 if (sz > cmd->rpl_len) {
646 "mps_user_command: reply buffer too small %d required %d\n",
653 copyout(rpl, cmd->rpl, sz);
655 copyout(buf, cmd->buf, cmd->len);
656 mps_dprint(sc, MPS_INFO, "mps_user_command: reply size %d\n", sz );
661 mps_free_command(sc, cm);
665 free(buf, M_MPSUSER);
670 mps_ioctl(struct cdev *dev, u_long cmd, void *arg, int flag,
673 struct mps_softc *sc;
674 struct mps_cfg_page_req *page_req;
675 struct mps_ext_cfg_page_req *ext_page_req;
681 page_req = (void *)arg;
682 ext_page_req = (void *)arg;
685 case MPSIO_READ_CFG_HEADER:
687 error = mps_user_read_cfg_header(sc, page_req);
690 case MPSIO_READ_CFG_PAGE:
691 mps_page = malloc(page_req->len, M_MPSUSER, M_WAITOK | M_ZERO);
692 error = copyin(page_req->buf, mps_page,
693 sizeof(MPI2_CONFIG_PAGE_HEADER));
697 error = mps_user_read_cfg_page(sc, page_req, mps_page);
701 error = copyout(mps_page, page_req->buf, page_req->len);
703 case MPSIO_READ_EXT_CFG_HEADER:
705 error = mps_user_read_extcfg_header(sc, ext_page_req);
708 case MPSIO_READ_EXT_CFG_PAGE:
709 mps_page = malloc(ext_page_req->len, M_MPSUSER, M_WAITOK|M_ZERO);
710 error = copyin(ext_page_req->buf, mps_page,
711 sizeof(MPI2_CONFIG_EXTENDED_PAGE_HEADER));
715 error = mps_user_read_extcfg_page(sc, ext_page_req, mps_page);
719 error = copyout(mps_page, ext_page_req->buf, ext_page_req->len);
721 case MPSIO_WRITE_CFG_PAGE:
722 mps_page = malloc(page_req->len, M_MPSUSER, M_WAITOK|M_ZERO);
723 error = copyin(page_req->buf, mps_page, page_req->len);
727 error = mps_user_write_cfg_page(sc, page_req, mps_page);
730 case MPSIO_MPS_COMMAND:
731 error = mps_user_command(sc, (struct mps_usr_command *)arg);
738 if (mps_page != NULL)
739 free(mps_page, M_MPSUSER);
744 #ifdef COMPAT_FREEBSD32
746 /* Macros from compat/freebsd32/freebsd32.h */
747 #define PTRIN(v) (void *)(uintptr_t)(v)
748 #define PTROUT(v) (uint32_t)(uintptr_t)(v)
750 #define CP(src,dst,fld) do { (dst).fld = (src).fld; } while (0)
751 #define PTRIN_CP(src,dst,fld) \
752 do { (dst).fld = PTRIN((src).fld); } while (0)
753 #define PTROUT_CP(src,dst,fld) \
754 do { (dst).fld = PTROUT((src).fld); } while (0)
756 struct mps_cfg_page_req32 {
757 MPI2_CONFIG_PAGE_HEADER header;
758 uint32_t page_address;
764 struct mps_ext_cfg_page_req32 {
765 MPI2_CONFIG_EXTENDED_PAGE_HEADER header;
766 uint32_t page_address;
772 struct mps_raid_action32 {
776 uint8_t phys_disk_num;
777 uint32_t action_data_word;
780 uint32_t volume_status;
781 uint32_t action_data[4];
782 uint16_t action_status;
787 struct mps_usr_command32 {
797 #define MPSIO_READ_CFG_HEADER32 _IOWR('M', 200, struct mps_cfg_page_req32)
798 #define MPSIO_READ_CFG_PAGE32 _IOWR('M', 201, struct mps_cfg_page_req32)
799 #define MPSIO_READ_EXT_CFG_HEADER32 _IOWR('M', 202, struct mps_ext_cfg_page_req32)
800 #define MPSIO_READ_EXT_CFG_PAGE32 _IOWR('M', 203, struct mps_ext_cfg_page_req32)
801 #define MPSIO_WRITE_CFG_PAGE32 _IOWR('M', 204, struct mps_cfg_page_req32)
802 #define MPSIO_RAID_ACTION32 _IOWR('M', 205, struct mps_raid_action32)
803 #define MPSIO_MPS_COMMAND32 _IOWR('M', 210, struct mps_usr_command32)
806 mps_ioctl32(struct cdev *dev, u_long cmd32, void *_arg, int flag,
809 struct mps_cfg_page_req32 *page32 = _arg;
810 struct mps_ext_cfg_page_req32 *ext32 = _arg;
811 struct mps_raid_action32 *raid32 = _arg;
812 struct mps_usr_command32 *user32 = _arg;
814 struct mps_cfg_page_req page;
815 struct mps_ext_cfg_page_req ext;
816 struct mps_raid_action raid;
817 struct mps_usr_command user;
823 case MPSIO_READ_CFG_HEADER32:
824 case MPSIO_READ_CFG_PAGE32:
825 case MPSIO_WRITE_CFG_PAGE32:
826 if (cmd32 == MPSIO_READ_CFG_HEADER32)
827 cmd = MPSIO_READ_CFG_HEADER;
828 else if (cmd32 == MPSIO_READ_CFG_PAGE32)
829 cmd = MPSIO_READ_CFG_PAGE;
831 cmd = MPSIO_WRITE_CFG_PAGE;
832 CP(*page32, arg.page, header);
833 CP(*page32, arg.page, page_address);
834 PTRIN_CP(*page32, arg.page, buf);
835 CP(*page32, arg.page, len);
836 CP(*page32, arg.page, ioc_status);
839 case MPSIO_READ_EXT_CFG_HEADER32:
840 case MPSIO_READ_EXT_CFG_PAGE32:
841 if (cmd32 == MPSIO_READ_EXT_CFG_HEADER32)
842 cmd = MPSIO_READ_EXT_CFG_HEADER;
844 cmd = MPSIO_READ_EXT_CFG_PAGE;
845 CP(*ext32, arg.ext, header);
846 CP(*ext32, arg.ext, page_address);
847 PTRIN_CP(*ext32, arg.ext, buf);
848 CP(*ext32, arg.ext, len);
849 CP(*ext32, arg.ext, ioc_status);
852 case MPSIO_RAID_ACTION32:
853 cmd = MPSIO_RAID_ACTION;
854 CP(*raid32, arg.raid, action);
855 CP(*raid32, arg.raid, volume_bus);
856 CP(*raid32, arg.raid, volume_id);
857 CP(*raid32, arg.raid, phys_disk_num);
858 CP(*raid32, arg.raid, action_data_word);
859 PTRIN_CP(*raid32, arg.raid, buf);
860 CP(*raid32, arg.raid, len);
861 CP(*raid32, arg.raid, volume_status);
862 bcopy(raid32->action_data, arg.raid.action_data,
863 sizeof arg.raid.action_data);
864 CP(*raid32, arg.raid, ioc_status);
865 CP(*raid32, arg.raid, write);
868 case MPSIO_MPS_COMMAND32:
869 cmd = MPSIO_MPS_COMMAND;
870 PTRIN_CP(*user32, arg.user, req);
871 CP(*user32, arg.user, req_len);
872 PTRIN_CP(*user32, arg.user, rpl);
873 CP(*user32, arg.user, rpl_len);
874 PTRIN_CP(*user32, arg.user, buf);
875 CP(*user32, arg.user, len);
876 CP(*user32, arg.user, flags);
882 error = mps_ioctl(dev, cmd, &arg, flag, td);
883 if (error == 0 && (cmd32 & IOC_OUT) != 0) {
885 case MPSIO_READ_CFG_HEADER32:
886 case MPSIO_READ_CFG_PAGE32:
887 case MPSIO_WRITE_CFG_PAGE32:
888 CP(arg.page, *page32, header);
889 CP(arg.page, *page32, page_address);
890 PTROUT_CP(arg.page, *page32, buf);
891 CP(arg.page, *page32, len);
892 CP(arg.page, *page32, ioc_status);
895 case MPSIO_READ_EXT_CFG_HEADER32:
896 case MPSIO_READ_EXT_CFG_PAGE32:
897 CP(arg.ext, *ext32, header);
898 CP(arg.ext, *ext32, page_address);
899 PTROUT_CP(arg.ext, *ext32, buf);
900 CP(arg.ext, *ext32, len);
901 CP(arg.ext, *ext32, ioc_status);
904 case MPSIO_RAID_ACTION32:
905 CP(arg.raid, *raid32, action);
906 CP(arg.raid, *raid32, volume_bus);
907 CP(arg.raid, *raid32, volume_id);
908 CP(arg.raid, *raid32, phys_disk_num);
909 CP(arg.raid, *raid32, action_data_word);
910 PTROUT_CP(arg.raid, *raid32, buf);
911 CP(arg.raid, *raid32, len);
912 CP(arg.raid, *raid32, volume_status);
913 bcopy(arg.raid.action_data, raid32->action_data,
914 sizeof arg.raid.action_data);
915 CP(arg.raid, *raid32, ioc_status);
916 CP(arg.raid, *raid32, write);
919 case MPSIO_MPS_COMMAND32:
920 PTROUT_CP(arg.user, *user32, req);
921 CP(arg.user, *user32, req_len);
922 PTROUT_CP(arg.user, *user32, rpl);
923 CP(arg.user, *user32, rpl_len);
924 PTROUT_CP(arg.user, *user32, buf);
925 CP(arg.user, *user32, len);
926 CP(arg.user, *user32, flags);
933 #endif /* COMPAT_FREEBSD32 */
936 mps_ioctl_devsw(struct cdev *dev, u_long com, caddr_t arg, int flag,
939 #ifdef COMPAT_FREEBSD32
940 if (SV_CURPROC_FLAG(SV_ILP32))
941 return (mps_ioctl32(dev, com, arg, flag, td));
943 return (mps_ioctl(dev, com, arg, flag, td));