1991554f2SKenneth D. Merry /*- 2991554f2SKenneth D. Merry * Copyright (c) 2008 Yahoo!, Inc. 3991554f2SKenneth D. Merry * All rights reserved. 4991554f2SKenneth D. Merry * Written by: John Baldwin <jhb@FreeBSD.org> 5991554f2SKenneth D. Merry * 6991554f2SKenneth D. Merry * Redistribution and use in source and binary forms, with or without 7991554f2SKenneth D. Merry * modification, are permitted provided that the following conditions 8991554f2SKenneth D. Merry * are met: 9991554f2SKenneth D. Merry * 1. Redistributions of source code must retain the above copyright 10991554f2SKenneth D. Merry * notice, this list of conditions and the following disclaimer. 11991554f2SKenneth D. Merry * 2. Redistributions in binary form must reproduce the above copyright 12991554f2SKenneth D. Merry * notice, this list of conditions and the following disclaimer in the 13991554f2SKenneth D. Merry * documentation and/or other materials provided with the distribution. 14991554f2SKenneth D. Merry * 3. Neither the name of the author nor the names of any co-contributors 15991554f2SKenneth D. Merry * may be used to endorse or promote products derived from this software 16991554f2SKenneth D. Merry * without specific prior written permission. 17991554f2SKenneth D. Merry * 18991554f2SKenneth D. Merry * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19991554f2SKenneth D. Merry * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20991554f2SKenneth D. Merry * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21991554f2SKenneth D. Merry * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22991554f2SKenneth D. Merry * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23991554f2SKenneth D. Merry * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24991554f2SKenneth D. Merry * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25991554f2SKenneth D. Merry * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26991554f2SKenneth D. Merry * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27991554f2SKenneth D. Merry * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28991554f2SKenneth D. Merry * SUCH DAMAGE. 29991554f2SKenneth D. Merry * 30a2c14879SStephen McConnell * Avago Technologies (LSI) MPT-Fusion Host Adapter FreeBSD userland interface 31991554f2SKenneth D. Merry */ 32991554f2SKenneth D. Merry /*- 33a2c14879SStephen McConnell * Copyright (c) 2011-2015 LSI Corp. 347a2a6a1aSStephen McConnell * Copyright (c) 2013-2016 Avago Technologies 35991554f2SKenneth D. Merry * All rights reserved. 36991554f2SKenneth D. Merry * 37991554f2SKenneth D. Merry * Redistribution and use in source and binary forms, with or without 38991554f2SKenneth D. Merry * modification, are permitted provided that the following conditions 39991554f2SKenneth D. Merry * are met: 40991554f2SKenneth D. Merry * 1. Redistributions of source code must retain the above copyright 41991554f2SKenneth D. Merry * notice, this list of conditions and the following disclaimer. 42991554f2SKenneth D. Merry * 2. Redistributions in binary form must reproduce the above copyright 43991554f2SKenneth D. Merry * notice, this list of conditions and the following disclaimer in the 44991554f2SKenneth D. Merry * documentation and/or other materials provided with the distribution. 45991554f2SKenneth D. Merry * 46991554f2SKenneth D. Merry * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 47991554f2SKenneth D. Merry * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 48991554f2SKenneth D. Merry * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 49991554f2SKenneth D. Merry * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 50991554f2SKenneth D. Merry * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 51991554f2SKenneth D. Merry * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 52991554f2SKenneth D. Merry * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 53991554f2SKenneth D. Merry * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 54991554f2SKenneth D. Merry * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 55991554f2SKenneth D. Merry * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 56991554f2SKenneth D. Merry * SUCH DAMAGE. 57991554f2SKenneth D. Merry * 58a2c14879SStephen McConnell * Avago Technologies (LSI) MPT-Fusion Host Adapter FreeBSD 59991554f2SKenneth D. Merry * 60991554f2SKenneth D. Merry * $FreeBSD$ 61991554f2SKenneth D. Merry */ 62991554f2SKenneth D. Merry 63991554f2SKenneth D. Merry #include <sys/cdefs.h> 64991554f2SKenneth D. Merry __FBSDID("$FreeBSD$"); 65991554f2SKenneth D. Merry 66991554f2SKenneth D. Merry #include "opt_compat.h" 67991554f2SKenneth D. Merry 68991554f2SKenneth D. Merry /* TODO Move headers to mprvar */ 69991554f2SKenneth D. Merry #include <sys/types.h> 70991554f2SKenneth D. Merry #include <sys/param.h> 71991554f2SKenneth D. Merry #include <sys/systm.h> 72991554f2SKenneth D. Merry #include <sys/kernel.h> 73991554f2SKenneth D. Merry #include <sys/selinfo.h> 74991554f2SKenneth D. Merry #include <sys/module.h> 75991554f2SKenneth D. Merry #include <sys/bus.h> 76991554f2SKenneth D. Merry #include <sys/conf.h> 77991554f2SKenneth D. Merry #include <sys/bio.h> 78991554f2SKenneth D. Merry #include <sys/malloc.h> 79991554f2SKenneth D. Merry #include <sys/uio.h> 80991554f2SKenneth D. Merry #include <sys/sysctl.h> 81991554f2SKenneth D. Merry #include <sys/ioccom.h> 82991554f2SKenneth D. Merry #include <sys/endian.h> 83991554f2SKenneth D. Merry #include <sys/queue.h> 84991554f2SKenneth D. Merry #include <sys/kthread.h> 85991554f2SKenneth D. Merry #include <sys/taskqueue.h> 86991554f2SKenneth D. Merry #include <sys/proc.h> 87991554f2SKenneth D. Merry #include <sys/sysent.h> 88991554f2SKenneth D. Merry 89991554f2SKenneth D. Merry #include <machine/bus.h> 90991554f2SKenneth D. Merry #include <machine/resource.h> 91991554f2SKenneth D. Merry #include <sys/rman.h> 92991554f2SKenneth D. Merry 93991554f2SKenneth D. Merry #include <cam/cam.h> 94a2c14879SStephen McConnell #include <cam/cam_ccb.h> 95991554f2SKenneth D. Merry 96991554f2SKenneth D. Merry #include <dev/mpr/mpi/mpi2_type.h> 97991554f2SKenneth D. Merry #include <dev/mpr/mpi/mpi2.h> 98991554f2SKenneth D. Merry #include <dev/mpr/mpi/mpi2_ioc.h> 99991554f2SKenneth D. Merry #include <dev/mpr/mpi/mpi2_cnfg.h> 100991554f2SKenneth D. Merry #include <dev/mpr/mpi/mpi2_init.h> 101991554f2SKenneth D. Merry #include <dev/mpr/mpi/mpi2_tool.h> 10267feec50SStephen McConnell #include <dev/mpr/mpi/mpi2_pci.h> 103991554f2SKenneth D. Merry #include <dev/mpr/mpr_ioctl.h> 104991554f2SKenneth D. Merry #include <dev/mpr/mprvar.h> 105991554f2SKenneth D. Merry #include <dev/mpr/mpr_table.h> 106991554f2SKenneth D. Merry #include <dev/mpr/mpr_sas.h> 107991554f2SKenneth D. Merry #include <dev/pci/pcivar.h> 108991554f2SKenneth D. Merry #include <dev/pci/pcireg.h> 109991554f2SKenneth D. Merry 110991554f2SKenneth D. Merry static d_open_t mpr_open; 111991554f2SKenneth D. Merry static d_close_t mpr_close; 112991554f2SKenneth D. Merry static d_ioctl_t mpr_ioctl_devsw; 113991554f2SKenneth D. Merry 114991554f2SKenneth D. Merry static struct cdevsw mpr_cdevsw = { 115991554f2SKenneth D. Merry .d_version = D_VERSION, 116991554f2SKenneth D. Merry .d_flags = 0, 117991554f2SKenneth D. Merry .d_open = mpr_open, 118991554f2SKenneth D. Merry .d_close = mpr_close, 119991554f2SKenneth D. Merry .d_ioctl = mpr_ioctl_devsw, 120991554f2SKenneth D. Merry .d_name = "mpr", 121991554f2SKenneth D. Merry }; 122991554f2SKenneth D. Merry 123991554f2SKenneth D. Merry typedef int (mpr_user_f)(struct mpr_command *, struct mpr_usr_command *); 124991554f2SKenneth D. Merry static mpr_user_f mpi_pre_ioc_facts; 125991554f2SKenneth D. Merry static mpr_user_f mpi_pre_port_facts; 126991554f2SKenneth D. Merry static mpr_user_f mpi_pre_fw_download; 127991554f2SKenneth D. Merry static mpr_user_f mpi_pre_fw_upload; 128991554f2SKenneth D. Merry static mpr_user_f mpi_pre_sata_passthrough; 129991554f2SKenneth D. Merry static mpr_user_f mpi_pre_smp_passthrough; 130991554f2SKenneth D. Merry static mpr_user_f mpi_pre_config; 131991554f2SKenneth D. Merry static mpr_user_f mpi_pre_sas_io_unit_control; 132991554f2SKenneth D. Merry 133991554f2SKenneth D. Merry static int mpr_user_read_cfg_header(struct mpr_softc *, 134991554f2SKenneth D. Merry struct mpr_cfg_page_req *); 135991554f2SKenneth D. Merry static int mpr_user_read_cfg_page(struct mpr_softc *, 136991554f2SKenneth D. Merry struct mpr_cfg_page_req *, void *); 137991554f2SKenneth D. Merry static int mpr_user_read_extcfg_header(struct mpr_softc *, 138991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req *); 139991554f2SKenneth D. Merry static int mpr_user_read_extcfg_page(struct mpr_softc *, 140991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req *, void *); 141991554f2SKenneth D. Merry static int mpr_user_write_cfg_page(struct mpr_softc *, 142991554f2SKenneth D. Merry struct mpr_cfg_page_req *, void *); 143991554f2SKenneth D. Merry static int mpr_user_setup_request(struct mpr_command *, 144991554f2SKenneth D. Merry struct mpr_usr_command *); 145991554f2SKenneth D. Merry static int mpr_user_command(struct mpr_softc *, struct mpr_usr_command *); 146991554f2SKenneth D. Merry 147991554f2SKenneth D. Merry static int mpr_user_pass_thru(struct mpr_softc *sc, mpr_pass_thru_t *data); 148991554f2SKenneth D. Merry static void mpr_user_get_adapter_data(struct mpr_softc *sc, 149991554f2SKenneth D. Merry mpr_adapter_data_t *data); 1507a2a6a1aSStephen McConnell static void mpr_user_read_pci_info(struct mpr_softc *sc, mpr_pci_info_t *data); 151991554f2SKenneth D. Merry static uint8_t mpr_get_fw_diag_buffer_number(struct mpr_softc *sc, 152991554f2SKenneth D. Merry uint32_t unique_id); 153991554f2SKenneth D. Merry static int mpr_post_fw_diag_buffer(struct mpr_softc *sc, 154991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer, uint32_t *return_code); 155991554f2SKenneth D. Merry static int mpr_release_fw_diag_buffer(struct mpr_softc *sc, 156991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer, uint32_t *return_code, 157991554f2SKenneth D. Merry uint32_t diag_type); 158991554f2SKenneth D. Merry static int mpr_diag_register(struct mpr_softc *sc, 159991554f2SKenneth D. Merry mpr_fw_diag_register_t *diag_register, uint32_t *return_code); 160991554f2SKenneth D. Merry static int mpr_diag_unregister(struct mpr_softc *sc, 161991554f2SKenneth D. Merry mpr_fw_diag_unregister_t *diag_unregister, uint32_t *return_code); 1627a2a6a1aSStephen McConnell static int mpr_diag_query(struct mpr_softc *sc, mpr_fw_diag_query_t *diag_query, 1637a2a6a1aSStephen McConnell uint32_t *return_code); 164991554f2SKenneth D. Merry static int mpr_diag_read_buffer(struct mpr_softc *sc, 165991554f2SKenneth D. Merry mpr_diag_read_buffer_t *diag_read_buffer, uint8_t *ioctl_buf, 166991554f2SKenneth D. Merry uint32_t *return_code); 167991554f2SKenneth D. Merry static int mpr_diag_release(struct mpr_softc *sc, 168991554f2SKenneth D. Merry mpr_fw_diag_release_t *diag_release, uint32_t *return_code); 169991554f2SKenneth D. Merry static int mpr_do_diag_action(struct mpr_softc *sc, uint32_t action, 170991554f2SKenneth D. Merry uint8_t *diag_action, uint32_t length, uint32_t *return_code); 1717a2a6a1aSStephen McConnell static int mpr_user_diag_action(struct mpr_softc *sc, mpr_diag_action_t *data); 1727a2a6a1aSStephen McConnell static void mpr_user_event_query(struct mpr_softc *sc, mpr_event_query_t *data); 173991554f2SKenneth D. Merry static void mpr_user_event_enable(struct mpr_softc *sc, 174991554f2SKenneth D. Merry mpr_event_enable_t *data); 175991554f2SKenneth D. Merry static int mpr_user_event_report(struct mpr_softc *sc, 176991554f2SKenneth D. Merry mpr_event_report_t *data); 177991554f2SKenneth D. Merry static int mpr_user_reg_access(struct mpr_softc *sc, mpr_reg_access_t *data); 178991554f2SKenneth D. Merry static int mpr_user_btdh(struct mpr_softc *sc, mpr_btdh_mapping_t *data); 179991554f2SKenneth D. Merry 180991554f2SKenneth D. Merry static MALLOC_DEFINE(M_MPRUSER, "mpr_user", "Buffers for mpr(4) ioctls"); 181991554f2SKenneth D. Merry 182991554f2SKenneth D. Merry /* Macros from compat/freebsd32/freebsd32.h */ 183991554f2SKenneth D. Merry #define PTRIN(v) (void *)(uintptr_t)(v) 184991554f2SKenneth D. Merry #define PTROUT(v) (uint32_t)(uintptr_t)(v) 185991554f2SKenneth D. Merry 186991554f2SKenneth D. Merry #define CP(src,dst,fld) do { (dst).fld = (src).fld; } while (0) 187991554f2SKenneth D. Merry #define PTRIN_CP(src,dst,fld) \ 188991554f2SKenneth D. Merry do { (dst).fld = PTRIN((src).fld); } while (0) 189991554f2SKenneth D. Merry #define PTROUT_CP(src,dst,fld) \ 190991554f2SKenneth D. Merry do { (dst).fld = PTROUT((src).fld); } while (0) 191991554f2SKenneth D. Merry 192991554f2SKenneth D. Merry /* 193991554f2SKenneth D. Merry * MPI functions that support IEEE SGLs for SAS3. 194991554f2SKenneth D. Merry */ 195991554f2SKenneth D. Merry static uint8_t ieee_sgl_func_list[] = { 196991554f2SKenneth D. Merry MPI2_FUNCTION_SCSI_IO_REQUEST, 197991554f2SKenneth D. Merry MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH, 198991554f2SKenneth D. Merry MPI2_FUNCTION_SMP_PASSTHROUGH, 199991554f2SKenneth D. Merry MPI2_FUNCTION_SATA_PASSTHROUGH, 200991554f2SKenneth D. Merry MPI2_FUNCTION_FW_UPLOAD, 201991554f2SKenneth D. Merry MPI2_FUNCTION_FW_DOWNLOAD, 202991554f2SKenneth D. Merry MPI2_FUNCTION_TARGET_ASSIST, 203991554f2SKenneth D. Merry MPI2_FUNCTION_TARGET_STATUS_SEND, 204991554f2SKenneth D. Merry MPI2_FUNCTION_TOOLBOX 205991554f2SKenneth D. Merry }; 206991554f2SKenneth D. Merry 207991554f2SKenneth D. Merry int 208991554f2SKenneth D. Merry mpr_attach_user(struct mpr_softc *sc) 209991554f2SKenneth D. Merry { 210991554f2SKenneth D. Merry int unit; 211991554f2SKenneth D. Merry 212991554f2SKenneth D. Merry unit = device_get_unit(sc->mpr_dev); 2137a2a6a1aSStephen McConnell sc->mpr_cdev = make_dev(&mpr_cdevsw, unit, UID_ROOT, GID_OPERATOR, 0640, 2147a2a6a1aSStephen McConnell "mpr%d", unit); 2157a2a6a1aSStephen McConnell 2167a2a6a1aSStephen McConnell if (sc->mpr_cdev == NULL) 217991554f2SKenneth D. Merry return (ENOMEM); 2187a2a6a1aSStephen McConnell 219991554f2SKenneth D. Merry sc->mpr_cdev->si_drv1 = sc; 220991554f2SKenneth D. Merry return (0); 221991554f2SKenneth D. Merry } 222991554f2SKenneth D. Merry 223991554f2SKenneth D. Merry void 224991554f2SKenneth D. Merry mpr_detach_user(struct mpr_softc *sc) 225991554f2SKenneth D. Merry { 226991554f2SKenneth D. Merry 227991554f2SKenneth D. Merry /* XXX: do a purge of pending requests? */ 228991554f2SKenneth D. Merry if (sc->mpr_cdev != NULL) 229991554f2SKenneth D. Merry destroy_dev(sc->mpr_cdev); 230991554f2SKenneth D. Merry } 231991554f2SKenneth D. Merry 232991554f2SKenneth D. Merry static int 233991554f2SKenneth D. Merry mpr_open(struct cdev *dev, int flags, int fmt, struct thread *td) 234991554f2SKenneth D. Merry { 235991554f2SKenneth D. Merry 236991554f2SKenneth D. Merry return (0); 237991554f2SKenneth D. Merry } 238991554f2SKenneth D. Merry 239991554f2SKenneth D. Merry static int 240991554f2SKenneth D. Merry mpr_close(struct cdev *dev, int flags, int fmt, struct thread *td) 241991554f2SKenneth D. Merry { 242991554f2SKenneth D. Merry 243991554f2SKenneth D. Merry return (0); 244991554f2SKenneth D. Merry } 245991554f2SKenneth D. Merry 246991554f2SKenneth D. Merry static int 247991554f2SKenneth D. Merry mpr_user_read_cfg_header(struct mpr_softc *sc, 248991554f2SKenneth D. Merry struct mpr_cfg_page_req *page_req) 249991554f2SKenneth D. Merry { 250991554f2SKenneth D. Merry MPI2_CONFIG_PAGE_HEADER *hdr; 251991554f2SKenneth D. Merry struct mpr_config_params params; 252991554f2SKenneth D. Merry int error; 253991554f2SKenneth D. Merry 254991554f2SKenneth D. Merry hdr = ¶ms.hdr.Struct; 255991554f2SKenneth D. Merry params.action = MPI2_CONFIG_ACTION_PAGE_HEADER; 256991554f2SKenneth D. Merry params.page_address = le32toh(page_req->page_address); 257991554f2SKenneth D. Merry hdr->PageVersion = 0; 258991554f2SKenneth D. Merry hdr->PageLength = 0; 259991554f2SKenneth D. Merry hdr->PageNumber = page_req->header.PageNumber; 260991554f2SKenneth D. Merry hdr->PageType = page_req->header.PageType; 261991554f2SKenneth D. Merry params.buffer = NULL; 262991554f2SKenneth D. Merry params.length = 0; 263991554f2SKenneth D. Merry params.callback = NULL; 264991554f2SKenneth D. Merry 265991554f2SKenneth D. Merry if ((error = mpr_read_config_page(sc, ¶ms)) != 0) { 266991554f2SKenneth D. Merry /* 267991554f2SKenneth D. Merry * Leave the request. Without resetting the chip, it's 268991554f2SKenneth D. Merry * still owned by it and we'll just get into trouble 269991554f2SKenneth D. Merry * freeing it now. Mark it as abandoned so that if it 270991554f2SKenneth D. Merry * shows up later it can be freed. 271991554f2SKenneth D. Merry */ 272991554f2SKenneth D. Merry mpr_printf(sc, "read_cfg_header timed out\n"); 273991554f2SKenneth D. Merry return (ETIMEDOUT); 274991554f2SKenneth D. Merry } 275991554f2SKenneth D. Merry 276991554f2SKenneth D. Merry page_req->ioc_status = htole16(params.status); 277991554f2SKenneth D. Merry if ((page_req->ioc_status & MPI2_IOCSTATUS_MASK) == 278991554f2SKenneth D. Merry MPI2_IOCSTATUS_SUCCESS) { 279991554f2SKenneth D. Merry bcopy(hdr, &page_req->header, sizeof(page_req->header)); 280991554f2SKenneth D. Merry } 281991554f2SKenneth D. Merry 282991554f2SKenneth D. Merry return (0); 283991554f2SKenneth D. Merry } 284991554f2SKenneth D. Merry 285991554f2SKenneth D. Merry static int 2867a2a6a1aSStephen McConnell mpr_user_read_cfg_page(struct mpr_softc *sc, struct mpr_cfg_page_req *page_req, 2877a2a6a1aSStephen McConnell void *buf) 288991554f2SKenneth D. Merry { 289991554f2SKenneth D. Merry MPI2_CONFIG_PAGE_HEADER *reqhdr, *hdr; 290991554f2SKenneth D. Merry struct mpr_config_params params; 291991554f2SKenneth D. Merry int error; 292991554f2SKenneth D. Merry 293991554f2SKenneth D. Merry reqhdr = buf; 294991554f2SKenneth D. Merry hdr = ¶ms.hdr.Struct; 295991554f2SKenneth D. Merry hdr->PageVersion = reqhdr->PageVersion; 296991554f2SKenneth D. Merry hdr->PageLength = reqhdr->PageLength; 297991554f2SKenneth D. Merry hdr->PageNumber = reqhdr->PageNumber; 298991554f2SKenneth D. Merry hdr->PageType = reqhdr->PageType & MPI2_CONFIG_PAGETYPE_MASK; 299991554f2SKenneth D. Merry params.action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 300991554f2SKenneth D. Merry params.page_address = le32toh(page_req->page_address); 301991554f2SKenneth D. Merry params.buffer = buf; 302991554f2SKenneth D. Merry params.length = le32toh(page_req->len); 303991554f2SKenneth D. Merry params.callback = NULL; 304991554f2SKenneth D. Merry 305991554f2SKenneth D. Merry if ((error = mpr_read_config_page(sc, ¶ms)) != 0) { 306991554f2SKenneth D. Merry mpr_printf(sc, "mpr_user_read_cfg_page timed out\n"); 307991554f2SKenneth D. Merry return (ETIMEDOUT); 308991554f2SKenneth D. Merry } 309991554f2SKenneth D. Merry 310991554f2SKenneth D. Merry page_req->ioc_status = htole16(params.status); 311991554f2SKenneth D. Merry return (0); 312991554f2SKenneth D. Merry } 313991554f2SKenneth D. Merry 314991554f2SKenneth D. Merry static int 315991554f2SKenneth D. Merry mpr_user_read_extcfg_header(struct mpr_softc *sc, 316991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req *ext_page_req) 317991554f2SKenneth D. Merry { 318991554f2SKenneth D. Merry MPI2_CONFIG_EXTENDED_PAGE_HEADER *hdr; 319991554f2SKenneth D. Merry struct mpr_config_params params; 320991554f2SKenneth D. Merry int error; 321991554f2SKenneth D. Merry 322991554f2SKenneth D. Merry hdr = ¶ms.hdr.Ext; 323991554f2SKenneth D. Merry params.action = MPI2_CONFIG_ACTION_PAGE_HEADER; 324991554f2SKenneth D. Merry hdr->PageVersion = ext_page_req->header.PageVersion; 325991554f2SKenneth D. Merry hdr->PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 326991554f2SKenneth D. Merry hdr->ExtPageLength = 0; 327991554f2SKenneth D. Merry hdr->PageNumber = ext_page_req->header.PageNumber; 328991554f2SKenneth D. Merry hdr->ExtPageType = ext_page_req->header.ExtPageType; 329991554f2SKenneth D. Merry params.page_address = le32toh(ext_page_req->page_address); 330a2c14879SStephen McConnell params.buffer = NULL; 331a2c14879SStephen McConnell params.length = 0; 332a2c14879SStephen McConnell params.callback = NULL; 333a2c14879SStephen McConnell 334991554f2SKenneth D. Merry if ((error = mpr_read_config_page(sc, ¶ms)) != 0) { 335991554f2SKenneth D. Merry /* 336991554f2SKenneth D. Merry * Leave the request. Without resetting the chip, it's 337991554f2SKenneth D. Merry * still owned by it and we'll just get into trouble 338991554f2SKenneth D. Merry * freeing it now. Mark it as abandoned so that if it 339991554f2SKenneth D. Merry * shows up later it can be freed. 340991554f2SKenneth D. Merry */ 341991554f2SKenneth D. Merry mpr_printf(sc, "mpr_user_read_extcfg_header timed out\n"); 342991554f2SKenneth D. Merry return (ETIMEDOUT); 343991554f2SKenneth D. Merry } 344991554f2SKenneth D. Merry 345991554f2SKenneth D. Merry ext_page_req->ioc_status = htole16(params.status); 346991554f2SKenneth D. Merry if ((ext_page_req->ioc_status & MPI2_IOCSTATUS_MASK) == 347991554f2SKenneth D. Merry MPI2_IOCSTATUS_SUCCESS) { 348991554f2SKenneth D. Merry ext_page_req->header.PageVersion = hdr->PageVersion; 349991554f2SKenneth D. Merry ext_page_req->header.PageNumber = hdr->PageNumber; 350991554f2SKenneth D. Merry ext_page_req->header.PageType = hdr->PageType; 351991554f2SKenneth D. Merry ext_page_req->header.ExtPageLength = hdr->ExtPageLength; 352991554f2SKenneth D. Merry ext_page_req->header.ExtPageType = hdr->ExtPageType; 353991554f2SKenneth D. Merry } 354991554f2SKenneth D. Merry 355991554f2SKenneth D. Merry return (0); 356991554f2SKenneth D. Merry } 357991554f2SKenneth D. Merry 358991554f2SKenneth D. Merry static int 359991554f2SKenneth D. Merry mpr_user_read_extcfg_page(struct mpr_softc *sc, 360991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req *ext_page_req, void *buf) 361991554f2SKenneth D. Merry { 362991554f2SKenneth D. Merry MPI2_CONFIG_EXTENDED_PAGE_HEADER *reqhdr, *hdr; 363991554f2SKenneth D. Merry struct mpr_config_params params; 364991554f2SKenneth D. Merry int error; 365991554f2SKenneth D. Merry 366991554f2SKenneth D. Merry reqhdr = buf; 367991554f2SKenneth D. Merry hdr = ¶ms.hdr.Ext; 368991554f2SKenneth D. Merry params.action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 369991554f2SKenneth D. Merry params.page_address = le32toh(ext_page_req->page_address); 370991554f2SKenneth D. Merry hdr->PageVersion = reqhdr->PageVersion; 371c91d307fSStephen McConnell hdr->PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 372a2c14879SStephen McConnell hdr->PageNumber = reqhdr->PageNumber; 373991554f2SKenneth D. Merry hdr->ExtPageType = reqhdr->ExtPageType; 374991554f2SKenneth D. Merry hdr->ExtPageLength = reqhdr->ExtPageLength; 375991554f2SKenneth D. Merry params.buffer = buf; 376991554f2SKenneth D. Merry params.length = le32toh(ext_page_req->len); 377991554f2SKenneth D. Merry params.callback = NULL; 378991554f2SKenneth D. Merry 379991554f2SKenneth D. Merry if ((error = mpr_read_config_page(sc, ¶ms)) != 0) { 380991554f2SKenneth D. Merry mpr_printf(sc, "mpr_user_read_extcfg_page timed out\n"); 381991554f2SKenneth D. Merry return (ETIMEDOUT); 382991554f2SKenneth D. Merry } 383991554f2SKenneth D. Merry 384991554f2SKenneth D. Merry ext_page_req->ioc_status = htole16(params.status); 385991554f2SKenneth D. Merry return (0); 386991554f2SKenneth D. Merry } 387991554f2SKenneth D. Merry 388991554f2SKenneth D. Merry static int 389991554f2SKenneth D. Merry mpr_user_write_cfg_page(struct mpr_softc *sc, 390991554f2SKenneth D. Merry struct mpr_cfg_page_req *page_req, void *buf) 391991554f2SKenneth D. Merry { 392991554f2SKenneth D. Merry MPI2_CONFIG_PAGE_HEADER *reqhdr, *hdr; 393991554f2SKenneth D. Merry struct mpr_config_params params; 394991554f2SKenneth D. Merry u_int hdr_attr; 395991554f2SKenneth D. Merry int error; 396991554f2SKenneth D. Merry 397991554f2SKenneth D. Merry reqhdr = buf; 398991554f2SKenneth D. Merry hdr = ¶ms.hdr.Struct; 399991554f2SKenneth D. Merry hdr_attr = reqhdr->PageType & MPI2_CONFIG_PAGEATTR_MASK; 400991554f2SKenneth D. Merry if (hdr_attr != MPI2_CONFIG_PAGEATTR_CHANGEABLE && 401991554f2SKenneth D. Merry hdr_attr != MPI2_CONFIG_PAGEATTR_PERSISTENT) { 402991554f2SKenneth D. Merry mpr_printf(sc, "page type 0x%x not changeable\n", 403991554f2SKenneth D. Merry reqhdr->PageType & MPI2_CONFIG_PAGETYPE_MASK); 404991554f2SKenneth D. Merry return (EINVAL); 405991554f2SKenneth D. Merry } 406991554f2SKenneth D. Merry 407991554f2SKenneth D. Merry /* 408991554f2SKenneth D. Merry * There isn't any point in restoring stripped out attributes 409991554f2SKenneth D. Merry * if you then mask them going down to issue the request. 410991554f2SKenneth D. Merry */ 411991554f2SKenneth D. Merry 412991554f2SKenneth D. Merry hdr->PageVersion = reqhdr->PageVersion; 413991554f2SKenneth D. Merry hdr->PageLength = reqhdr->PageLength; 414991554f2SKenneth D. Merry hdr->PageNumber = reqhdr->PageNumber; 415991554f2SKenneth D. Merry hdr->PageType = reqhdr->PageType; 416991554f2SKenneth D. Merry params.action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT; 417991554f2SKenneth D. Merry params.page_address = le32toh(page_req->page_address); 418991554f2SKenneth D. Merry params.buffer = buf; 419991554f2SKenneth D. Merry params.length = le32toh(page_req->len); 420991554f2SKenneth D. Merry params.callback = NULL; 421991554f2SKenneth D. Merry 422991554f2SKenneth D. Merry if ((error = mpr_write_config_page(sc, ¶ms)) != 0) { 423991554f2SKenneth D. Merry mpr_printf(sc, "mpr_write_cfg_page timed out\n"); 424991554f2SKenneth D. Merry return (ETIMEDOUT); 425991554f2SKenneth D. Merry } 426991554f2SKenneth D. Merry 427991554f2SKenneth D. Merry page_req->ioc_status = htole16(params.status); 428991554f2SKenneth D. Merry return (0); 429991554f2SKenneth D. Merry } 430991554f2SKenneth D. Merry 431991554f2SKenneth D. Merry void 432991554f2SKenneth D. Merry mpr_init_sge(struct mpr_command *cm, void *req, void *sge) 433991554f2SKenneth D. Merry { 434991554f2SKenneth D. Merry int off, space; 435991554f2SKenneth D. Merry 436991554f2SKenneth D. Merry space = (int)cm->cm_sc->facts->IOCRequestFrameSize * 4; 437991554f2SKenneth D. Merry off = (uintptr_t)sge - (uintptr_t)req; 438991554f2SKenneth D. Merry 439991554f2SKenneth D. Merry KASSERT(off < space, ("bad pointers %p %p, off %d, space %d", 440991554f2SKenneth D. Merry req, sge, off, space)); 441991554f2SKenneth D. Merry 442991554f2SKenneth D. Merry cm->cm_sge = sge; 443991554f2SKenneth D. Merry cm->cm_sglsize = space - off; 444991554f2SKenneth D. Merry } 445991554f2SKenneth D. Merry 446991554f2SKenneth D. Merry /* 447991554f2SKenneth D. Merry * Prepare the mpr_command for an IOC_FACTS request. 448991554f2SKenneth D. Merry */ 449991554f2SKenneth D. Merry static int 450991554f2SKenneth D. Merry mpi_pre_ioc_facts(struct mpr_command *cm, struct mpr_usr_command *cmd) 451991554f2SKenneth D. Merry { 452991554f2SKenneth D. Merry MPI2_IOC_FACTS_REQUEST *req = (void *)cm->cm_req; 453991554f2SKenneth D. Merry MPI2_IOC_FACTS_REPLY *rpl; 454991554f2SKenneth D. Merry 455991554f2SKenneth D. Merry if (cmd->req_len != sizeof *req) 456991554f2SKenneth D. Merry return (EINVAL); 457991554f2SKenneth D. Merry if (cmd->rpl_len != sizeof *rpl) 458991554f2SKenneth D. Merry return (EINVAL); 459991554f2SKenneth D. Merry 460991554f2SKenneth D. Merry cm->cm_sge = NULL; 461991554f2SKenneth D. Merry cm->cm_sglsize = 0; 462991554f2SKenneth D. Merry return (0); 463991554f2SKenneth D. Merry } 464991554f2SKenneth D. Merry 465991554f2SKenneth D. Merry /* 466991554f2SKenneth D. Merry * Prepare the mpr_command for a PORT_FACTS request. 467991554f2SKenneth D. Merry */ 468991554f2SKenneth D. Merry static int 469991554f2SKenneth D. Merry mpi_pre_port_facts(struct mpr_command *cm, struct mpr_usr_command *cmd) 470991554f2SKenneth D. Merry { 471991554f2SKenneth D. Merry MPI2_PORT_FACTS_REQUEST *req = (void *)cm->cm_req; 472991554f2SKenneth D. Merry MPI2_PORT_FACTS_REPLY *rpl; 473991554f2SKenneth D. Merry 474991554f2SKenneth D. Merry if (cmd->req_len != sizeof *req) 475991554f2SKenneth D. Merry return (EINVAL); 476991554f2SKenneth D. Merry if (cmd->rpl_len != sizeof *rpl) 477991554f2SKenneth D. Merry return (EINVAL); 478991554f2SKenneth D. Merry 479991554f2SKenneth D. Merry cm->cm_sge = NULL; 480991554f2SKenneth D. Merry cm->cm_sglsize = 0; 481991554f2SKenneth D. Merry return (0); 482991554f2SKenneth D. Merry } 483991554f2SKenneth D. Merry 484991554f2SKenneth D. Merry /* 485991554f2SKenneth D. Merry * Prepare the mpr_command for a FW_DOWNLOAD request. 486991554f2SKenneth D. Merry */ 487991554f2SKenneth D. Merry static int 488991554f2SKenneth D. Merry mpi_pre_fw_download(struct mpr_command *cm, struct mpr_usr_command *cmd) 489991554f2SKenneth D. Merry { 490991554f2SKenneth D. Merry MPI25_FW_DOWNLOAD_REQUEST *req = (void *)cm->cm_req; 491991554f2SKenneth D. Merry MPI2_FW_DOWNLOAD_REPLY *rpl; 492991554f2SKenneth D. Merry int error; 493991554f2SKenneth D. Merry 494991554f2SKenneth D. Merry if (cmd->req_len != sizeof *req) 495991554f2SKenneth D. Merry return (EINVAL); 496991554f2SKenneth D. Merry if (cmd->rpl_len != sizeof *rpl) 497991554f2SKenneth D. Merry return (EINVAL); 498991554f2SKenneth D. Merry 499991554f2SKenneth D. Merry if (cmd->len == 0) 500991554f2SKenneth D. Merry return (EINVAL); 501991554f2SKenneth D. Merry 502991554f2SKenneth D. Merry error = copyin(cmd->buf, cm->cm_data, cmd->len); 503991554f2SKenneth D. Merry if (error != 0) 504991554f2SKenneth D. Merry return (error); 505991554f2SKenneth D. Merry 506991554f2SKenneth D. Merry mpr_init_sge(cm, req, &req->SGL); 507991554f2SKenneth D. Merry 508991554f2SKenneth D. Merry /* 509991554f2SKenneth D. Merry * For now, the F/W image must be provided in a single request. 510991554f2SKenneth D. Merry */ 511991554f2SKenneth D. Merry if ((req->MsgFlags & MPI2_FW_DOWNLOAD_MSGFLGS_LAST_SEGMENT) == 0) 512991554f2SKenneth D. Merry return (EINVAL); 513991554f2SKenneth D. Merry if (req->TotalImageSize != cmd->len) 514991554f2SKenneth D. Merry return (EINVAL); 515991554f2SKenneth D. Merry 516991554f2SKenneth D. Merry req->ImageOffset = 0; 517991554f2SKenneth D. Merry req->ImageSize = cmd->len; 518991554f2SKenneth D. Merry 519991554f2SKenneth D. Merry cm->cm_flags |= MPR_CM_FLAGS_DATAOUT; 520991554f2SKenneth D. Merry 521991554f2SKenneth D. Merry return (mpr_push_ieee_sge(cm, &req->SGL, 0)); 522991554f2SKenneth D. Merry } 523991554f2SKenneth D. Merry 524991554f2SKenneth D. Merry /* 525991554f2SKenneth D. Merry * Prepare the mpr_command for a FW_UPLOAD request. 526991554f2SKenneth D. Merry */ 527991554f2SKenneth D. Merry static int 528991554f2SKenneth D. Merry mpi_pre_fw_upload(struct mpr_command *cm, struct mpr_usr_command *cmd) 529991554f2SKenneth D. Merry { 530991554f2SKenneth D. Merry MPI25_FW_UPLOAD_REQUEST *req = (void *)cm->cm_req; 531991554f2SKenneth D. Merry MPI2_FW_UPLOAD_REPLY *rpl; 532991554f2SKenneth D. Merry 533991554f2SKenneth D. Merry if (cmd->req_len != sizeof *req) 534991554f2SKenneth D. Merry return (EINVAL); 535991554f2SKenneth D. Merry if (cmd->rpl_len != sizeof *rpl) 536991554f2SKenneth D. Merry return (EINVAL); 537991554f2SKenneth D. Merry 538991554f2SKenneth D. Merry mpr_init_sge(cm, req, &req->SGL); 539991554f2SKenneth D. Merry if (cmd->len == 0) { 540991554f2SKenneth D. Merry /* Perhaps just asking what the size of the fw is? */ 541991554f2SKenneth D. Merry return (0); 542991554f2SKenneth D. Merry } 543991554f2SKenneth D. Merry 544991554f2SKenneth D. Merry req->ImageOffset = 0; 545991554f2SKenneth D. Merry req->ImageSize = cmd->len; 546991554f2SKenneth D. Merry 547a2c14879SStephen McConnell cm->cm_flags |= MPR_CM_FLAGS_DATAIN; 548a2c14879SStephen McConnell 549991554f2SKenneth D. Merry return (mpr_push_ieee_sge(cm, &req->SGL, 0)); 550991554f2SKenneth D. Merry } 551991554f2SKenneth D. Merry 552991554f2SKenneth D. Merry /* 553991554f2SKenneth D. Merry * Prepare the mpr_command for a SATA_PASSTHROUGH request. 554991554f2SKenneth D. Merry */ 555991554f2SKenneth D. Merry static int 556991554f2SKenneth D. Merry mpi_pre_sata_passthrough(struct mpr_command *cm, struct mpr_usr_command *cmd) 557991554f2SKenneth D. Merry { 558991554f2SKenneth D. Merry MPI2_SATA_PASSTHROUGH_REQUEST *req = (void *)cm->cm_req; 559991554f2SKenneth D. Merry MPI2_SATA_PASSTHROUGH_REPLY *rpl; 560991554f2SKenneth D. Merry 561991554f2SKenneth D. Merry if (cmd->req_len != sizeof *req) 562991554f2SKenneth D. Merry return (EINVAL); 563991554f2SKenneth D. Merry if (cmd->rpl_len != sizeof *rpl) 564991554f2SKenneth D. Merry return (EINVAL); 565991554f2SKenneth D. Merry 566991554f2SKenneth D. Merry mpr_init_sge(cm, req, &req->SGL); 567991554f2SKenneth D. Merry return (0); 568991554f2SKenneth D. Merry } 569991554f2SKenneth D. Merry 570991554f2SKenneth D. Merry /* 571991554f2SKenneth D. Merry * Prepare the mpr_command for a SMP_PASSTHROUGH request. 572991554f2SKenneth D. Merry */ 573991554f2SKenneth D. Merry static int 574991554f2SKenneth D. Merry mpi_pre_smp_passthrough(struct mpr_command *cm, struct mpr_usr_command *cmd) 575991554f2SKenneth D. Merry { 576991554f2SKenneth D. Merry MPI2_SMP_PASSTHROUGH_REQUEST *req = (void *)cm->cm_req; 577991554f2SKenneth D. Merry MPI2_SMP_PASSTHROUGH_REPLY *rpl; 578991554f2SKenneth D. Merry 579991554f2SKenneth D. Merry if (cmd->req_len != sizeof *req) 580991554f2SKenneth D. Merry return (EINVAL); 581991554f2SKenneth D. Merry if (cmd->rpl_len != sizeof *rpl) 582991554f2SKenneth D. Merry return (EINVAL); 583991554f2SKenneth D. Merry 584991554f2SKenneth D. Merry mpr_init_sge(cm, req, &req->SGL); 585991554f2SKenneth D. Merry return (0); 586991554f2SKenneth D. Merry } 587991554f2SKenneth D. Merry 588991554f2SKenneth D. Merry /* 589991554f2SKenneth D. Merry * Prepare the mpr_command for a CONFIG request. 590991554f2SKenneth D. Merry */ 591991554f2SKenneth D. Merry static int 592991554f2SKenneth D. Merry mpi_pre_config(struct mpr_command *cm, struct mpr_usr_command *cmd) 593991554f2SKenneth D. Merry { 594991554f2SKenneth D. Merry MPI2_CONFIG_REQUEST *req = (void *)cm->cm_req; 595991554f2SKenneth D. Merry MPI2_CONFIG_REPLY *rpl; 596991554f2SKenneth D. Merry 597991554f2SKenneth D. Merry if (cmd->req_len != sizeof *req) 598991554f2SKenneth D. Merry return (EINVAL); 599991554f2SKenneth D. Merry if (cmd->rpl_len != sizeof *rpl) 600991554f2SKenneth D. Merry return (EINVAL); 601991554f2SKenneth D. Merry 602991554f2SKenneth D. Merry mpr_init_sge(cm, req, &req->PageBufferSGE); 603991554f2SKenneth D. Merry return (0); 604991554f2SKenneth D. Merry } 605991554f2SKenneth D. Merry 606991554f2SKenneth D. Merry /* 607991554f2SKenneth D. Merry * Prepare the mpr_command for a SAS_IO_UNIT_CONTROL request. 608991554f2SKenneth D. Merry */ 609991554f2SKenneth D. Merry static int 610991554f2SKenneth D. Merry mpi_pre_sas_io_unit_control(struct mpr_command *cm, 611991554f2SKenneth D. Merry struct mpr_usr_command *cmd) 612991554f2SKenneth D. Merry { 613991554f2SKenneth D. Merry 614991554f2SKenneth D. Merry cm->cm_sge = NULL; 615991554f2SKenneth D. Merry cm->cm_sglsize = 0; 616991554f2SKenneth D. Merry return (0); 617991554f2SKenneth D. Merry } 618991554f2SKenneth D. Merry 619991554f2SKenneth D. Merry /* 620991554f2SKenneth D. Merry * A set of functions to prepare an mpr_command for the various 621991554f2SKenneth D. Merry * supported requests. 622991554f2SKenneth D. Merry */ 623991554f2SKenneth D. Merry struct mpr_user_func { 624991554f2SKenneth D. Merry U8 Function; 625991554f2SKenneth D. Merry mpr_user_f *f_pre; 626991554f2SKenneth D. Merry } mpr_user_func_list[] = { 627991554f2SKenneth D. Merry { MPI2_FUNCTION_IOC_FACTS, mpi_pre_ioc_facts }, 628991554f2SKenneth D. Merry { MPI2_FUNCTION_PORT_FACTS, mpi_pre_port_facts }, 629991554f2SKenneth D. Merry { MPI2_FUNCTION_FW_DOWNLOAD, mpi_pre_fw_download }, 630991554f2SKenneth D. Merry { MPI2_FUNCTION_FW_UPLOAD, mpi_pre_fw_upload }, 631991554f2SKenneth D. Merry { MPI2_FUNCTION_SATA_PASSTHROUGH, mpi_pre_sata_passthrough }, 632991554f2SKenneth D. Merry { MPI2_FUNCTION_SMP_PASSTHROUGH, mpi_pre_smp_passthrough}, 633991554f2SKenneth D. Merry { MPI2_FUNCTION_CONFIG, mpi_pre_config}, 634991554f2SKenneth D. Merry { MPI2_FUNCTION_SAS_IO_UNIT_CONTROL, mpi_pre_sas_io_unit_control }, 635991554f2SKenneth D. Merry { 0xFF, NULL } /* list end */ 636991554f2SKenneth D. Merry }; 637991554f2SKenneth D. Merry 638991554f2SKenneth D. Merry static int 639991554f2SKenneth D. Merry mpr_user_setup_request(struct mpr_command *cm, struct mpr_usr_command *cmd) 640991554f2SKenneth D. Merry { 641991554f2SKenneth D. Merry MPI2_REQUEST_HEADER *hdr = (MPI2_REQUEST_HEADER *)cm->cm_req; 642991554f2SKenneth D. Merry struct mpr_user_func *f; 643991554f2SKenneth D. Merry 644991554f2SKenneth D. Merry for (f = mpr_user_func_list; f->f_pre != NULL; f++) { 645991554f2SKenneth D. Merry if (hdr->Function == f->Function) 646991554f2SKenneth D. Merry return (f->f_pre(cm, cmd)); 647991554f2SKenneth D. Merry } 648991554f2SKenneth D. Merry return (EINVAL); 649991554f2SKenneth D. Merry } 650991554f2SKenneth D. Merry 651991554f2SKenneth D. Merry static int 652991554f2SKenneth D. Merry mpr_user_command(struct mpr_softc *sc, struct mpr_usr_command *cmd) 653991554f2SKenneth D. Merry { 654991554f2SKenneth D. Merry MPI2_REQUEST_HEADER *hdr; 6556d4ffcb4SKenneth D. Merry MPI2_DEFAULT_REPLY *rpl = NULL; 656991554f2SKenneth D. Merry void *buf = NULL; 657991554f2SKenneth D. Merry struct mpr_command *cm = NULL; 658991554f2SKenneth D. Merry int err = 0; 659991554f2SKenneth D. Merry int sz; 660991554f2SKenneth D. Merry 661991554f2SKenneth D. Merry mpr_lock(sc); 662991554f2SKenneth D. Merry cm = mpr_alloc_command(sc); 663991554f2SKenneth D. Merry 664991554f2SKenneth D. Merry if (cm == NULL) { 665991554f2SKenneth D. Merry mpr_printf(sc, "%s: no mpr requests\n", __func__); 666991554f2SKenneth D. Merry err = ENOMEM; 6676d4ffcb4SKenneth D. Merry goto RetFree; 668991554f2SKenneth D. Merry } 669991554f2SKenneth D. Merry mpr_unlock(sc); 670991554f2SKenneth D. Merry 671991554f2SKenneth D. Merry hdr = (MPI2_REQUEST_HEADER *)cm->cm_req; 672991554f2SKenneth D. Merry 673991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: req %p %d rpl %p %d\n", __func__, 674991554f2SKenneth D. Merry cmd->req, cmd->req_len, cmd->rpl, cmd->rpl_len); 675991554f2SKenneth D. Merry 676991554f2SKenneth D. Merry if (cmd->req_len > (int)sc->facts->IOCRequestFrameSize * 4) { 677991554f2SKenneth D. Merry err = EINVAL; 678991554f2SKenneth D. Merry goto RetFreeUnlocked; 679991554f2SKenneth D. Merry } 680991554f2SKenneth D. Merry err = copyin(cmd->req, hdr, cmd->req_len); 681991554f2SKenneth D. Merry if (err != 0) 682991554f2SKenneth D. Merry goto RetFreeUnlocked; 683991554f2SKenneth D. Merry 684991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: Function %02X MsgFlags %02X\n", __func__, 685991554f2SKenneth D. Merry hdr->Function, hdr->MsgFlags); 686991554f2SKenneth D. Merry 687991554f2SKenneth D. Merry if (cmd->len > 0) { 688991554f2SKenneth D. Merry buf = malloc(cmd->len, M_MPRUSER, M_WAITOK|M_ZERO); 689991554f2SKenneth D. Merry cm->cm_data = buf; 690991554f2SKenneth D. Merry cm->cm_length = cmd->len; 691991554f2SKenneth D. Merry } else { 692991554f2SKenneth D. Merry cm->cm_data = NULL; 693991554f2SKenneth D. Merry cm->cm_length = 0; 694991554f2SKenneth D. Merry } 695991554f2SKenneth D. Merry 696991554f2SKenneth D. Merry cm->cm_flags = MPR_CM_FLAGS_SGE_SIMPLE; 697991554f2SKenneth D. Merry cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 698991554f2SKenneth D. Merry 699991554f2SKenneth D. Merry err = mpr_user_setup_request(cm, cmd); 700991554f2SKenneth D. Merry if (err == EINVAL) { 701991554f2SKenneth D. Merry mpr_printf(sc, "%s: unsupported parameter or unsupported " 702991554f2SKenneth D. Merry "function in request (function = 0x%X)\n", __func__, 703991554f2SKenneth D. Merry hdr->Function); 704991554f2SKenneth D. Merry } 705991554f2SKenneth D. Merry if (err != 0) 706991554f2SKenneth D. Merry goto RetFreeUnlocked; 707991554f2SKenneth D. Merry 708991554f2SKenneth D. Merry mpr_lock(sc); 7096d4ffcb4SKenneth D. Merry err = mpr_wait_command(sc, &cm, 30, CAN_SLEEP); 710991554f2SKenneth D. Merry 7116d4ffcb4SKenneth D. Merry if (err || (cm == NULL)) { 712991554f2SKenneth D. Merry mpr_printf(sc, "%s: invalid request: error %d\n", 713991554f2SKenneth D. Merry __func__, err); 7146d4ffcb4SKenneth D. Merry goto RetFree; 715991554f2SKenneth D. Merry } 716991554f2SKenneth D. Merry 7176d4ffcb4SKenneth D. Merry if (cm != NULL) 718991554f2SKenneth D. Merry rpl = (MPI2_DEFAULT_REPLY *)cm->cm_reply; 719991554f2SKenneth D. Merry if (rpl != NULL) 720991554f2SKenneth D. Merry sz = rpl->MsgLength * 4; 721991554f2SKenneth D. Merry else 722991554f2SKenneth D. Merry sz = 0; 723991554f2SKenneth D. Merry 724991554f2SKenneth D. Merry if (sz > cmd->rpl_len) { 725991554f2SKenneth D. Merry mpr_printf(sc, "%s: user reply buffer (%d) smaller than " 726991554f2SKenneth D. Merry "returned buffer (%d)\n", __func__, cmd->rpl_len, sz); 727991554f2SKenneth D. Merry sz = cmd->rpl_len; 728991554f2SKenneth D. Merry } 729991554f2SKenneth D. Merry 730991554f2SKenneth D. Merry mpr_unlock(sc); 731991554f2SKenneth D. Merry copyout(rpl, cmd->rpl, sz); 732991554f2SKenneth D. Merry if (buf != NULL) 733991554f2SKenneth D. Merry copyout(buf, cmd->buf, cmd->len); 734991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: reply size %d\n", __func__, sz); 735991554f2SKenneth D. Merry 736991554f2SKenneth D. Merry RetFreeUnlocked: 737991554f2SKenneth D. Merry mpr_lock(sc); 7386d4ffcb4SKenneth D. Merry RetFree: 739991554f2SKenneth D. Merry if (cm != NULL) 740991554f2SKenneth D. Merry mpr_free_command(sc, cm); 741991554f2SKenneth D. Merry mpr_unlock(sc); 742991554f2SKenneth D. Merry if (buf != NULL) 743991554f2SKenneth D. Merry free(buf, M_MPRUSER); 744991554f2SKenneth D. Merry return (err); 745991554f2SKenneth D. Merry } 746991554f2SKenneth D. Merry 747991554f2SKenneth D. Merry static int 748991554f2SKenneth D. Merry mpr_user_pass_thru(struct mpr_softc *sc, mpr_pass_thru_t *data) 749991554f2SKenneth D. Merry { 750991554f2SKenneth D. Merry MPI2_REQUEST_HEADER *hdr, tmphdr; 751991554f2SKenneth D. Merry MPI2_DEFAULT_REPLY *rpl; 75267feec50SStephen McConnell Mpi26NVMeEncapsulatedErrorReply_t *nvme_error_reply = NULL; 75367feec50SStephen McConnell Mpi26NVMeEncapsulatedRequest_t *nvme_encap_request = NULL; 754991554f2SKenneth D. Merry struct mpr_command *cm = NULL; 755991554f2SKenneth D. Merry int i, err = 0, dir = 0, sz; 756991554f2SKenneth D. Merry uint8_t tool, function = 0; 757991554f2SKenneth D. Merry u_int sense_len; 758991554f2SKenneth D. Merry struct mprsas_target *targ = NULL; 759991554f2SKenneth D. Merry 760991554f2SKenneth D. Merry /* 761991554f2SKenneth D. Merry * Only allow one passthru command at a time. Use the MPR_FLAGS_BUSY 762991554f2SKenneth D. Merry * bit to denote that a passthru is being processed. 763991554f2SKenneth D. Merry */ 764991554f2SKenneth D. Merry mpr_lock(sc); 765991554f2SKenneth D. Merry if (sc->mpr_flags & MPR_FLAGS_BUSY) { 766991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: Only one passthru command " 767991554f2SKenneth D. Merry "allowed at a single time.", __func__); 768991554f2SKenneth D. Merry mpr_unlock(sc); 769991554f2SKenneth D. Merry return (EBUSY); 770991554f2SKenneth D. Merry } 771991554f2SKenneth D. Merry sc->mpr_flags |= MPR_FLAGS_BUSY; 772991554f2SKenneth D. Merry mpr_unlock(sc); 773991554f2SKenneth D. Merry 774991554f2SKenneth D. Merry /* 775991554f2SKenneth D. Merry * Do some validation on data direction. Valid cases are: 776991554f2SKenneth D. Merry * 1) DataSize is 0 and direction is NONE 777991554f2SKenneth D. Merry * 2) DataSize is non-zero and one of: 778991554f2SKenneth D. Merry * a) direction is READ or 779991554f2SKenneth D. Merry * b) direction is WRITE or 780991554f2SKenneth D. Merry * c) direction is BOTH and DataOutSize is non-zero 781991554f2SKenneth D. Merry * If valid and the direction is BOTH, change the direction to READ. 782991554f2SKenneth D. Merry * if valid and the direction is not BOTH, make sure DataOutSize is 0. 783991554f2SKenneth D. Merry */ 784991554f2SKenneth D. Merry if (((data->DataSize == 0) && 785991554f2SKenneth D. Merry (data->DataDirection == MPR_PASS_THRU_DIRECTION_NONE)) || 786991554f2SKenneth D. Merry ((data->DataSize != 0) && 787991554f2SKenneth D. Merry ((data->DataDirection == MPR_PASS_THRU_DIRECTION_READ) || 788991554f2SKenneth D. Merry (data->DataDirection == MPR_PASS_THRU_DIRECTION_WRITE) || 789991554f2SKenneth D. Merry ((data->DataDirection == MPR_PASS_THRU_DIRECTION_BOTH) && 790991554f2SKenneth D. Merry (data->DataOutSize != 0))))) { 791991554f2SKenneth D. Merry if (data->DataDirection == MPR_PASS_THRU_DIRECTION_BOTH) 792991554f2SKenneth D. Merry data->DataDirection = MPR_PASS_THRU_DIRECTION_READ; 793991554f2SKenneth D. Merry else 794991554f2SKenneth D. Merry data->DataOutSize = 0; 795991554f2SKenneth D. Merry } else 796991554f2SKenneth D. Merry return (EINVAL); 797991554f2SKenneth D. Merry 798991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: req 0x%jx %d rpl 0x%jx %d " 799991554f2SKenneth D. Merry "data in 0x%jx %d data out 0x%jx %d data dir %d\n", __func__, 800991554f2SKenneth D. Merry data->PtrRequest, data->RequestSize, data->PtrReply, 801991554f2SKenneth D. Merry data->ReplySize, data->PtrData, data->DataSize, 802991554f2SKenneth D. Merry data->PtrDataOut, data->DataOutSize, data->DataDirection); 803991554f2SKenneth D. Merry 804991554f2SKenneth D. Merry /* 805991554f2SKenneth D. Merry * copy in the header so we know what we're dealing with before we 806991554f2SKenneth D. Merry * commit to allocating a command for it. 807991554f2SKenneth D. Merry */ 808991554f2SKenneth D. Merry err = copyin(PTRIN(data->PtrRequest), &tmphdr, data->RequestSize); 809991554f2SKenneth D. Merry if (err != 0) 810991554f2SKenneth D. Merry goto RetFreeUnlocked; 811991554f2SKenneth D. Merry 812991554f2SKenneth D. Merry if (data->RequestSize > (int)sc->facts->IOCRequestFrameSize * 4) { 813991554f2SKenneth D. Merry err = EINVAL; 814991554f2SKenneth D. Merry goto RetFreeUnlocked; 815991554f2SKenneth D. Merry } 816991554f2SKenneth D. Merry 817991554f2SKenneth D. Merry function = tmphdr.Function; 818991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: Function %02X MsgFlags %02X\n", __func__, 819991554f2SKenneth D. Merry function, tmphdr.MsgFlags); 820991554f2SKenneth D. Merry 821991554f2SKenneth D. Merry /* 822991554f2SKenneth D. Merry * Handle a passthru TM request. 823991554f2SKenneth D. Merry */ 824991554f2SKenneth D. Merry if (function == MPI2_FUNCTION_SCSI_TASK_MGMT) { 825991554f2SKenneth D. Merry MPI2_SCSI_TASK_MANAGE_REQUEST *task; 826991554f2SKenneth D. Merry 827991554f2SKenneth D. Merry mpr_lock(sc); 828991554f2SKenneth D. Merry cm = mprsas_alloc_tm(sc); 829991554f2SKenneth D. Merry if (cm == NULL) { 830991554f2SKenneth D. Merry err = EINVAL; 831991554f2SKenneth D. Merry goto Ret; 832991554f2SKenneth D. Merry } 833991554f2SKenneth D. Merry 834991554f2SKenneth D. Merry /* Copy the header in. Only a small fixup is needed. */ 835991554f2SKenneth D. Merry task = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req; 836991554f2SKenneth D. Merry bcopy(&tmphdr, task, data->RequestSize); 837991554f2SKenneth D. Merry task->TaskMID = cm->cm_desc.Default.SMID; 838991554f2SKenneth D. Merry 839991554f2SKenneth D. Merry cm->cm_data = NULL; 840a2c14879SStephen McConnell cm->cm_desc.HighPriority.RequestFlags = 841a2c14879SStephen McConnell MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY; 842991554f2SKenneth D. Merry cm->cm_complete = NULL; 843991554f2SKenneth D. Merry cm->cm_complete_data = NULL; 844991554f2SKenneth D. Merry 845a2c14879SStephen McConnell targ = mprsas_find_target_by_handle(sc->sassc, 0, 846a2c14879SStephen McConnell task->DevHandle); 847a2c14879SStephen McConnell if (targ == NULL) { 848a2c14879SStephen McConnell mpr_dprint(sc, MPR_INFO, 849a2c14879SStephen McConnell "%s %d : invalid handle for requested TM 0x%x \n", 850a2c14879SStephen McConnell __func__, __LINE__, task->DevHandle); 851a2c14879SStephen McConnell err = 1; 852a2c14879SStephen McConnell } else { 853a2c14879SStephen McConnell mprsas_prepare_for_tm(sc, cm, targ, CAM_LUN_WILDCARD); 8546d4ffcb4SKenneth D. Merry err = mpr_wait_command(sc, &cm, 30, CAN_SLEEP); 855a2c14879SStephen McConnell } 856991554f2SKenneth D. Merry 857991554f2SKenneth D. Merry if (err != 0) { 858991554f2SKenneth D. Merry err = EIO; 859991554f2SKenneth D. Merry mpr_dprint(sc, MPR_FAULT, "%s: task management failed", 860991554f2SKenneth D. Merry __func__); 861991554f2SKenneth D. Merry } 862991554f2SKenneth D. Merry /* 863991554f2SKenneth D. Merry * Copy the reply data and sense data to user space. 864991554f2SKenneth D. Merry */ 8656d4ffcb4SKenneth D. Merry if ((cm != NULL) && (cm->cm_reply != NULL)) { 866991554f2SKenneth D. Merry rpl = (MPI2_DEFAULT_REPLY *)cm->cm_reply; 867991554f2SKenneth D. Merry sz = rpl->MsgLength * 4; 868991554f2SKenneth D. Merry 869991554f2SKenneth D. Merry if (sz > data->ReplySize) { 870991554f2SKenneth D. Merry mpr_printf(sc, "%s: user reply buffer (%d) " 871991554f2SKenneth D. Merry "smaller than returned buffer (%d)\n", 872991554f2SKenneth D. Merry __func__, data->ReplySize, sz); 873991554f2SKenneth D. Merry } 874991554f2SKenneth D. Merry mpr_unlock(sc); 875991554f2SKenneth D. Merry copyout(cm->cm_reply, PTRIN(data->PtrReply), 876991554f2SKenneth D. Merry data->ReplySize); 877991554f2SKenneth D. Merry mpr_lock(sc); 878991554f2SKenneth D. Merry } 879991554f2SKenneth D. Merry mprsas_free_tm(sc, cm); 880991554f2SKenneth D. Merry goto Ret; 881991554f2SKenneth D. Merry } 882991554f2SKenneth D. Merry 883991554f2SKenneth D. Merry mpr_lock(sc); 884991554f2SKenneth D. Merry cm = mpr_alloc_command(sc); 885991554f2SKenneth D. Merry 886991554f2SKenneth D. Merry if (cm == NULL) { 887991554f2SKenneth D. Merry mpr_printf(sc, "%s: no mpr requests\n", __func__); 888991554f2SKenneth D. Merry err = ENOMEM; 889991554f2SKenneth D. Merry goto Ret; 890991554f2SKenneth D. Merry } 891991554f2SKenneth D. Merry mpr_unlock(sc); 892991554f2SKenneth D. Merry 893991554f2SKenneth D. Merry hdr = (MPI2_REQUEST_HEADER *)cm->cm_req; 894991554f2SKenneth D. Merry bcopy(&tmphdr, hdr, data->RequestSize); 895991554f2SKenneth D. Merry 896991554f2SKenneth D. Merry /* 897991554f2SKenneth D. Merry * Do some checking to make sure the IOCTL request contains a valid 898991554f2SKenneth D. Merry * request. Then set the SGL info. 899991554f2SKenneth D. Merry */ 900991554f2SKenneth D. Merry mpr_init_sge(cm, hdr, (void *)((uint8_t *)hdr + data->RequestSize)); 901991554f2SKenneth D. Merry 902991554f2SKenneth D. Merry /* 903991554f2SKenneth D. Merry * Set up for read, write or both. From check above, DataOutSize will 904991554f2SKenneth D. Merry * be 0 if direction is READ or WRITE, but it will have some non-zero 905991554f2SKenneth D. Merry * value if the direction is BOTH. So, just use the biggest size to get 906991554f2SKenneth D. Merry * the cm_data buffer size. If direction is BOTH, 2 SGLs need to be set 907991554f2SKenneth D. Merry * up; the first is for the request and the second will contain the 908991554f2SKenneth D. Merry * response data. cm_out_len needs to be set here and this will be used 909991554f2SKenneth D. Merry * when the SGLs are set up. 910991554f2SKenneth D. Merry */ 911991554f2SKenneth D. Merry cm->cm_data = NULL; 912991554f2SKenneth D. Merry cm->cm_length = MAX(data->DataSize, data->DataOutSize); 913991554f2SKenneth D. Merry cm->cm_out_len = data->DataOutSize; 914991554f2SKenneth D. Merry cm->cm_flags = 0; 915991554f2SKenneth D. Merry if (cm->cm_length != 0) { 916991554f2SKenneth D. Merry cm->cm_data = malloc(cm->cm_length, M_MPRUSER, M_WAITOK | 917991554f2SKenneth D. Merry M_ZERO); 918991554f2SKenneth D. Merry cm->cm_flags = MPR_CM_FLAGS_DATAIN; 919991554f2SKenneth D. Merry if (data->DataOutSize) { 920991554f2SKenneth D. Merry cm->cm_flags |= MPR_CM_FLAGS_DATAOUT; 921991554f2SKenneth D. Merry err = copyin(PTRIN(data->PtrDataOut), 922991554f2SKenneth D. Merry cm->cm_data, data->DataOutSize); 923991554f2SKenneth D. Merry } else if (data->DataDirection == 924991554f2SKenneth D. Merry MPR_PASS_THRU_DIRECTION_WRITE) { 925991554f2SKenneth D. Merry cm->cm_flags = MPR_CM_FLAGS_DATAOUT; 926991554f2SKenneth D. Merry err = copyin(PTRIN(data->PtrData), 927991554f2SKenneth D. Merry cm->cm_data, data->DataSize); 928991554f2SKenneth D. Merry } 929991554f2SKenneth D. Merry if (err != 0) 93067feec50SStephen McConnell mpr_dprint(sc, MPR_FAULT, "%s: failed to copy IOCTL " 93167feec50SStephen McConnell "data from user space\n", __func__); 932991554f2SKenneth D. Merry } 933991554f2SKenneth D. Merry /* 934991554f2SKenneth D. Merry * Set this flag only if processing a command that does not need an 935991554f2SKenneth D. Merry * IEEE SGL. The CLI Tool within the Toolbox uses IEEE SGLs, so clear 936991554f2SKenneth D. Merry * the flag only for that tool if processing a Toolbox function. 937991554f2SKenneth D. Merry */ 938991554f2SKenneth D. Merry cm->cm_flags |= MPR_CM_FLAGS_SGE_SIMPLE; 939991554f2SKenneth D. Merry for (i = 0; i < sizeof (ieee_sgl_func_list); i++) { 940991554f2SKenneth D. Merry if (function == ieee_sgl_func_list[i]) { 941991554f2SKenneth D. Merry if (function == MPI2_FUNCTION_TOOLBOX) 942991554f2SKenneth D. Merry { 943991554f2SKenneth D. Merry tool = (uint8_t)hdr->FunctionDependent1; 944991554f2SKenneth D. Merry if (tool != MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL) 945991554f2SKenneth D. Merry break; 946991554f2SKenneth D. Merry } 947991554f2SKenneth D. Merry cm->cm_flags &= ~MPR_CM_FLAGS_SGE_SIMPLE; 948991554f2SKenneth D. Merry break; 949991554f2SKenneth D. Merry } 950991554f2SKenneth D. Merry } 951991554f2SKenneth D. Merry cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 952991554f2SKenneth D. Merry 95367feec50SStephen McConnell if (function == MPI2_FUNCTION_NVME_ENCAPSULATED) { 95467feec50SStephen McConnell nvme_encap_request = 95567feec50SStephen McConnell (Mpi26NVMeEncapsulatedRequest_t *)cm->cm_req; 95667feec50SStephen McConnell cm->cm_desc.Default.RequestFlags = 95767feec50SStephen McConnell MPI26_REQ_DESCRIPT_FLAGS_PCIE_ENCAPSULATED; 95867feec50SStephen McConnell 95967feec50SStephen McConnell /* 96067feec50SStephen McConnell * Get the Physical Address of the sense buffer. 96167feec50SStephen McConnell * Save the user's Error Response buffer address and use that 96267feec50SStephen McConnell * field to hold the sense buffer address. 96367feec50SStephen McConnell * Clear the internal sense buffer, which will potentially hold 96467feec50SStephen McConnell * the Completion Queue Entry on return, or 0 if no Entry. 96567feec50SStephen McConnell * Build the PRPs and set direction bits. 96667feec50SStephen McConnell * Send the request. 96767feec50SStephen McConnell */ 96867feec50SStephen McConnell cm->nvme_error_response = 96967feec50SStephen McConnell (uint64_t *)(uintptr_t)(((uint64_t)nvme_encap_request-> 97067feec50SStephen McConnell ErrorResponseBaseAddress.High << 32) | 97167feec50SStephen McConnell (uint64_t)nvme_encap_request-> 97267feec50SStephen McConnell ErrorResponseBaseAddress.Low); 97367feec50SStephen McConnell nvme_encap_request->ErrorResponseBaseAddress.High = 97467feec50SStephen McConnell htole32((uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32)); 97567feec50SStephen McConnell nvme_encap_request->ErrorResponseBaseAddress.Low = 97667feec50SStephen McConnell htole32(cm->cm_sense_busaddr); 97767feec50SStephen McConnell memset(cm->cm_sense, 0, NVME_ERROR_RESPONSE_SIZE); 97867feec50SStephen McConnell mpr_build_nvme_prp(sc, cm, nvme_encap_request, cm->cm_data, 97967feec50SStephen McConnell data->DataSize, data->DataOutSize); 98067feec50SStephen McConnell } 98167feec50SStephen McConnell 982991554f2SKenneth D. Merry /* 983991554f2SKenneth D. Merry * Set up Sense buffer and SGL offset for IO passthru. SCSI IO request 984991554f2SKenneth D. Merry * uses SCSI IO or Fast Path SCSI IO descriptor. 985991554f2SKenneth D. Merry */ 986991554f2SKenneth D. Merry if ((function == MPI2_FUNCTION_SCSI_IO_REQUEST) || 987991554f2SKenneth D. Merry (function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) { 988991554f2SKenneth D. Merry MPI2_SCSI_IO_REQUEST *scsi_io_req; 989991554f2SKenneth D. Merry 990991554f2SKenneth D. Merry scsi_io_req = (MPI2_SCSI_IO_REQUEST *)hdr; 991991554f2SKenneth D. Merry /* 992991554f2SKenneth D. Merry * Put SGE for data and data_out buffer at the end of 993991554f2SKenneth D. Merry * scsi_io_request message header (64 bytes in total). 994991554f2SKenneth D. Merry * Following above SGEs, the residual space will be used by 995991554f2SKenneth D. Merry * sense data. 996991554f2SKenneth D. Merry */ 997991554f2SKenneth D. Merry scsi_io_req->SenseBufferLength = (uint8_t)(data->RequestSize - 998991554f2SKenneth D. Merry 64); 999991554f2SKenneth D. Merry scsi_io_req->SenseBufferLowAddress = 1000991554f2SKenneth D. Merry htole32(cm->cm_sense_busaddr); 1001991554f2SKenneth D. Merry 1002991554f2SKenneth D. Merry /* 1003991554f2SKenneth D. Merry * Set SGLOffset0 value. This is the number of dwords that SGL 1004991554f2SKenneth D. Merry * is offset from the beginning of MPI2_SCSI_IO_REQUEST struct. 1005991554f2SKenneth D. Merry */ 1006991554f2SKenneth D. Merry scsi_io_req->SGLOffset0 = 24; 1007991554f2SKenneth D. Merry 1008991554f2SKenneth D. Merry /* 1009991554f2SKenneth D. Merry * Setup descriptor info. RAID passthrough must use the 1010991554f2SKenneth D. Merry * default request descriptor which is already set, so if this 1011991554f2SKenneth D. Merry * is a SCSI IO request, change the descriptor to SCSI IO or 1012991554f2SKenneth D. Merry * Fast Path SCSI IO. Also, if this is a SCSI IO request, 1013991554f2SKenneth D. Merry * handle the reply in the mprsas_scsio_complete function. 1014991554f2SKenneth D. Merry */ 1015991554f2SKenneth D. Merry if (function == MPI2_FUNCTION_SCSI_IO_REQUEST) { 1016991554f2SKenneth D. Merry targ = mprsas_find_target_by_handle(sc->sassc, 0, 1017991554f2SKenneth D. Merry scsi_io_req->DevHandle); 1018991554f2SKenneth D. Merry 1019991554f2SKenneth D. Merry if (!targ) { 1020991554f2SKenneth D. Merry printf("No Target found for handle %d\n", 1021991554f2SKenneth D. Merry scsi_io_req->DevHandle); 1022991554f2SKenneth D. Merry err = EINVAL; 1023991554f2SKenneth D. Merry goto RetFreeUnlocked; 1024991554f2SKenneth D. Merry } 1025991554f2SKenneth D. Merry 1026991554f2SKenneth D. Merry if (targ->scsi_req_desc_type == 1027991554f2SKenneth D. Merry MPI25_REQ_DESCRIPT_FLAGS_FAST_PATH_SCSI_IO) { 1028991554f2SKenneth D. Merry cm->cm_desc.FastPathSCSIIO.RequestFlags = 1029991554f2SKenneth D. Merry MPI25_REQ_DESCRIPT_FLAGS_FAST_PATH_SCSI_IO; 103067feec50SStephen McConnell if (!sc->atomic_desc_capable) { 1031991554f2SKenneth D. Merry cm->cm_desc.FastPathSCSIIO.DevHandle = 1032991554f2SKenneth D. Merry scsi_io_req->DevHandle; 103367feec50SStephen McConnell } 1034991554f2SKenneth D. Merry scsi_io_req->IoFlags |= 1035991554f2SKenneth D. Merry MPI25_SCSIIO_IOFLAGS_FAST_PATH; 1036991554f2SKenneth D. Merry } else { 1037991554f2SKenneth D. Merry cm->cm_desc.SCSIIO.RequestFlags = 1038991554f2SKenneth D. Merry MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO; 103967feec50SStephen McConnell if (!sc->atomic_desc_capable) { 1040991554f2SKenneth D. Merry cm->cm_desc.SCSIIO.DevHandle = 1041991554f2SKenneth D. Merry scsi_io_req->DevHandle; 1042991554f2SKenneth D. Merry } 104367feec50SStephen McConnell } 1044991554f2SKenneth D. Merry 1045991554f2SKenneth D. Merry /* 1046991554f2SKenneth D. Merry * Make sure the DevHandle is not 0 because this is a 1047991554f2SKenneth D. Merry * likely error. 1048991554f2SKenneth D. Merry */ 1049991554f2SKenneth D. Merry if (scsi_io_req->DevHandle == 0) { 1050991554f2SKenneth D. Merry err = EINVAL; 1051991554f2SKenneth D. Merry goto RetFreeUnlocked; 1052991554f2SKenneth D. Merry } 1053991554f2SKenneth D. Merry } 1054991554f2SKenneth D. Merry } 1055991554f2SKenneth D. Merry 1056991554f2SKenneth D. Merry mpr_lock(sc); 1057991554f2SKenneth D. Merry 10586d4ffcb4SKenneth D. Merry err = mpr_wait_command(sc, &cm, 30, CAN_SLEEP); 1059991554f2SKenneth D. Merry 10606d4ffcb4SKenneth D. Merry if (err || (cm == NULL)) { 1061991554f2SKenneth D. Merry mpr_printf(sc, "%s: invalid request: error %d\n", __func__, 1062991554f2SKenneth D. Merry err); 10636d4ffcb4SKenneth D. Merry goto RetFree; 1064991554f2SKenneth D. Merry } 1065991554f2SKenneth D. Merry 1066991554f2SKenneth D. Merry /* 1067991554f2SKenneth D. Merry * Sync the DMA data, if any. Then copy the data to user space. 1068991554f2SKenneth D. Merry */ 1069991554f2SKenneth D. Merry if (cm->cm_data != NULL) { 1070991554f2SKenneth D. Merry if (cm->cm_flags & MPR_CM_FLAGS_DATAIN) 1071991554f2SKenneth D. Merry dir = BUS_DMASYNC_POSTREAD; 1072991554f2SKenneth D. Merry else if (cm->cm_flags & MPR_CM_FLAGS_DATAOUT) 1073a2c14879SStephen McConnell dir = BUS_DMASYNC_POSTWRITE; 1074991554f2SKenneth D. Merry bus_dmamap_sync(sc->buffer_dmat, cm->cm_dmamap, dir); 1075991554f2SKenneth D. Merry bus_dmamap_unload(sc->buffer_dmat, cm->cm_dmamap); 1076991554f2SKenneth D. Merry 1077991554f2SKenneth D. Merry if (cm->cm_flags & MPR_CM_FLAGS_DATAIN) { 1078991554f2SKenneth D. Merry mpr_unlock(sc); 1079991554f2SKenneth D. Merry err = copyout(cm->cm_data, 1080991554f2SKenneth D. Merry PTRIN(data->PtrData), data->DataSize); 1081991554f2SKenneth D. Merry mpr_lock(sc); 1082991554f2SKenneth D. Merry if (err != 0) 1083991554f2SKenneth D. Merry mpr_dprint(sc, MPR_FAULT, "%s: failed to copy " 1084991554f2SKenneth D. Merry "IOCTL data to user space\n", __func__); 1085991554f2SKenneth D. Merry } 1086991554f2SKenneth D. Merry } 1087991554f2SKenneth D. Merry 1088991554f2SKenneth D. Merry /* 1089991554f2SKenneth D. Merry * Copy the reply data and sense data to user space. 1090991554f2SKenneth D. Merry */ 1091991554f2SKenneth D. Merry if (cm->cm_reply != NULL) { 1092991554f2SKenneth D. Merry rpl = (MPI2_DEFAULT_REPLY *)cm->cm_reply; 1093991554f2SKenneth D. Merry sz = rpl->MsgLength * 4; 1094991554f2SKenneth D. Merry 1095991554f2SKenneth D. Merry if (sz > data->ReplySize) { 1096991554f2SKenneth D. Merry mpr_printf(sc, "%s: user reply buffer (%d) smaller " 1097991554f2SKenneth D. Merry "than returned buffer (%d)\n", __func__, 1098991554f2SKenneth D. Merry data->ReplySize, sz); 1099991554f2SKenneth D. Merry } 1100991554f2SKenneth D. Merry mpr_unlock(sc); 1101991554f2SKenneth D. Merry copyout(cm->cm_reply, PTRIN(data->PtrReply), data->ReplySize); 1102991554f2SKenneth D. Merry mpr_lock(sc); 1103991554f2SKenneth D. Merry 1104991554f2SKenneth D. Merry if ((function == MPI2_FUNCTION_SCSI_IO_REQUEST) || 1105991554f2SKenneth D. Merry (function == MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) { 1106991554f2SKenneth D. Merry if (((MPI2_SCSI_IO_REPLY *)rpl)->SCSIState & 1107991554f2SKenneth D. Merry MPI2_SCSI_STATE_AUTOSENSE_VALID) { 1108991554f2SKenneth D. Merry sense_len = 1109991554f2SKenneth D. Merry MIN((le32toh(((MPI2_SCSI_IO_REPLY *)rpl)-> 1110991554f2SKenneth D. Merry SenseCount)), sizeof(struct 1111991554f2SKenneth D. Merry scsi_sense_data)); 1112991554f2SKenneth D. Merry mpr_unlock(sc); 1113991554f2SKenneth D. Merry copyout(cm->cm_sense, cm->cm_req + 64, 1114991554f2SKenneth D. Merry sense_len); 1115991554f2SKenneth D. Merry mpr_lock(sc); 1116991554f2SKenneth D. Merry } 1117991554f2SKenneth D. Merry } 111867feec50SStephen McConnell 111967feec50SStephen McConnell /* 112067feec50SStephen McConnell * Copy out the NVMe Error Reponse to user. The Error Response 112167feec50SStephen McConnell * buffer is given by the user, but a sense buffer is used to 112267feec50SStephen McConnell * get that data from the IOC. The user's 112367feec50SStephen McConnell * ErrorResponseBaseAddress is saved in the 112467feec50SStephen McConnell * 'nvme_error_response' field before the command because that 112567feec50SStephen McConnell * field is set to a sense buffer. When the command is 112667feec50SStephen McConnell * complete, the Error Response data from the IOC is copied to 112767feec50SStephen McConnell * that user address after it is checked for validity. 112867feec50SStephen McConnell * Also note that 'sense' buffers are not defined for 112967feec50SStephen McConnell * NVMe commands. Sense terminalogy is only used here so that 113067feec50SStephen McConnell * the same IOCTL structure and sense buffers can be used for 113167feec50SStephen McConnell * NVMe. 113267feec50SStephen McConnell */ 113367feec50SStephen McConnell if (function == MPI2_FUNCTION_NVME_ENCAPSULATED) { 113467feec50SStephen McConnell if (cm->nvme_error_response == NULL) { 113567feec50SStephen McConnell mpr_dprint(sc, MPR_INFO, "NVMe Error Response " 113667feec50SStephen McConnell "buffer is NULL. Response data will not be " 113767feec50SStephen McConnell "returned.\n"); 113867feec50SStephen McConnell mpr_unlock(sc); 113967feec50SStephen McConnell goto RetFreeUnlocked; 114067feec50SStephen McConnell } 114167feec50SStephen McConnell 114267feec50SStephen McConnell nvme_error_reply = 114367feec50SStephen McConnell (Mpi26NVMeEncapsulatedErrorReply_t *)cm->cm_reply; 114467feec50SStephen McConnell sz = MIN(le32toh(nvme_error_reply->ErrorResponseCount), 114567feec50SStephen McConnell NVME_ERROR_RESPONSE_SIZE); 114667feec50SStephen McConnell mpr_unlock(sc); 114767feec50SStephen McConnell copyout(cm->cm_sense, cm->nvme_error_response, sz); 114867feec50SStephen McConnell mpr_lock(sc); 114967feec50SStephen McConnell } 1150991554f2SKenneth D. Merry } 1151991554f2SKenneth D. Merry mpr_unlock(sc); 1152991554f2SKenneth D. Merry 1153991554f2SKenneth D. Merry RetFreeUnlocked: 1154991554f2SKenneth D. Merry mpr_lock(sc); 1155991554f2SKenneth D. Merry 11566d4ffcb4SKenneth D. Merry RetFree: 1157991554f2SKenneth D. Merry if (cm != NULL) { 1158991554f2SKenneth D. Merry if (cm->cm_data) 1159991554f2SKenneth D. Merry free(cm->cm_data, M_MPRUSER); 1160991554f2SKenneth D. Merry mpr_free_command(sc, cm); 1161991554f2SKenneth D. Merry } 1162991554f2SKenneth D. Merry Ret: 1163991554f2SKenneth D. Merry sc->mpr_flags &= ~MPR_FLAGS_BUSY; 1164991554f2SKenneth D. Merry mpr_unlock(sc); 1165991554f2SKenneth D. Merry 1166991554f2SKenneth D. Merry return (err); 1167991554f2SKenneth D. Merry } 1168991554f2SKenneth D. Merry 1169991554f2SKenneth D. Merry static void 1170991554f2SKenneth D. Merry mpr_user_get_adapter_data(struct mpr_softc *sc, mpr_adapter_data_t *data) 1171991554f2SKenneth D. Merry { 1172991554f2SKenneth D. Merry Mpi2ConfigReply_t mpi_reply; 1173991554f2SKenneth D. Merry Mpi2BiosPage3_t config_page; 1174991554f2SKenneth D. Merry 1175991554f2SKenneth D. Merry /* 1176991554f2SKenneth D. Merry * Use the PCI interface functions to get the Bus, Device, and Function 1177991554f2SKenneth D. Merry * information. 1178991554f2SKenneth D. Merry */ 1179991554f2SKenneth D. Merry data->PciInformation.u.bits.BusNumber = pci_get_bus(sc->mpr_dev); 1180991554f2SKenneth D. Merry data->PciInformation.u.bits.DeviceNumber = pci_get_slot(sc->mpr_dev); 1181991554f2SKenneth D. Merry data->PciInformation.u.bits.FunctionNumber = 1182991554f2SKenneth D. Merry pci_get_function(sc->mpr_dev); 1183991554f2SKenneth D. Merry 1184991554f2SKenneth D. Merry /* 1185991554f2SKenneth D. Merry * Get the FW version that should already be saved in IOC Facts. 1186991554f2SKenneth D. Merry */ 1187991554f2SKenneth D. Merry data->MpiFirmwareVersion = sc->facts->FWVersion.Word; 1188991554f2SKenneth D. Merry 1189991554f2SKenneth D. Merry /* 1190991554f2SKenneth D. Merry * General device info. 1191991554f2SKenneth D. Merry */ 1192991554f2SKenneth D. Merry data->AdapterType = MPRIOCTL_ADAPTER_TYPE_SAS3; 1193991554f2SKenneth D. Merry data->PCIDeviceHwId = pci_get_device(sc->mpr_dev); 1194991554f2SKenneth D. Merry data->PCIDeviceHwRev = pci_read_config(sc->mpr_dev, PCIR_REVID, 1); 1195991554f2SKenneth D. Merry data->SubSystemId = pci_get_subdevice(sc->mpr_dev); 1196991554f2SKenneth D. Merry data->SubsystemVendorId = pci_get_subvendor(sc->mpr_dev); 1197991554f2SKenneth D. Merry 1198991554f2SKenneth D. Merry /* 1199991554f2SKenneth D. Merry * Get the driver version. 1200991554f2SKenneth D. Merry */ 1201991554f2SKenneth D. Merry strcpy((char *)&data->DriverVersion[0], MPR_DRIVER_VERSION); 1202991554f2SKenneth D. Merry 1203991554f2SKenneth D. Merry /* 1204991554f2SKenneth D. Merry * Need to get BIOS Config Page 3 for the BIOS Version. 1205991554f2SKenneth D. Merry */ 1206991554f2SKenneth D. Merry data->BiosVersion = 0; 1207991554f2SKenneth D. Merry mpr_lock(sc); 1208991554f2SKenneth D. Merry if (mpr_config_get_bios_pg3(sc, &mpi_reply, &config_page)) 1209991554f2SKenneth D. Merry printf("%s: Error while retrieving BIOS Version\n", __func__); 1210991554f2SKenneth D. Merry else 1211991554f2SKenneth D. Merry data->BiosVersion = config_page.BiosVersion; 1212991554f2SKenneth D. Merry mpr_unlock(sc); 1213991554f2SKenneth D. Merry } 1214991554f2SKenneth D. Merry 1215991554f2SKenneth D. Merry static void 1216991554f2SKenneth D. Merry mpr_user_read_pci_info(struct mpr_softc *sc, mpr_pci_info_t *data) 1217991554f2SKenneth D. Merry { 1218991554f2SKenneth D. Merry int i; 1219991554f2SKenneth D. Merry 1220991554f2SKenneth D. Merry /* 1221991554f2SKenneth D. Merry * Use the PCI interface functions to get the Bus, Device, and Function 1222991554f2SKenneth D. Merry * information. 1223991554f2SKenneth D. Merry */ 1224991554f2SKenneth D. Merry data->BusNumber = pci_get_bus(sc->mpr_dev); 1225991554f2SKenneth D. Merry data->DeviceNumber = pci_get_slot(sc->mpr_dev); 1226991554f2SKenneth D. Merry data->FunctionNumber = pci_get_function(sc->mpr_dev); 1227991554f2SKenneth D. Merry 1228991554f2SKenneth D. Merry /* 1229991554f2SKenneth D. Merry * Now get the interrupt vector and the pci header. The vector can 1230991554f2SKenneth D. Merry * only be 0 right now. The header is the first 256 bytes of config 1231991554f2SKenneth D. Merry * space. 1232991554f2SKenneth D. Merry */ 1233991554f2SKenneth D. Merry data->InterruptVector = 0; 1234991554f2SKenneth D. Merry for (i = 0; i < sizeof (data->PciHeader); i++) { 1235991554f2SKenneth D. Merry data->PciHeader[i] = pci_read_config(sc->mpr_dev, i, 1); 1236991554f2SKenneth D. Merry } 1237991554f2SKenneth D. Merry } 1238991554f2SKenneth D. Merry 1239991554f2SKenneth D. Merry static uint8_t 1240991554f2SKenneth D. Merry mpr_get_fw_diag_buffer_number(struct mpr_softc *sc, uint32_t unique_id) 1241991554f2SKenneth D. Merry { 1242991554f2SKenneth D. Merry uint8_t index; 1243991554f2SKenneth D. Merry 1244991554f2SKenneth D. Merry for (index = 0; index < MPI2_DIAG_BUF_TYPE_COUNT; index++) { 1245991554f2SKenneth D. Merry if (sc->fw_diag_buffer_list[index].unique_id == unique_id) { 1246991554f2SKenneth D. Merry return (index); 1247991554f2SKenneth D. Merry } 1248991554f2SKenneth D. Merry } 1249991554f2SKenneth D. Merry 1250991554f2SKenneth D. Merry return (MPR_FW_DIAGNOSTIC_UID_NOT_FOUND); 1251991554f2SKenneth D. Merry } 1252991554f2SKenneth D. Merry 1253991554f2SKenneth D. Merry static int 1254991554f2SKenneth D. Merry mpr_post_fw_diag_buffer(struct mpr_softc *sc, 1255991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer, uint32_t *return_code) 1256991554f2SKenneth D. Merry { 1257991554f2SKenneth D. Merry MPI2_DIAG_BUFFER_POST_REQUEST *req; 1258991554f2SKenneth D. Merry MPI2_DIAG_BUFFER_POST_REPLY *reply; 1259991554f2SKenneth D. Merry struct mpr_command *cm = NULL; 1260991554f2SKenneth D. Merry int i, status; 1261991554f2SKenneth D. Merry 1262991554f2SKenneth D. Merry /* 1263991554f2SKenneth D. Merry * If buffer is not enabled, just leave. 1264991554f2SKenneth D. Merry */ 1265991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_POST_FAILED; 1266991554f2SKenneth D. Merry if (!pBuffer->enabled) { 1267991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1268991554f2SKenneth D. Merry } 1269991554f2SKenneth D. Merry 1270991554f2SKenneth D. Merry /* 1271991554f2SKenneth D. Merry * Clear some flags initially. 1272991554f2SKenneth D. Merry */ 1273991554f2SKenneth D. Merry pBuffer->force_release = FALSE; 1274991554f2SKenneth D. Merry pBuffer->valid_data = FALSE; 1275991554f2SKenneth D. Merry pBuffer->owned_by_firmware = FALSE; 1276991554f2SKenneth D. Merry 1277991554f2SKenneth D. Merry /* 1278991554f2SKenneth D. Merry * Get a command. 1279991554f2SKenneth D. Merry */ 1280991554f2SKenneth D. Merry cm = mpr_alloc_command(sc); 1281991554f2SKenneth D. Merry if (cm == NULL) { 1282991554f2SKenneth D. Merry mpr_printf(sc, "%s: no mpr requests\n", __func__); 1283991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1284991554f2SKenneth D. Merry } 1285991554f2SKenneth D. Merry 1286991554f2SKenneth D. Merry /* 1287991554f2SKenneth D. Merry * Build the request for releasing the FW Diag Buffer and send it. 1288991554f2SKenneth D. Merry */ 1289991554f2SKenneth D. Merry req = (MPI2_DIAG_BUFFER_POST_REQUEST *)cm->cm_req; 1290991554f2SKenneth D. Merry req->Function = MPI2_FUNCTION_DIAG_BUFFER_POST; 1291991554f2SKenneth D. Merry req->BufferType = pBuffer->buffer_type; 1292991554f2SKenneth D. Merry req->ExtendedType = pBuffer->extended_type; 1293991554f2SKenneth D. Merry req->BufferLength = pBuffer->size; 1294991554f2SKenneth D. Merry for (i = 0; i < (sizeof(req->ProductSpecific) / 4); i++) 1295991554f2SKenneth D. Merry req->ProductSpecific[i] = pBuffer->product_specific[i]; 1296991554f2SKenneth D. Merry mpr_from_u64(sc->fw_diag_busaddr, &req->BufferAddress); 1297991554f2SKenneth D. Merry cm->cm_data = NULL; 1298991554f2SKenneth D. Merry cm->cm_length = 0; 1299991554f2SKenneth D. Merry cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1300991554f2SKenneth D. Merry cm->cm_complete_data = NULL; 1301991554f2SKenneth D. Merry 1302991554f2SKenneth D. Merry /* 1303991554f2SKenneth D. Merry * Send command synchronously. 1304991554f2SKenneth D. Merry */ 13056d4ffcb4SKenneth D. Merry status = mpr_wait_command(sc, &cm, 30, CAN_SLEEP); 13066d4ffcb4SKenneth D. Merry if (status || (cm == NULL)) { 1307991554f2SKenneth D. Merry mpr_printf(sc, "%s: invalid request: error %d\n", __func__, 1308991554f2SKenneth D. Merry status); 1309991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1310991554f2SKenneth D. Merry goto done; 1311991554f2SKenneth D. Merry } 1312991554f2SKenneth D. Merry 1313991554f2SKenneth D. Merry /* 1314991554f2SKenneth D. Merry * Process POST reply. 1315991554f2SKenneth D. Merry */ 1316991554f2SKenneth D. Merry reply = (MPI2_DIAG_BUFFER_POST_REPLY *)cm->cm_reply; 1317*e2997a03SKenneth D. Merry if (reply == NULL) { 1318*e2997a03SKenneth D. Merry mpr_printf(sc, "%s: reply is NULL, probably due to " 1319*e2997a03SKenneth D. Merry "reinitialization", __func__); 1320*e2997a03SKenneth D. Merry status = MPR_DIAG_FAILURE; 1321*e2997a03SKenneth D. Merry goto done; 1322*e2997a03SKenneth D. Merry } 1323*e2997a03SKenneth D. Merry 1324d3f6eabfSStephen McConnell if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) != 1325d3f6eabfSStephen McConnell MPI2_IOCSTATUS_SUCCESS) { 1326991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1327991554f2SKenneth D. Merry mpr_dprint(sc, MPR_FAULT, "%s: post of FW Diag Buffer failed " 1328991554f2SKenneth D. Merry "with IOCStatus = 0x%x, IOCLogInfo = 0x%x and " 1329d3f6eabfSStephen McConnell "TransferLength = 0x%x\n", __func__, 1330d3f6eabfSStephen McConnell le16toh(reply->IOCStatus), le32toh(reply->IOCLogInfo), 1331d3f6eabfSStephen McConnell le32toh(reply->TransferLength)); 1332991554f2SKenneth D. Merry goto done; 1333991554f2SKenneth D. Merry } 1334991554f2SKenneth D. Merry 1335991554f2SKenneth D. Merry /* 1336991554f2SKenneth D. Merry * Post was successful. 1337991554f2SKenneth D. Merry */ 1338991554f2SKenneth D. Merry pBuffer->valid_data = TRUE; 1339991554f2SKenneth D. Merry pBuffer->owned_by_firmware = TRUE; 1340991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_SUCCESS; 1341991554f2SKenneth D. Merry status = MPR_DIAG_SUCCESS; 1342991554f2SKenneth D. Merry 1343991554f2SKenneth D. Merry done: 13446d4ffcb4SKenneth D. Merry if (cm != NULL) 1345991554f2SKenneth D. Merry mpr_free_command(sc, cm); 1346991554f2SKenneth D. Merry return (status); 1347991554f2SKenneth D. Merry } 1348991554f2SKenneth D. Merry 1349991554f2SKenneth D. Merry static int 1350991554f2SKenneth D. Merry mpr_release_fw_diag_buffer(struct mpr_softc *sc, 1351991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer, uint32_t *return_code, 1352991554f2SKenneth D. Merry uint32_t diag_type) 1353991554f2SKenneth D. Merry { 1354991554f2SKenneth D. Merry MPI2_DIAG_RELEASE_REQUEST *req; 1355991554f2SKenneth D. Merry MPI2_DIAG_RELEASE_REPLY *reply; 1356991554f2SKenneth D. Merry struct mpr_command *cm = NULL; 1357991554f2SKenneth D. Merry int status; 1358991554f2SKenneth D. Merry 1359991554f2SKenneth D. Merry /* 1360991554f2SKenneth D. Merry * If buffer is not enabled, just leave. 1361991554f2SKenneth D. Merry */ 1362991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_RELEASE_FAILED; 1363991554f2SKenneth D. Merry if (!pBuffer->enabled) { 1364991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: This buffer type is not " 1365991554f2SKenneth D. Merry "supported by the IOC", __func__); 1366991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1367991554f2SKenneth D. Merry } 1368991554f2SKenneth D. Merry 1369991554f2SKenneth D. Merry /* 1370991554f2SKenneth D. Merry * Clear some flags initially. 1371991554f2SKenneth D. Merry */ 1372991554f2SKenneth D. Merry pBuffer->force_release = FALSE; 1373991554f2SKenneth D. Merry pBuffer->valid_data = FALSE; 1374991554f2SKenneth D. Merry pBuffer->owned_by_firmware = FALSE; 1375991554f2SKenneth D. Merry 1376991554f2SKenneth D. Merry /* 1377991554f2SKenneth D. Merry * Get a command. 1378991554f2SKenneth D. Merry */ 1379991554f2SKenneth D. Merry cm = mpr_alloc_command(sc); 1380991554f2SKenneth D. Merry if (cm == NULL) { 1381991554f2SKenneth D. Merry mpr_printf(sc, "%s: no mpr requests\n", __func__); 1382991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1383991554f2SKenneth D. Merry } 1384991554f2SKenneth D. Merry 1385991554f2SKenneth D. Merry /* 1386991554f2SKenneth D. Merry * Build the request for releasing the FW Diag Buffer and send it. 1387991554f2SKenneth D. Merry */ 1388991554f2SKenneth D. Merry req = (MPI2_DIAG_RELEASE_REQUEST *)cm->cm_req; 1389991554f2SKenneth D. Merry req->Function = MPI2_FUNCTION_DIAG_RELEASE; 1390991554f2SKenneth D. Merry req->BufferType = pBuffer->buffer_type; 1391991554f2SKenneth D. Merry cm->cm_data = NULL; 1392991554f2SKenneth D. Merry cm->cm_length = 0; 1393991554f2SKenneth D. Merry cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1394991554f2SKenneth D. Merry cm->cm_complete_data = NULL; 1395991554f2SKenneth D. Merry 1396991554f2SKenneth D. Merry /* 1397991554f2SKenneth D. Merry * Send command synchronously. 1398991554f2SKenneth D. Merry */ 13996d4ffcb4SKenneth D. Merry status = mpr_wait_command(sc, &cm, 30, CAN_SLEEP); 14006d4ffcb4SKenneth D. Merry if (status || (cm == NULL)) { 1401991554f2SKenneth D. Merry mpr_printf(sc, "%s: invalid request: error %d\n", __func__, 1402991554f2SKenneth D. Merry status); 1403991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1404991554f2SKenneth D. Merry goto done; 1405991554f2SKenneth D. Merry } 1406991554f2SKenneth D. Merry 1407991554f2SKenneth D. Merry /* 1408991554f2SKenneth D. Merry * Process RELEASE reply. 1409991554f2SKenneth D. Merry */ 1410991554f2SKenneth D. Merry reply = (MPI2_DIAG_RELEASE_REPLY *)cm->cm_reply; 1411*e2997a03SKenneth D. Merry if (reply == NULL) { 1412*e2997a03SKenneth D. Merry mpr_printf(sc, "%s: reply is NULL, probably due to " 1413*e2997a03SKenneth D. Merry "reinitialization", __func__); 1414*e2997a03SKenneth D. Merry status = MPR_DIAG_FAILURE; 1415*e2997a03SKenneth D. Merry goto done; 1416*e2997a03SKenneth D. Merry } 1417d3f6eabfSStephen McConnell if (((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) != 1418d3f6eabfSStephen McConnell MPI2_IOCSTATUS_SUCCESS) || pBuffer->owned_by_firmware) { 1419991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1420991554f2SKenneth D. Merry mpr_dprint(sc, MPR_FAULT, "%s: release of FW Diag Buffer " 1421991554f2SKenneth D. Merry "failed with IOCStatus = 0x%x and IOCLogInfo = 0x%x\n", 1422d3f6eabfSStephen McConnell __func__, le16toh(reply->IOCStatus), 1423d3f6eabfSStephen McConnell le32toh(reply->IOCLogInfo)); 1424991554f2SKenneth D. Merry goto done; 1425991554f2SKenneth D. Merry } 1426991554f2SKenneth D. Merry 1427991554f2SKenneth D. Merry /* 1428991554f2SKenneth D. Merry * Release was successful. 1429991554f2SKenneth D. Merry */ 1430991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_SUCCESS; 1431991554f2SKenneth D. Merry status = MPR_DIAG_SUCCESS; 1432991554f2SKenneth D. Merry 1433991554f2SKenneth D. Merry /* 1434991554f2SKenneth D. Merry * If this was for an UNREGISTER diag type command, clear the unique ID. 1435991554f2SKenneth D. Merry */ 1436991554f2SKenneth D. Merry if (diag_type == MPR_FW_DIAG_TYPE_UNREGISTER) { 1437991554f2SKenneth D. Merry pBuffer->unique_id = MPR_FW_DIAG_INVALID_UID; 1438991554f2SKenneth D. Merry } 1439991554f2SKenneth D. Merry 1440991554f2SKenneth D. Merry done: 14416d4ffcb4SKenneth D. Merry if (cm != NULL) 14426d4ffcb4SKenneth D. Merry mpr_free_command(sc, cm); 14436d4ffcb4SKenneth D. Merry 1444991554f2SKenneth D. Merry return (status); 1445991554f2SKenneth D. Merry } 1446991554f2SKenneth D. Merry 1447991554f2SKenneth D. Merry static int 1448a2c14879SStephen McConnell mpr_diag_register(struct mpr_softc *sc, mpr_fw_diag_register_t *diag_register, 1449a2c14879SStephen McConnell uint32_t *return_code) 1450991554f2SKenneth D. Merry { 1451991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer; 1452*e2997a03SKenneth D. Merry struct mpr_busdma_context *ctx; 1453991554f2SKenneth D. Merry uint8_t extended_type, buffer_type, i; 1454991554f2SKenneth D. Merry uint32_t buffer_size; 1455991554f2SKenneth D. Merry uint32_t unique_id; 1456991554f2SKenneth D. Merry int status; 1457*e2997a03SKenneth D. Merry int error; 1458991554f2SKenneth D. Merry 1459991554f2SKenneth D. Merry extended_type = diag_register->ExtendedType; 1460991554f2SKenneth D. Merry buffer_type = diag_register->BufferType; 1461991554f2SKenneth D. Merry buffer_size = diag_register->RequestedBufferSize; 1462991554f2SKenneth D. Merry unique_id = diag_register->UniqueId; 1463*e2997a03SKenneth D. Merry ctx = NULL; 1464*e2997a03SKenneth D. Merry error = 0; 1465991554f2SKenneth D. Merry 1466991554f2SKenneth D. Merry /* 1467991554f2SKenneth D. Merry * Check for valid buffer type 1468991554f2SKenneth D. Merry */ 1469991554f2SKenneth D. Merry if (buffer_type >= MPI2_DIAG_BUF_TYPE_COUNT) { 1470991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1471991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1472991554f2SKenneth D. Merry } 1473991554f2SKenneth D. Merry 1474991554f2SKenneth D. Merry /* 1475991554f2SKenneth D. Merry * Get the current buffer and look up the unique ID. The unique ID 1476991554f2SKenneth D. Merry * should not be found. If it is, the ID is already in use. 1477991554f2SKenneth D. Merry */ 1478991554f2SKenneth D. Merry i = mpr_get_fw_diag_buffer_number(sc, unique_id); 1479991554f2SKenneth D. Merry pBuffer = &sc->fw_diag_buffer_list[buffer_type]; 1480991554f2SKenneth D. Merry if (i != MPR_FW_DIAGNOSTIC_UID_NOT_FOUND) { 1481991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_UID; 1482991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1483991554f2SKenneth D. Merry } 1484991554f2SKenneth D. Merry 1485991554f2SKenneth D. Merry /* 1486991554f2SKenneth D. Merry * The buffer's unique ID should not be registered yet, and the given 1487991554f2SKenneth D. Merry * unique ID cannot be 0. 1488991554f2SKenneth D. Merry */ 1489991554f2SKenneth D. Merry if ((pBuffer->unique_id != MPR_FW_DIAG_INVALID_UID) || 1490991554f2SKenneth D. Merry (unique_id == MPR_FW_DIAG_INVALID_UID)) { 1491991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_UID; 1492991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1493991554f2SKenneth D. Merry } 1494991554f2SKenneth D. Merry 1495991554f2SKenneth D. Merry /* 1496991554f2SKenneth D. Merry * If this buffer is already posted as immediate, just change owner. 1497991554f2SKenneth D. Merry */ 1498991554f2SKenneth D. Merry if (pBuffer->immediate && pBuffer->owned_by_firmware && 1499991554f2SKenneth D. Merry (pBuffer->unique_id == MPR_FW_DIAG_INVALID_UID)) { 1500991554f2SKenneth D. Merry pBuffer->immediate = FALSE; 1501991554f2SKenneth D. Merry pBuffer->unique_id = unique_id; 1502991554f2SKenneth D. Merry return (MPR_DIAG_SUCCESS); 1503991554f2SKenneth D. Merry } 1504991554f2SKenneth D. Merry 1505991554f2SKenneth D. Merry /* 1506991554f2SKenneth D. Merry * Post a new buffer after checking if it's enabled. The DMA buffer 1507991554f2SKenneth D. Merry * that is allocated will be contiguous (nsegments = 1). 1508991554f2SKenneth D. Merry */ 1509991554f2SKenneth D. Merry if (!pBuffer->enabled) { 1510991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_NO_BUFFER; 1511991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1512991554f2SKenneth D. Merry } 1513991554f2SKenneth D. Merry if (bus_dma_tag_create( sc->mpr_parent_dmat, /* parent */ 1514991554f2SKenneth D. Merry 1, 0, /* algnmnt, boundary */ 1515991554f2SKenneth D. Merry BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 1516991554f2SKenneth D. Merry BUS_SPACE_MAXADDR, /* highaddr */ 1517991554f2SKenneth D. Merry NULL, NULL, /* filter, filterarg */ 1518991554f2SKenneth D. Merry buffer_size, /* maxsize */ 1519991554f2SKenneth D. Merry 1, /* nsegments */ 1520991554f2SKenneth D. Merry buffer_size, /* maxsegsize */ 1521991554f2SKenneth D. Merry 0, /* flags */ 1522991554f2SKenneth D. Merry NULL, NULL, /* lockfunc, lockarg */ 1523991554f2SKenneth D. Merry &sc->fw_diag_dmat)) { 1524757ff642SScott Long mpr_dprint(sc, MPR_ERROR, 1525757ff642SScott Long "Cannot allocate FW diag buffer DMA tag\n"); 1526*e2997a03SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_NO_BUFFER; 1527*e2997a03SKenneth D. Merry status = MPR_DIAG_FAILURE; 1528*e2997a03SKenneth D. Merry goto bailout; 1529991554f2SKenneth D. Merry } 1530991554f2SKenneth D. Merry if (bus_dmamem_alloc(sc->fw_diag_dmat, (void **)&sc->fw_diag_buffer, 1531991554f2SKenneth D. Merry BUS_DMA_NOWAIT, &sc->fw_diag_map)) { 1532757ff642SScott Long mpr_dprint(sc, MPR_ERROR, 1533757ff642SScott Long "Cannot allocate FW diag buffer memory\n"); 1534*e2997a03SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_NO_BUFFER; 1535*e2997a03SKenneth D. Merry status = MPR_DIAG_FAILURE; 1536*e2997a03SKenneth D. Merry goto bailout; 1537991554f2SKenneth D. Merry } 1538991554f2SKenneth D. Merry bzero(sc->fw_diag_buffer, buffer_size); 1539*e2997a03SKenneth D. Merry 1540*e2997a03SKenneth D. Merry ctx = malloc(sizeof(*ctx), M_MPR, M_WAITOK | M_ZERO); 1541*e2997a03SKenneth D. Merry if (ctx == NULL) { 1542*e2997a03SKenneth D. Merry device_printf(sc->mpr_dev, "%s: context malloc failed\n", 1543*e2997a03SKenneth D. Merry __func__); 1544*e2997a03SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_NO_BUFFER; 1545*e2997a03SKenneth D. Merry status = MPR_DIAG_FAILURE; 1546*e2997a03SKenneth D. Merry goto bailout; 1547*e2997a03SKenneth D. Merry } 1548*e2997a03SKenneth D. Merry ctx->addr = &sc->fw_diag_busaddr; 1549*e2997a03SKenneth D. Merry ctx->buffer_dmat = sc->fw_diag_dmat; 1550*e2997a03SKenneth D. Merry ctx->buffer_dmamap = sc->fw_diag_map; 1551*e2997a03SKenneth D. Merry ctx->softc = sc; 1552*e2997a03SKenneth D. Merry error = bus_dmamap_load(sc->fw_diag_dmat, sc->fw_diag_map, 1553*e2997a03SKenneth D. Merry sc->fw_diag_buffer, buffer_size, mpr_memaddr_wait_cb, 1554*e2997a03SKenneth D. Merry ctx, 0); 1555*e2997a03SKenneth D. Merry if (error == EINPROGRESS) { 1556*e2997a03SKenneth D. Merry 1557*e2997a03SKenneth D. Merry /* XXX KDM */ 1558*e2997a03SKenneth D. Merry device_printf(sc->mpr_dev, "%s: Deferred bus_dmamap_load\n", 1559*e2997a03SKenneth D. Merry __func__); 1560*e2997a03SKenneth D. Merry /* 1561*e2997a03SKenneth D. Merry * Wait for the load to complete. If we're interrupted, 1562*e2997a03SKenneth D. Merry * bail out. 1563*e2997a03SKenneth D. Merry */ 1564*e2997a03SKenneth D. Merry mpr_lock(sc); 1565*e2997a03SKenneth D. Merry if (ctx->completed == 0) { 1566*e2997a03SKenneth D. Merry error = msleep(ctx, &sc->mpr_mtx, PCATCH, "mprwait", 0); 1567*e2997a03SKenneth D. Merry if (error != 0) { 1568*e2997a03SKenneth D. Merry /* 1569*e2997a03SKenneth D. Merry * We got an error from msleep(9). This is 1570*e2997a03SKenneth D. Merry * most likely due to a signal. Tell 1571*e2997a03SKenneth D. Merry * mpr_memaddr_wait_cb() that we've abandoned 1572*e2997a03SKenneth D. Merry * the context, so it needs to clean up when 1573*e2997a03SKenneth D. Merry * it is called. 1574*e2997a03SKenneth D. Merry */ 1575*e2997a03SKenneth D. Merry ctx->abandoned = 1; 1576*e2997a03SKenneth D. Merry 1577*e2997a03SKenneth D. Merry /* The callback will free this memory */ 1578*e2997a03SKenneth D. Merry ctx = NULL; 1579*e2997a03SKenneth D. Merry mpr_unlock(sc); 1580*e2997a03SKenneth D. Merry 1581*e2997a03SKenneth D. Merry device_printf(sc->mpr_dev, "Cannot " 1582*e2997a03SKenneth D. Merry "bus_dmamap_load FW diag buffer, error = " 1583*e2997a03SKenneth D. Merry "%d returned from msleep\n", error); 1584*e2997a03SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_NO_BUFFER; 1585*e2997a03SKenneth D. Merry status = MPR_DIAG_FAILURE; 1586*e2997a03SKenneth D. Merry goto bailout; 1587*e2997a03SKenneth D. Merry } 1588*e2997a03SKenneth D. Merry } 1589*e2997a03SKenneth D. Merry mpr_unlock(sc); 1590*e2997a03SKenneth D. Merry } 1591*e2997a03SKenneth D. Merry 1592*e2997a03SKenneth D. Merry if ((error != 0) || (ctx->error != 0)) { 1593*e2997a03SKenneth D. Merry device_printf(sc->mpr_dev, "Cannot bus_dmamap_load FW diag " 1594*e2997a03SKenneth D. Merry "buffer, %serror = %d\n", error ? "" : "callback ", 1595*e2997a03SKenneth D. Merry error ? error : ctx->error); 1596*e2997a03SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_NO_BUFFER; 1597*e2997a03SKenneth D. Merry status = MPR_DIAG_FAILURE; 1598*e2997a03SKenneth D. Merry goto bailout; 1599*e2997a03SKenneth D. Merry } 1600*e2997a03SKenneth D. Merry 1601*e2997a03SKenneth D. Merry bus_dmamap_sync(sc->fw_diag_dmat, sc->fw_diag_map, BUS_DMASYNC_PREREAD); 1602*e2997a03SKenneth D. Merry 1603991554f2SKenneth D. Merry pBuffer->size = buffer_size; 1604991554f2SKenneth D. Merry 1605991554f2SKenneth D. Merry /* 1606991554f2SKenneth D. Merry * Copy the given info to the diag buffer and post the buffer. 1607991554f2SKenneth D. Merry */ 1608991554f2SKenneth D. Merry pBuffer->buffer_type = buffer_type; 1609991554f2SKenneth D. Merry pBuffer->immediate = FALSE; 1610991554f2SKenneth D. Merry if (buffer_type == MPI2_DIAG_BUF_TYPE_TRACE) { 1611991554f2SKenneth D. Merry for (i = 0; i < (sizeof (pBuffer->product_specific) / 4); 1612991554f2SKenneth D. Merry i++) { 1613991554f2SKenneth D. Merry pBuffer->product_specific[i] = 1614991554f2SKenneth D. Merry diag_register->ProductSpecific[i]; 1615991554f2SKenneth D. Merry } 1616991554f2SKenneth D. Merry } 1617991554f2SKenneth D. Merry pBuffer->extended_type = extended_type; 1618991554f2SKenneth D. Merry pBuffer->unique_id = unique_id; 1619991554f2SKenneth D. Merry status = mpr_post_fw_diag_buffer(sc, pBuffer, return_code); 1620991554f2SKenneth D. Merry 1621*e2997a03SKenneth D. Merry bailout: 1622*e2997a03SKenneth D. Merry 1623991554f2SKenneth D. Merry /* 1624991554f2SKenneth D. Merry * In case there was a failure, free the DMA buffer. 1625991554f2SKenneth D. Merry */ 1626991554f2SKenneth D. Merry if (status == MPR_DIAG_FAILURE) { 1627*e2997a03SKenneth D. Merry if (sc->fw_diag_busaddr != 0) { 1628991554f2SKenneth D. Merry bus_dmamap_unload(sc->fw_diag_dmat, sc->fw_diag_map); 1629*e2997a03SKenneth D. Merry sc->fw_diag_busaddr = 0; 1630*e2997a03SKenneth D. Merry } 1631*e2997a03SKenneth D. Merry if (sc->fw_diag_buffer != NULL) { 1632991554f2SKenneth D. Merry bus_dmamem_free(sc->fw_diag_dmat, sc->fw_diag_buffer, 1633991554f2SKenneth D. Merry sc->fw_diag_map); 1634*e2997a03SKenneth D. Merry sc->fw_diag_buffer = NULL; 1635991554f2SKenneth D. Merry } 1636*e2997a03SKenneth D. Merry if (sc->fw_diag_dmat != NULL) { 1637*e2997a03SKenneth D. Merry bus_dma_tag_destroy(sc->fw_diag_dmat); 1638*e2997a03SKenneth D. Merry sc->fw_diag_dmat = NULL; 1639*e2997a03SKenneth D. Merry } 1640*e2997a03SKenneth D. Merry } 1641*e2997a03SKenneth D. Merry 1642*e2997a03SKenneth D. Merry if (ctx != NULL) 1643*e2997a03SKenneth D. Merry free(ctx, M_MPR); 1644991554f2SKenneth D. Merry 1645991554f2SKenneth D. Merry return (status); 1646991554f2SKenneth D. Merry } 1647991554f2SKenneth D. Merry 1648991554f2SKenneth D. Merry static int 1649991554f2SKenneth D. Merry mpr_diag_unregister(struct mpr_softc *sc, 1650991554f2SKenneth D. Merry mpr_fw_diag_unregister_t *diag_unregister, uint32_t *return_code) 1651991554f2SKenneth D. Merry { 1652991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer; 1653991554f2SKenneth D. Merry uint8_t i; 1654991554f2SKenneth D. Merry uint32_t unique_id; 1655991554f2SKenneth D. Merry int status; 1656991554f2SKenneth D. Merry 1657991554f2SKenneth D. Merry unique_id = diag_unregister->UniqueId; 1658991554f2SKenneth D. Merry 1659991554f2SKenneth D. Merry /* 1660991554f2SKenneth D. Merry * Get the current buffer and look up the unique ID. The unique ID 1661991554f2SKenneth D. Merry * should be there. 1662991554f2SKenneth D. Merry */ 1663991554f2SKenneth D. Merry i = mpr_get_fw_diag_buffer_number(sc, unique_id); 1664991554f2SKenneth D. Merry if (i == MPR_FW_DIAGNOSTIC_UID_NOT_FOUND) { 1665991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_UID; 1666991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1667991554f2SKenneth D. Merry } 1668991554f2SKenneth D. Merry 1669991554f2SKenneth D. Merry pBuffer = &sc->fw_diag_buffer_list[i]; 1670991554f2SKenneth D. Merry 1671991554f2SKenneth D. Merry /* 1672991554f2SKenneth D. Merry * Try to release the buffer from FW before freeing it. If release 1673991554f2SKenneth D. Merry * fails, don't free the DMA buffer in case FW tries to access it 1674991554f2SKenneth D. Merry * later. If buffer is not owned by firmware, can't release it. 1675991554f2SKenneth D. Merry */ 1676991554f2SKenneth D. Merry if (!pBuffer->owned_by_firmware) { 1677991554f2SKenneth D. Merry status = MPR_DIAG_SUCCESS; 1678991554f2SKenneth D. Merry } else { 1679991554f2SKenneth D. Merry status = mpr_release_fw_diag_buffer(sc, pBuffer, return_code, 1680991554f2SKenneth D. Merry MPR_FW_DIAG_TYPE_UNREGISTER); 1681991554f2SKenneth D. Merry } 1682991554f2SKenneth D. Merry 1683991554f2SKenneth D. Merry /* 1684991554f2SKenneth D. Merry * At this point, return the current status no matter what happens with 1685991554f2SKenneth D. Merry * the DMA buffer. 1686991554f2SKenneth D. Merry */ 1687991554f2SKenneth D. Merry pBuffer->unique_id = MPR_FW_DIAG_INVALID_UID; 1688991554f2SKenneth D. Merry if (status == MPR_DIAG_SUCCESS) { 1689*e2997a03SKenneth D. Merry if (sc->fw_diag_busaddr != 0) { 1690991554f2SKenneth D. Merry bus_dmamap_unload(sc->fw_diag_dmat, sc->fw_diag_map); 1691*e2997a03SKenneth D. Merry sc->fw_diag_busaddr = 0; 1692*e2997a03SKenneth D. Merry } 1693*e2997a03SKenneth D. Merry if (sc->fw_diag_buffer != NULL) { 1694991554f2SKenneth D. Merry bus_dmamem_free(sc->fw_diag_dmat, sc->fw_diag_buffer, 1695991554f2SKenneth D. Merry sc->fw_diag_map); 1696*e2997a03SKenneth D. Merry sc->fw_diag_buffer = NULL; 1697*e2997a03SKenneth D. Merry } 1698*e2997a03SKenneth D. Merry if (sc->fw_diag_dmat != NULL) { 1699991554f2SKenneth D. Merry bus_dma_tag_destroy(sc->fw_diag_dmat); 1700*e2997a03SKenneth D. Merry sc->fw_diag_dmat = NULL; 1701*e2997a03SKenneth D. Merry } 1702991554f2SKenneth D. Merry } 1703991554f2SKenneth D. Merry 1704991554f2SKenneth D. Merry return (status); 1705991554f2SKenneth D. Merry } 1706991554f2SKenneth D. Merry 1707991554f2SKenneth D. Merry static int 1708991554f2SKenneth D. Merry mpr_diag_query(struct mpr_softc *sc, mpr_fw_diag_query_t *diag_query, 1709991554f2SKenneth D. Merry uint32_t *return_code) 1710991554f2SKenneth D. Merry { 1711991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer; 1712991554f2SKenneth D. Merry uint8_t i; 1713991554f2SKenneth D. Merry uint32_t unique_id; 1714991554f2SKenneth D. Merry 1715991554f2SKenneth D. Merry unique_id = diag_query->UniqueId; 1716991554f2SKenneth D. Merry 1717991554f2SKenneth D. Merry /* 1718991554f2SKenneth D. Merry * If ID is valid, query on ID. 1719991554f2SKenneth D. Merry * If ID is invalid, query on buffer type. 1720991554f2SKenneth D. Merry */ 1721991554f2SKenneth D. Merry if (unique_id == MPR_FW_DIAG_INVALID_UID) { 1722991554f2SKenneth D. Merry i = diag_query->BufferType; 1723991554f2SKenneth D. Merry if (i >= MPI2_DIAG_BUF_TYPE_COUNT) { 1724991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_UID; 1725991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1726991554f2SKenneth D. Merry } 1727991554f2SKenneth D. Merry } else { 1728991554f2SKenneth D. Merry i = mpr_get_fw_diag_buffer_number(sc, unique_id); 1729991554f2SKenneth D. Merry if (i == MPR_FW_DIAGNOSTIC_UID_NOT_FOUND) { 1730991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_UID; 1731991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1732991554f2SKenneth D. Merry } 1733991554f2SKenneth D. Merry } 1734991554f2SKenneth D. Merry 1735991554f2SKenneth D. Merry /* 1736991554f2SKenneth D. Merry * Fill query structure with the diag buffer info. 1737991554f2SKenneth D. Merry */ 1738991554f2SKenneth D. Merry pBuffer = &sc->fw_diag_buffer_list[i]; 1739991554f2SKenneth D. Merry diag_query->BufferType = pBuffer->buffer_type; 1740991554f2SKenneth D. Merry diag_query->ExtendedType = pBuffer->extended_type; 1741991554f2SKenneth D. Merry if (diag_query->BufferType == MPI2_DIAG_BUF_TYPE_TRACE) { 1742991554f2SKenneth D. Merry for (i = 0; i < (sizeof(diag_query->ProductSpecific) / 4); 1743991554f2SKenneth D. Merry i++) { 1744991554f2SKenneth D. Merry diag_query->ProductSpecific[i] = 1745991554f2SKenneth D. Merry pBuffer->product_specific[i]; 1746991554f2SKenneth D. Merry } 1747991554f2SKenneth D. Merry } 1748991554f2SKenneth D. Merry diag_query->TotalBufferSize = pBuffer->size; 1749991554f2SKenneth D. Merry diag_query->DriverAddedBufferSize = 0; 1750991554f2SKenneth D. Merry diag_query->UniqueId = pBuffer->unique_id; 1751991554f2SKenneth D. Merry diag_query->ApplicationFlags = 0; 1752991554f2SKenneth D. Merry diag_query->DiagnosticFlags = 0; 1753991554f2SKenneth D. Merry 1754991554f2SKenneth D. Merry /* 1755991554f2SKenneth D. Merry * Set/Clear application flags 1756991554f2SKenneth D. Merry */ 1757991554f2SKenneth D. Merry if (pBuffer->immediate) { 1758991554f2SKenneth D. Merry diag_query->ApplicationFlags &= ~MPR_FW_DIAG_FLAG_APP_OWNED; 1759991554f2SKenneth D. Merry } else { 1760991554f2SKenneth D. Merry diag_query->ApplicationFlags |= MPR_FW_DIAG_FLAG_APP_OWNED; 1761991554f2SKenneth D. Merry } 1762991554f2SKenneth D. Merry if (pBuffer->valid_data || pBuffer->owned_by_firmware) { 1763991554f2SKenneth D. Merry diag_query->ApplicationFlags |= MPR_FW_DIAG_FLAG_BUFFER_VALID; 1764991554f2SKenneth D. Merry } else { 1765991554f2SKenneth D. Merry diag_query->ApplicationFlags &= ~MPR_FW_DIAG_FLAG_BUFFER_VALID; 1766991554f2SKenneth D. Merry } 1767991554f2SKenneth D. Merry if (pBuffer->owned_by_firmware) { 1768991554f2SKenneth D. Merry diag_query->ApplicationFlags |= 1769991554f2SKenneth D. Merry MPR_FW_DIAG_FLAG_FW_BUFFER_ACCESS; 1770991554f2SKenneth D. Merry } else { 1771991554f2SKenneth D. Merry diag_query->ApplicationFlags &= 1772991554f2SKenneth D. Merry ~MPR_FW_DIAG_FLAG_FW_BUFFER_ACCESS; 1773991554f2SKenneth D. Merry } 1774991554f2SKenneth D. Merry 1775991554f2SKenneth D. Merry return (MPR_DIAG_SUCCESS); 1776991554f2SKenneth D. Merry } 1777991554f2SKenneth D. Merry 1778991554f2SKenneth D. Merry static int 1779991554f2SKenneth D. Merry mpr_diag_read_buffer(struct mpr_softc *sc, 1780991554f2SKenneth D. Merry mpr_diag_read_buffer_t *diag_read_buffer, uint8_t *ioctl_buf, 1781991554f2SKenneth D. Merry uint32_t *return_code) 1782991554f2SKenneth D. Merry { 1783991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer; 1784991554f2SKenneth D. Merry uint8_t i, *pData; 1785991554f2SKenneth D. Merry uint32_t unique_id; 1786991554f2SKenneth D. Merry int status; 1787991554f2SKenneth D. Merry 1788991554f2SKenneth D. Merry unique_id = diag_read_buffer->UniqueId; 1789991554f2SKenneth D. Merry 1790991554f2SKenneth D. Merry /* 1791991554f2SKenneth D. Merry * Get the current buffer and look up the unique ID. The unique ID 1792991554f2SKenneth D. Merry * should be there. 1793991554f2SKenneth D. Merry */ 1794991554f2SKenneth D. Merry i = mpr_get_fw_diag_buffer_number(sc, unique_id); 1795991554f2SKenneth D. Merry if (i == MPR_FW_DIAGNOSTIC_UID_NOT_FOUND) { 1796991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_UID; 1797991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1798991554f2SKenneth D. Merry } 1799991554f2SKenneth D. Merry 1800991554f2SKenneth D. Merry pBuffer = &sc->fw_diag_buffer_list[i]; 1801991554f2SKenneth D. Merry 1802991554f2SKenneth D. Merry /* 1803991554f2SKenneth D. Merry * Make sure requested read is within limits 1804991554f2SKenneth D. Merry */ 1805991554f2SKenneth D. Merry if (diag_read_buffer->StartingOffset + diag_read_buffer->BytesToRead > 1806991554f2SKenneth D. Merry pBuffer->size) { 1807991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1808991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1809991554f2SKenneth D. Merry } 1810991554f2SKenneth D. Merry 1811*e2997a03SKenneth D. Merry /* Sync the DMA map before we copy to userland. */ 1812*e2997a03SKenneth D. Merry bus_dmamap_sync(sc->fw_diag_dmat, sc->fw_diag_map, 1813*e2997a03SKenneth D. Merry BUS_DMASYNC_POSTREAD); 1814*e2997a03SKenneth D. Merry 1815991554f2SKenneth D. Merry /* 1816991554f2SKenneth D. Merry * Copy the requested data from DMA to the diag_read_buffer. The DMA 1817991554f2SKenneth D. Merry * buffer that was allocated is one contiguous buffer. 1818991554f2SKenneth D. Merry */ 1819991554f2SKenneth D. Merry pData = (uint8_t *)(sc->fw_diag_buffer + 1820991554f2SKenneth D. Merry diag_read_buffer->StartingOffset); 1821991554f2SKenneth D. Merry if (copyout(pData, ioctl_buf, diag_read_buffer->BytesToRead) != 0) 1822991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1823991554f2SKenneth D. Merry diag_read_buffer->Status = 0; 1824991554f2SKenneth D. Merry 1825991554f2SKenneth D. Merry /* 1826991554f2SKenneth D. Merry * Set or clear the Force Release flag. 1827991554f2SKenneth D. Merry */ 1828991554f2SKenneth D. Merry if (pBuffer->force_release) { 1829991554f2SKenneth D. Merry diag_read_buffer->Flags |= MPR_FW_DIAG_FLAG_FORCE_RELEASE; 1830991554f2SKenneth D. Merry } else { 1831991554f2SKenneth D. Merry diag_read_buffer->Flags &= ~MPR_FW_DIAG_FLAG_FORCE_RELEASE; 1832991554f2SKenneth D. Merry } 1833991554f2SKenneth D. Merry 1834991554f2SKenneth D. Merry /* 1835991554f2SKenneth D. Merry * If buffer is to be reregistered, make sure it's not already owned by 1836991554f2SKenneth D. Merry * firmware first. 1837991554f2SKenneth D. Merry */ 1838991554f2SKenneth D. Merry status = MPR_DIAG_SUCCESS; 1839991554f2SKenneth D. Merry if (!pBuffer->owned_by_firmware) { 1840991554f2SKenneth D. Merry if (diag_read_buffer->Flags & MPR_FW_DIAG_FLAG_REREGISTER) { 1841991554f2SKenneth D. Merry status = mpr_post_fw_diag_buffer(sc, pBuffer, 1842991554f2SKenneth D. Merry return_code); 1843991554f2SKenneth D. Merry } 1844991554f2SKenneth D. Merry } 1845991554f2SKenneth D. Merry 1846991554f2SKenneth D. Merry return (status); 1847991554f2SKenneth D. Merry } 1848991554f2SKenneth D. Merry 1849991554f2SKenneth D. Merry static int 1850991554f2SKenneth D. Merry mpr_diag_release(struct mpr_softc *sc, mpr_fw_diag_release_t *diag_release, 1851991554f2SKenneth D. Merry uint32_t *return_code) 1852991554f2SKenneth D. Merry { 1853991554f2SKenneth D. Merry mpr_fw_diagnostic_buffer_t *pBuffer; 1854991554f2SKenneth D. Merry uint8_t i; 1855991554f2SKenneth D. Merry uint32_t unique_id; 1856991554f2SKenneth D. Merry int status; 1857991554f2SKenneth D. Merry 1858991554f2SKenneth D. Merry unique_id = diag_release->UniqueId; 1859991554f2SKenneth D. Merry 1860991554f2SKenneth D. Merry /* 1861991554f2SKenneth D. Merry * Get the current buffer and look up the unique ID. The unique ID 1862991554f2SKenneth D. Merry * should be there. 1863991554f2SKenneth D. Merry */ 1864991554f2SKenneth D. Merry i = mpr_get_fw_diag_buffer_number(sc, unique_id); 1865991554f2SKenneth D. Merry if (i == MPR_FW_DIAGNOSTIC_UID_NOT_FOUND) { 1866991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_UID; 1867991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1868991554f2SKenneth D. Merry } 1869991554f2SKenneth D. Merry 1870991554f2SKenneth D. Merry pBuffer = &sc->fw_diag_buffer_list[i]; 1871991554f2SKenneth D. Merry 1872991554f2SKenneth D. Merry /* 1873991554f2SKenneth D. Merry * If buffer is not owned by firmware, it's already been released. 1874991554f2SKenneth D. Merry */ 1875991554f2SKenneth D. Merry if (!pBuffer->owned_by_firmware) { 1876991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_ALREADY_RELEASED; 1877991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1878991554f2SKenneth D. Merry } 1879991554f2SKenneth D. Merry 1880991554f2SKenneth D. Merry /* 1881991554f2SKenneth D. Merry * Release the buffer. 1882991554f2SKenneth D. Merry */ 1883991554f2SKenneth D. Merry status = mpr_release_fw_diag_buffer(sc, pBuffer, return_code, 1884991554f2SKenneth D. Merry MPR_FW_DIAG_TYPE_RELEASE); 1885991554f2SKenneth D. Merry return (status); 1886991554f2SKenneth D. Merry } 1887991554f2SKenneth D. Merry 1888991554f2SKenneth D. Merry static int 18897a2a6a1aSStephen McConnell mpr_do_diag_action(struct mpr_softc *sc, uint32_t action, uint8_t *diag_action, 18907a2a6a1aSStephen McConnell uint32_t length, uint32_t *return_code) 1891991554f2SKenneth D. Merry { 1892991554f2SKenneth D. Merry mpr_fw_diag_register_t diag_register; 1893991554f2SKenneth D. Merry mpr_fw_diag_unregister_t diag_unregister; 1894991554f2SKenneth D. Merry mpr_fw_diag_query_t diag_query; 1895991554f2SKenneth D. Merry mpr_diag_read_buffer_t diag_read_buffer; 1896991554f2SKenneth D. Merry mpr_fw_diag_release_t diag_release; 1897991554f2SKenneth D. Merry int status = MPR_DIAG_SUCCESS; 1898991554f2SKenneth D. Merry uint32_t original_return_code; 1899991554f2SKenneth D. Merry 1900991554f2SKenneth D. Merry original_return_code = *return_code; 1901991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_SUCCESS; 1902991554f2SKenneth D. Merry 1903991554f2SKenneth D. Merry switch (action) { 1904991554f2SKenneth D. Merry case MPR_FW_DIAG_TYPE_REGISTER: 1905991554f2SKenneth D. Merry if (!length) { 1906991554f2SKenneth D. Merry *return_code = 1907991554f2SKenneth D. Merry MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1908991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1909991554f2SKenneth D. Merry break; 1910991554f2SKenneth D. Merry } 1911991554f2SKenneth D. Merry if (copyin(diag_action, &diag_register, 1912991554f2SKenneth D. Merry sizeof(diag_register)) != 0) 1913991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1914991554f2SKenneth D. Merry status = mpr_diag_register(sc, &diag_register, 1915991554f2SKenneth D. Merry return_code); 1916991554f2SKenneth D. Merry break; 1917991554f2SKenneth D. Merry 1918991554f2SKenneth D. Merry case MPR_FW_DIAG_TYPE_UNREGISTER: 1919991554f2SKenneth D. Merry if (length < sizeof(diag_unregister)) { 1920991554f2SKenneth D. Merry *return_code = 1921991554f2SKenneth D. Merry MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1922991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1923991554f2SKenneth D. Merry break; 1924991554f2SKenneth D. Merry } 1925991554f2SKenneth D. Merry if (copyin(diag_action, &diag_unregister, 1926991554f2SKenneth D. Merry sizeof(diag_unregister)) != 0) 1927991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1928991554f2SKenneth D. Merry status = mpr_diag_unregister(sc, &diag_unregister, 1929991554f2SKenneth D. Merry return_code); 1930991554f2SKenneth D. Merry break; 1931991554f2SKenneth D. Merry 1932991554f2SKenneth D. Merry case MPR_FW_DIAG_TYPE_QUERY: 1933991554f2SKenneth D. Merry if (length < sizeof (diag_query)) { 1934991554f2SKenneth D. Merry *return_code = 1935991554f2SKenneth D. Merry MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1936991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1937991554f2SKenneth D. Merry break; 1938991554f2SKenneth D. Merry } 1939991554f2SKenneth D. Merry if (copyin(diag_action, &diag_query, sizeof(diag_query)) 1940991554f2SKenneth D. Merry != 0) 1941991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1942991554f2SKenneth D. Merry status = mpr_diag_query(sc, &diag_query, return_code); 1943991554f2SKenneth D. Merry if (status == MPR_DIAG_SUCCESS) 1944991554f2SKenneth D. Merry if (copyout(&diag_query, diag_action, 1945991554f2SKenneth D. Merry sizeof (diag_query)) != 0) 1946991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1947991554f2SKenneth D. Merry break; 1948991554f2SKenneth D. Merry 1949991554f2SKenneth D. Merry case MPR_FW_DIAG_TYPE_READ_BUFFER: 1950991554f2SKenneth D. Merry if (copyin(diag_action, &diag_read_buffer, 1951991554f2SKenneth D. Merry sizeof(diag_read_buffer)) != 0) 1952991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1953991554f2SKenneth D. Merry if (length < diag_read_buffer.BytesToRead) { 1954991554f2SKenneth D. Merry *return_code = 1955991554f2SKenneth D. Merry MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1956991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1957991554f2SKenneth D. Merry break; 1958991554f2SKenneth D. Merry } 1959991554f2SKenneth D. Merry status = mpr_diag_read_buffer(sc, &diag_read_buffer, 1960991554f2SKenneth D. Merry PTRIN(diag_read_buffer.PtrDataBuffer), 1961991554f2SKenneth D. Merry return_code); 1962991554f2SKenneth D. Merry if (status == MPR_DIAG_SUCCESS) { 1963991554f2SKenneth D. Merry if (copyout(&diag_read_buffer, diag_action, 1964991554f2SKenneth D. Merry sizeof(diag_read_buffer) - 1965991554f2SKenneth D. Merry sizeof(diag_read_buffer.PtrDataBuffer)) != 1966991554f2SKenneth D. Merry 0) 1967991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1968991554f2SKenneth D. Merry } 1969991554f2SKenneth D. Merry break; 1970991554f2SKenneth D. Merry 1971991554f2SKenneth D. Merry case MPR_FW_DIAG_TYPE_RELEASE: 1972991554f2SKenneth D. Merry if (length < sizeof(diag_release)) { 1973991554f2SKenneth D. Merry *return_code = 1974991554f2SKenneth D. Merry MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1975991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1976991554f2SKenneth D. Merry break; 1977991554f2SKenneth D. Merry } 1978991554f2SKenneth D. Merry if (copyin(diag_action, &diag_release, 1979991554f2SKenneth D. Merry sizeof(diag_release)) != 0) 1980991554f2SKenneth D. Merry return (MPR_DIAG_FAILURE); 1981991554f2SKenneth D. Merry status = mpr_diag_release(sc, &diag_release, 1982991554f2SKenneth D. Merry return_code); 1983991554f2SKenneth D. Merry break; 1984991554f2SKenneth D. Merry 1985991554f2SKenneth D. Merry default: 1986991554f2SKenneth D. Merry *return_code = MPR_FW_DIAG_ERROR_INVALID_PARAMETER; 1987991554f2SKenneth D. Merry status = MPR_DIAG_FAILURE; 1988991554f2SKenneth D. Merry break; 1989991554f2SKenneth D. Merry } 1990991554f2SKenneth D. Merry 1991991554f2SKenneth D. Merry if ((status == MPR_DIAG_FAILURE) && 1992991554f2SKenneth D. Merry (original_return_code == MPR_FW_DIAG_NEW) && 1993991554f2SKenneth D. Merry (*return_code != MPR_FW_DIAG_ERROR_SUCCESS)) 1994991554f2SKenneth D. Merry status = MPR_DIAG_SUCCESS; 1995991554f2SKenneth D. Merry 1996991554f2SKenneth D. Merry return (status); 1997991554f2SKenneth D. Merry } 1998991554f2SKenneth D. Merry 1999991554f2SKenneth D. Merry static int 2000991554f2SKenneth D. Merry mpr_user_diag_action(struct mpr_softc *sc, mpr_diag_action_t *data) 2001991554f2SKenneth D. Merry { 2002991554f2SKenneth D. Merry int status; 2003991554f2SKenneth D. Merry 2004991554f2SKenneth D. Merry /* 2005991554f2SKenneth D. Merry * Only allow one diag action at one time. 2006991554f2SKenneth D. Merry */ 2007991554f2SKenneth D. Merry if (sc->mpr_flags & MPR_FLAGS_BUSY) { 2008991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "%s: Only one FW diag command " 2009991554f2SKenneth D. Merry "allowed at a single time.", __func__); 2010991554f2SKenneth D. Merry return (EBUSY); 2011991554f2SKenneth D. Merry } 2012991554f2SKenneth D. Merry sc->mpr_flags |= MPR_FLAGS_BUSY; 2013991554f2SKenneth D. Merry 2014991554f2SKenneth D. Merry /* 2015991554f2SKenneth D. Merry * Send diag action request 2016991554f2SKenneth D. Merry */ 2017991554f2SKenneth D. Merry if (data->Action == MPR_FW_DIAG_TYPE_REGISTER || 2018991554f2SKenneth D. Merry data->Action == MPR_FW_DIAG_TYPE_UNREGISTER || 2019991554f2SKenneth D. Merry data->Action == MPR_FW_DIAG_TYPE_QUERY || 2020991554f2SKenneth D. Merry data->Action == MPR_FW_DIAG_TYPE_READ_BUFFER || 2021991554f2SKenneth D. Merry data->Action == MPR_FW_DIAG_TYPE_RELEASE) { 2022991554f2SKenneth D. Merry status = mpr_do_diag_action(sc, data->Action, 2023991554f2SKenneth D. Merry PTRIN(data->PtrDiagAction), data->Length, 2024991554f2SKenneth D. Merry &data->ReturnCode); 2025991554f2SKenneth D. Merry } else 2026991554f2SKenneth D. Merry status = EINVAL; 2027991554f2SKenneth D. Merry 2028991554f2SKenneth D. Merry sc->mpr_flags &= ~MPR_FLAGS_BUSY; 2029991554f2SKenneth D. Merry return (status); 2030991554f2SKenneth D. Merry } 2031991554f2SKenneth D. Merry 2032991554f2SKenneth D. Merry /* 2033991554f2SKenneth D. Merry * Copy the event recording mask and the event queue size out. For 2034991554f2SKenneth D. Merry * clarification, the event recording mask (events_to_record) is not the same 2035991554f2SKenneth D. Merry * thing as the event mask (event_mask). events_to_record has a bit set for 2036991554f2SKenneth D. Merry * every event type that is to be recorded by the driver, and event_mask has a 2037991554f2SKenneth D. Merry * bit cleared for every event that is allowed into the driver from the IOC. 2038991554f2SKenneth D. Merry * They really have nothing to do with each other. 2039991554f2SKenneth D. Merry */ 2040991554f2SKenneth D. Merry static void 2041991554f2SKenneth D. Merry mpr_user_event_query(struct mpr_softc *sc, mpr_event_query_t *data) 2042991554f2SKenneth D. Merry { 2043991554f2SKenneth D. Merry uint8_t i; 2044991554f2SKenneth D. Merry 2045991554f2SKenneth D. Merry mpr_lock(sc); 2046991554f2SKenneth D. Merry data->Entries = MPR_EVENT_QUEUE_SIZE; 2047991554f2SKenneth D. Merry 2048991554f2SKenneth D. Merry for (i = 0; i < 4; i++) { 2049991554f2SKenneth D. Merry data->Types[i] = sc->events_to_record[i]; 2050991554f2SKenneth D. Merry } 2051991554f2SKenneth D. Merry mpr_unlock(sc); 2052991554f2SKenneth D. Merry } 2053991554f2SKenneth D. Merry 2054991554f2SKenneth D. Merry /* 2055991554f2SKenneth D. Merry * Set the driver's event mask according to what's been given. See 2056991554f2SKenneth D. Merry * mpr_user_event_query for explanation of the event recording mask and the IOC 2057991554f2SKenneth D. Merry * event mask. It's the app's responsibility to enable event logging by setting 2058991554f2SKenneth D. Merry * the bits in events_to_record. Initially, no events will be logged. 2059991554f2SKenneth D. Merry */ 2060991554f2SKenneth D. Merry static void 2061991554f2SKenneth D. Merry mpr_user_event_enable(struct mpr_softc *sc, mpr_event_enable_t *data) 2062991554f2SKenneth D. Merry { 2063991554f2SKenneth D. Merry uint8_t i; 2064991554f2SKenneth D. Merry 2065991554f2SKenneth D. Merry mpr_lock(sc); 2066991554f2SKenneth D. Merry for (i = 0; i < 4; i++) { 2067991554f2SKenneth D. Merry sc->events_to_record[i] = data->Types[i]; 2068991554f2SKenneth D. Merry } 2069991554f2SKenneth D. Merry mpr_unlock(sc); 2070991554f2SKenneth D. Merry } 2071991554f2SKenneth D. Merry 2072991554f2SKenneth D. Merry /* 2073991554f2SKenneth D. Merry * Copy out the events that have been recorded, up to the max events allowed. 2074991554f2SKenneth D. Merry */ 2075991554f2SKenneth D. Merry static int 2076991554f2SKenneth D. Merry mpr_user_event_report(struct mpr_softc *sc, mpr_event_report_t *data) 2077991554f2SKenneth D. Merry { 2078991554f2SKenneth D. Merry int status = 0; 2079991554f2SKenneth D. Merry uint32_t size; 2080991554f2SKenneth D. Merry 2081991554f2SKenneth D. Merry mpr_lock(sc); 2082991554f2SKenneth D. Merry size = data->Size; 2083991554f2SKenneth D. Merry if ((size >= sizeof(sc->recorded_events)) && (status == 0)) { 2084991554f2SKenneth D. Merry mpr_unlock(sc); 2085991554f2SKenneth D. Merry if (copyout((void *)sc->recorded_events, 2086991554f2SKenneth D. Merry PTRIN(data->PtrEvents), size) != 0) 2087991554f2SKenneth D. Merry status = EFAULT; 2088991554f2SKenneth D. Merry mpr_lock(sc); 2089991554f2SKenneth D. Merry } else { 2090991554f2SKenneth D. Merry /* 2091991554f2SKenneth D. Merry * data->Size value is not large enough to copy event data. 2092991554f2SKenneth D. Merry */ 2093991554f2SKenneth D. Merry status = EFAULT; 2094991554f2SKenneth D. Merry } 2095991554f2SKenneth D. Merry 2096991554f2SKenneth D. Merry /* 2097991554f2SKenneth D. Merry * Change size value to match the number of bytes that were copied. 2098991554f2SKenneth D. Merry */ 2099991554f2SKenneth D. Merry if (status == 0) 2100991554f2SKenneth D. Merry data->Size = sizeof(sc->recorded_events); 2101991554f2SKenneth D. Merry mpr_unlock(sc); 2102991554f2SKenneth D. Merry 2103991554f2SKenneth D. Merry return (status); 2104991554f2SKenneth D. Merry } 2105991554f2SKenneth D. Merry 2106991554f2SKenneth D. Merry /* 2107991554f2SKenneth D. Merry * Record events into the driver from the IOC if they are not masked. 2108991554f2SKenneth D. Merry */ 2109991554f2SKenneth D. Merry void 2110991554f2SKenneth D. Merry mprsas_record_event(struct mpr_softc *sc, 2111991554f2SKenneth D. Merry MPI2_EVENT_NOTIFICATION_REPLY *event_reply) 2112991554f2SKenneth D. Merry { 2113991554f2SKenneth D. Merry uint32_t event; 2114991554f2SKenneth D. Merry int i, j; 2115991554f2SKenneth D. Merry uint16_t event_data_len; 2116991554f2SKenneth D. Merry boolean_t sendAEN = FALSE; 2117991554f2SKenneth D. Merry 2118991554f2SKenneth D. Merry event = event_reply->Event; 2119991554f2SKenneth D. Merry 2120991554f2SKenneth D. Merry /* 2121991554f2SKenneth D. Merry * Generate a system event to let anyone who cares know that a 2122991554f2SKenneth D. Merry * LOG_ENTRY_ADDED event has occurred. This is sent no matter what the 2123991554f2SKenneth D. Merry * event mask is set to. 2124991554f2SKenneth D. Merry */ 2125991554f2SKenneth D. Merry if (event == MPI2_EVENT_LOG_ENTRY_ADDED) { 2126991554f2SKenneth D. Merry sendAEN = TRUE; 2127991554f2SKenneth D. Merry } 2128991554f2SKenneth D. Merry 2129991554f2SKenneth D. Merry /* 2130991554f2SKenneth D. Merry * Record the event only if its corresponding bit is set in 2131991554f2SKenneth D. Merry * events_to_record. event_index is the index into recorded_events and 2132991554f2SKenneth D. Merry * event_number is the overall number of an event being recorded since 2133991554f2SKenneth D. Merry * start-of-day. event_index will roll over; event_number will never 2134991554f2SKenneth D. Merry * roll over. 2135991554f2SKenneth D. Merry */ 2136991554f2SKenneth D. Merry i = (uint8_t)(event / 32); 2137991554f2SKenneth D. Merry j = (uint8_t)(event % 32); 2138991554f2SKenneth D. Merry if ((i < 4) && ((1 << j) & sc->events_to_record[i])) { 2139991554f2SKenneth D. Merry i = sc->event_index; 2140991554f2SKenneth D. Merry sc->recorded_events[i].Type = event; 2141991554f2SKenneth D. Merry sc->recorded_events[i].Number = ++sc->event_number; 2142991554f2SKenneth D. Merry bzero(sc->recorded_events[i].Data, MPR_MAX_EVENT_DATA_LENGTH * 2143991554f2SKenneth D. Merry 4); 2144991554f2SKenneth D. Merry event_data_len = event_reply->EventDataLength; 2145991554f2SKenneth D. Merry 2146991554f2SKenneth D. Merry if (event_data_len > 0) { 2147991554f2SKenneth D. Merry /* 2148991554f2SKenneth D. Merry * Limit data to size in m_event entry 2149991554f2SKenneth D. Merry */ 2150991554f2SKenneth D. Merry if (event_data_len > MPR_MAX_EVENT_DATA_LENGTH) { 2151991554f2SKenneth D. Merry event_data_len = MPR_MAX_EVENT_DATA_LENGTH; 2152991554f2SKenneth D. Merry } 2153991554f2SKenneth D. Merry for (j = 0; j < event_data_len; j++) { 2154991554f2SKenneth D. Merry sc->recorded_events[i].Data[j] = 2155991554f2SKenneth D. Merry event_reply->EventData[j]; 2156991554f2SKenneth D. Merry } 2157991554f2SKenneth D. Merry 2158991554f2SKenneth D. Merry /* 2159991554f2SKenneth D. Merry * check for index wrap-around 2160991554f2SKenneth D. Merry */ 2161991554f2SKenneth D. Merry if (++i == MPR_EVENT_QUEUE_SIZE) { 2162991554f2SKenneth D. Merry i = 0; 2163991554f2SKenneth D. Merry } 2164991554f2SKenneth D. Merry sc->event_index = (uint8_t)i; 2165991554f2SKenneth D. Merry 2166991554f2SKenneth D. Merry /* 2167991554f2SKenneth D. Merry * Set flag to send the event. 2168991554f2SKenneth D. Merry */ 2169991554f2SKenneth D. Merry sendAEN = TRUE; 2170991554f2SKenneth D. Merry } 2171991554f2SKenneth D. Merry } 2172991554f2SKenneth D. Merry 2173991554f2SKenneth D. Merry /* 2174991554f2SKenneth D. Merry * Generate a system event if flag is set to let anyone who cares know 2175991554f2SKenneth D. Merry * that an event has occurred. 2176991554f2SKenneth D. Merry */ 2177991554f2SKenneth D. Merry if (sendAEN) { 2178991554f2SKenneth D. Merry //SLM-how to send a system event (see kqueue, kevent) 2179991554f2SKenneth D. Merry // (void) ddi_log_sysevent(mpt->m_dip, DDI_VENDOR_LSI, "MPT_SAS", 2180991554f2SKenneth D. Merry // "SAS", NULL, NULL, DDI_NOSLEEP); 2181991554f2SKenneth D. Merry } 2182991554f2SKenneth D. Merry } 2183991554f2SKenneth D. Merry 2184991554f2SKenneth D. Merry static int 2185991554f2SKenneth D. Merry mpr_user_reg_access(struct mpr_softc *sc, mpr_reg_access_t *data) 2186991554f2SKenneth D. Merry { 2187991554f2SKenneth D. Merry int status = 0; 2188991554f2SKenneth D. Merry 2189991554f2SKenneth D. Merry switch (data->Command) { 2190991554f2SKenneth D. Merry /* 2191991554f2SKenneth D. Merry * IO access is not supported. 2192991554f2SKenneth D. Merry */ 2193991554f2SKenneth D. Merry case REG_IO_READ: 2194991554f2SKenneth D. Merry case REG_IO_WRITE: 2195991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "IO access is not supported. " 2196991554f2SKenneth D. Merry "Use memory access."); 2197991554f2SKenneth D. Merry status = EINVAL; 2198991554f2SKenneth D. Merry break; 2199991554f2SKenneth D. Merry 2200991554f2SKenneth D. Merry case REG_MEM_READ: 2201991554f2SKenneth D. Merry data->RegData = mpr_regread(sc, data->RegOffset); 2202991554f2SKenneth D. Merry break; 2203991554f2SKenneth D. Merry 2204991554f2SKenneth D. Merry case REG_MEM_WRITE: 2205991554f2SKenneth D. Merry mpr_regwrite(sc, data->RegOffset, data->RegData); 2206991554f2SKenneth D. Merry break; 2207991554f2SKenneth D. Merry 2208991554f2SKenneth D. Merry default: 2209991554f2SKenneth D. Merry status = EINVAL; 2210991554f2SKenneth D. Merry break; 2211991554f2SKenneth D. Merry } 2212991554f2SKenneth D. Merry 2213991554f2SKenneth D. Merry return (status); 2214991554f2SKenneth D. Merry } 2215991554f2SKenneth D. Merry 2216991554f2SKenneth D. Merry static int 2217991554f2SKenneth D. Merry mpr_user_btdh(struct mpr_softc *sc, mpr_btdh_mapping_t *data) 2218991554f2SKenneth D. Merry { 2219991554f2SKenneth D. Merry uint8_t bt2dh = FALSE; 2220991554f2SKenneth D. Merry uint8_t dh2bt = FALSE; 2221991554f2SKenneth D. Merry uint16_t dev_handle, bus, target; 2222991554f2SKenneth D. Merry 2223991554f2SKenneth D. Merry bus = data->Bus; 2224991554f2SKenneth D. Merry target = data->TargetID; 2225991554f2SKenneth D. Merry dev_handle = data->DevHandle; 2226991554f2SKenneth D. Merry 2227991554f2SKenneth D. Merry /* 2228991554f2SKenneth D. Merry * When DevHandle is 0xFFFF and Bus/Target are not 0xFFFF, use Bus/ 2229991554f2SKenneth D. Merry * Target to get DevHandle. When Bus/Target are 0xFFFF and DevHandle is 2230991554f2SKenneth D. Merry * not 0xFFFF, use DevHandle to get Bus/Target. Anything else is 2231991554f2SKenneth D. Merry * invalid. 2232991554f2SKenneth D. Merry */ 2233991554f2SKenneth D. Merry if ((bus == 0xFFFF) && (target == 0xFFFF) && (dev_handle != 0xFFFF)) 2234991554f2SKenneth D. Merry dh2bt = TRUE; 2235991554f2SKenneth D. Merry if ((dev_handle == 0xFFFF) && (bus != 0xFFFF) && (target != 0xFFFF)) 2236991554f2SKenneth D. Merry bt2dh = TRUE; 2237991554f2SKenneth D. Merry if (!dh2bt && !bt2dh) 2238991554f2SKenneth D. Merry return (EINVAL); 2239991554f2SKenneth D. Merry 2240991554f2SKenneth D. Merry /* 2241991554f2SKenneth D. Merry * Only handle bus of 0. Make sure target is within range. 2242991554f2SKenneth D. Merry */ 2243991554f2SKenneth D. Merry if (bt2dh) { 2244991554f2SKenneth D. Merry if (bus != 0) 2245991554f2SKenneth D. Merry return (EINVAL); 2246991554f2SKenneth D. Merry 2247991554f2SKenneth D. Merry if (target > sc->max_devices) { 224867feec50SStephen McConnell mpr_dprint(sc, MPR_XINFO, "Target ID is out of range " 2249991554f2SKenneth D. Merry "for Bus/Target to DevHandle mapping."); 2250991554f2SKenneth D. Merry return (EINVAL); 2251991554f2SKenneth D. Merry } 2252991554f2SKenneth D. Merry dev_handle = sc->mapping_table[target].dev_handle; 2253991554f2SKenneth D. Merry if (dev_handle) 2254991554f2SKenneth D. Merry data->DevHandle = dev_handle; 2255991554f2SKenneth D. Merry } else { 2256991554f2SKenneth D. Merry bus = 0; 2257327f2e6cSStephen McConnell target = mpr_mapping_get_tid_from_handle(sc, dev_handle); 2258991554f2SKenneth D. Merry data->Bus = bus; 2259991554f2SKenneth D. Merry data->TargetID = target; 2260991554f2SKenneth D. Merry } 2261991554f2SKenneth D. Merry 2262991554f2SKenneth D. Merry return (0); 2263991554f2SKenneth D. Merry } 2264991554f2SKenneth D. Merry 2265991554f2SKenneth D. Merry static int 2266991554f2SKenneth D. Merry mpr_ioctl(struct cdev *dev, u_long cmd, void *arg, int flag, 2267991554f2SKenneth D. Merry struct thread *td) 2268991554f2SKenneth D. Merry { 2269991554f2SKenneth D. Merry struct mpr_softc *sc; 2270991554f2SKenneth D. Merry struct mpr_cfg_page_req *page_req; 2271991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req *ext_page_req; 2272991554f2SKenneth D. Merry void *mpr_page; 2273991554f2SKenneth D. Merry int error, msleep_ret; 2274991554f2SKenneth D. Merry 2275991554f2SKenneth D. Merry mpr_page = NULL; 2276991554f2SKenneth D. Merry sc = dev->si_drv1; 2277991554f2SKenneth D. Merry page_req = (void *)arg; 2278991554f2SKenneth D. Merry ext_page_req = (void *)arg; 2279991554f2SKenneth D. Merry 2280991554f2SKenneth D. Merry switch (cmd) { 2281991554f2SKenneth D. Merry case MPRIO_READ_CFG_HEADER: 2282991554f2SKenneth D. Merry mpr_lock(sc); 2283991554f2SKenneth D. Merry error = mpr_user_read_cfg_header(sc, page_req); 2284991554f2SKenneth D. Merry mpr_unlock(sc); 2285991554f2SKenneth D. Merry break; 2286991554f2SKenneth D. Merry case MPRIO_READ_CFG_PAGE: 2287991554f2SKenneth D. Merry mpr_page = malloc(page_req->len, M_MPRUSER, M_WAITOK | M_ZERO); 2288991554f2SKenneth D. Merry error = copyin(page_req->buf, mpr_page, 2289991554f2SKenneth D. Merry sizeof(MPI2_CONFIG_PAGE_HEADER)); 2290991554f2SKenneth D. Merry if (error) 2291991554f2SKenneth D. Merry break; 2292991554f2SKenneth D. Merry mpr_lock(sc); 2293991554f2SKenneth D. Merry error = mpr_user_read_cfg_page(sc, page_req, mpr_page); 2294991554f2SKenneth D. Merry mpr_unlock(sc); 2295991554f2SKenneth D. Merry if (error) 2296991554f2SKenneth D. Merry break; 2297991554f2SKenneth D. Merry error = copyout(mpr_page, page_req->buf, page_req->len); 2298991554f2SKenneth D. Merry break; 2299991554f2SKenneth D. Merry case MPRIO_READ_EXT_CFG_HEADER: 2300991554f2SKenneth D. Merry mpr_lock(sc); 2301991554f2SKenneth D. Merry error = mpr_user_read_extcfg_header(sc, ext_page_req); 2302991554f2SKenneth D. Merry mpr_unlock(sc); 2303991554f2SKenneth D. Merry break; 2304991554f2SKenneth D. Merry case MPRIO_READ_EXT_CFG_PAGE: 2305991554f2SKenneth D. Merry mpr_page = malloc(ext_page_req->len, M_MPRUSER, 2306991554f2SKenneth D. Merry M_WAITOK | M_ZERO); 2307991554f2SKenneth D. Merry error = copyin(ext_page_req->buf, mpr_page, 2308991554f2SKenneth D. Merry sizeof(MPI2_CONFIG_EXTENDED_PAGE_HEADER)); 2309991554f2SKenneth D. Merry if (error) 2310991554f2SKenneth D. Merry break; 2311991554f2SKenneth D. Merry mpr_lock(sc); 2312991554f2SKenneth D. Merry error = mpr_user_read_extcfg_page(sc, ext_page_req, mpr_page); 2313991554f2SKenneth D. Merry mpr_unlock(sc); 2314991554f2SKenneth D. Merry if (error) 2315991554f2SKenneth D. Merry break; 2316991554f2SKenneth D. Merry error = copyout(mpr_page, ext_page_req->buf, ext_page_req->len); 2317991554f2SKenneth D. Merry break; 2318991554f2SKenneth D. Merry case MPRIO_WRITE_CFG_PAGE: 2319991554f2SKenneth D. Merry mpr_page = malloc(page_req->len, M_MPRUSER, M_WAITOK|M_ZERO); 2320991554f2SKenneth D. Merry error = copyin(page_req->buf, mpr_page, page_req->len); 2321991554f2SKenneth D. Merry if (error) 2322991554f2SKenneth D. Merry break; 2323991554f2SKenneth D. Merry mpr_lock(sc); 2324991554f2SKenneth D. Merry error = mpr_user_write_cfg_page(sc, page_req, mpr_page); 2325991554f2SKenneth D. Merry mpr_unlock(sc); 2326991554f2SKenneth D. Merry break; 2327991554f2SKenneth D. Merry case MPRIO_MPR_COMMAND: 2328991554f2SKenneth D. Merry error = mpr_user_command(sc, (struct mpr_usr_command *)arg); 2329991554f2SKenneth D. Merry break; 2330991554f2SKenneth D. Merry case MPTIOCTL_PASS_THRU: 2331991554f2SKenneth D. Merry /* 2332991554f2SKenneth D. Merry * The user has requested to pass through a command to be 2333991554f2SKenneth D. Merry * executed by the MPT firmware. Call our routine which does 2334991554f2SKenneth D. Merry * this. Only allow one passthru IOCTL at one time. 2335991554f2SKenneth D. Merry */ 2336991554f2SKenneth D. Merry error = mpr_user_pass_thru(sc, (mpr_pass_thru_t *)arg); 2337991554f2SKenneth D. Merry break; 2338991554f2SKenneth D. Merry case MPTIOCTL_GET_ADAPTER_DATA: 2339991554f2SKenneth D. Merry /* 2340991554f2SKenneth D. Merry * The user has requested to read adapter data. Call our 2341991554f2SKenneth D. Merry * routine which does this. 2342991554f2SKenneth D. Merry */ 2343991554f2SKenneth D. Merry error = 0; 2344991554f2SKenneth D. Merry mpr_user_get_adapter_data(sc, (mpr_adapter_data_t *)arg); 2345991554f2SKenneth D. Merry break; 2346991554f2SKenneth D. Merry case MPTIOCTL_GET_PCI_INFO: 2347991554f2SKenneth D. Merry /* 2348991554f2SKenneth D. Merry * The user has requested to read pci info. Call 2349991554f2SKenneth D. Merry * our routine which does this. 2350991554f2SKenneth D. Merry */ 2351991554f2SKenneth D. Merry mpr_lock(sc); 2352991554f2SKenneth D. Merry error = 0; 2353991554f2SKenneth D. Merry mpr_user_read_pci_info(sc, (mpr_pci_info_t *)arg); 2354991554f2SKenneth D. Merry mpr_unlock(sc); 2355991554f2SKenneth D. Merry break; 2356991554f2SKenneth D. Merry case MPTIOCTL_RESET_ADAPTER: 2357991554f2SKenneth D. Merry mpr_lock(sc); 2358991554f2SKenneth D. Merry sc->port_enable_complete = 0; 2359991554f2SKenneth D. Merry uint32_t reinit_start = time_uptime; 2360991554f2SKenneth D. Merry error = mpr_reinit(sc); 2361991554f2SKenneth D. Merry /* Sleep for 300 second. */ 2362991554f2SKenneth D. Merry msleep_ret = msleep(&sc->port_enable_complete, &sc->mpr_mtx, 2363991554f2SKenneth D. Merry PRIBIO, "mpr_porten", 300 * hz); 2364991554f2SKenneth D. Merry mpr_unlock(sc); 2365991554f2SKenneth D. Merry if (msleep_ret) 2366991554f2SKenneth D. Merry printf("Port Enable did not complete after Diag " 2367991554f2SKenneth D. Merry "Reset msleep error %d.\n", msleep_ret); 2368991554f2SKenneth D. Merry else 2369991554f2SKenneth D. Merry mpr_dprint(sc, MPR_USER, "Hard Reset with Port Enable " 2370991554f2SKenneth D. Merry "completed in %d seconds.\n", 2371991554f2SKenneth D. Merry (uint32_t)(time_uptime - reinit_start)); 2372991554f2SKenneth D. Merry break; 2373991554f2SKenneth D. Merry case MPTIOCTL_DIAG_ACTION: 2374991554f2SKenneth D. Merry /* 2375991554f2SKenneth D. Merry * The user has done a diag buffer action. Call our routine 2376991554f2SKenneth D. Merry * which does this. Only allow one diag action at one time. 2377991554f2SKenneth D. Merry */ 2378991554f2SKenneth D. Merry mpr_lock(sc); 2379991554f2SKenneth D. Merry error = mpr_user_diag_action(sc, (mpr_diag_action_t *)arg); 2380991554f2SKenneth D. Merry mpr_unlock(sc); 2381991554f2SKenneth D. Merry break; 2382991554f2SKenneth D. Merry case MPTIOCTL_EVENT_QUERY: 2383991554f2SKenneth D. Merry /* 2384991554f2SKenneth D. Merry * The user has done an event query. Call our routine which does 2385991554f2SKenneth D. Merry * this. 2386991554f2SKenneth D. Merry */ 2387991554f2SKenneth D. Merry error = 0; 2388991554f2SKenneth D. Merry mpr_user_event_query(sc, (mpr_event_query_t *)arg); 2389991554f2SKenneth D. Merry break; 2390991554f2SKenneth D. Merry case MPTIOCTL_EVENT_ENABLE: 2391991554f2SKenneth D. Merry /* 2392991554f2SKenneth D. Merry * The user has done an event enable. Call our routine which 2393991554f2SKenneth D. Merry * does this. 2394991554f2SKenneth D. Merry */ 2395991554f2SKenneth D. Merry error = 0; 2396991554f2SKenneth D. Merry mpr_user_event_enable(sc, (mpr_event_enable_t *)arg); 2397991554f2SKenneth D. Merry break; 2398991554f2SKenneth D. Merry case MPTIOCTL_EVENT_REPORT: 2399991554f2SKenneth D. Merry /* 2400991554f2SKenneth D. Merry * The user has done an event report. Call our routine which 2401991554f2SKenneth D. Merry * does this. 2402991554f2SKenneth D. Merry */ 2403991554f2SKenneth D. Merry error = mpr_user_event_report(sc, (mpr_event_report_t *)arg); 2404991554f2SKenneth D. Merry break; 2405991554f2SKenneth D. Merry case MPTIOCTL_REG_ACCESS: 2406991554f2SKenneth D. Merry /* 2407991554f2SKenneth D. Merry * The user has requested register access. Call our routine 2408991554f2SKenneth D. Merry * which does this. 2409991554f2SKenneth D. Merry */ 2410991554f2SKenneth D. Merry mpr_lock(sc); 2411991554f2SKenneth D. Merry error = mpr_user_reg_access(sc, (mpr_reg_access_t *)arg); 2412991554f2SKenneth D. Merry mpr_unlock(sc); 2413991554f2SKenneth D. Merry break; 2414991554f2SKenneth D. Merry case MPTIOCTL_BTDH_MAPPING: 2415991554f2SKenneth D. Merry /* 2416991554f2SKenneth D. Merry * The user has requested to translate a bus/target to a 2417991554f2SKenneth D. Merry * DevHandle or a DevHandle to a bus/target. Call our routine 2418991554f2SKenneth D. Merry * which does this. 2419991554f2SKenneth D. Merry */ 2420991554f2SKenneth D. Merry error = mpr_user_btdh(sc, (mpr_btdh_mapping_t *)arg); 2421991554f2SKenneth D. Merry break; 2422991554f2SKenneth D. Merry default: 2423991554f2SKenneth D. Merry error = ENOIOCTL; 2424991554f2SKenneth D. Merry break; 2425991554f2SKenneth D. Merry } 2426991554f2SKenneth D. Merry 2427991554f2SKenneth D. Merry if (mpr_page != NULL) 2428991554f2SKenneth D. Merry free(mpr_page, M_MPRUSER); 2429991554f2SKenneth D. Merry 2430991554f2SKenneth D. Merry return (error); 2431991554f2SKenneth D. Merry } 2432991554f2SKenneth D. Merry 2433991554f2SKenneth D. Merry #ifdef COMPAT_FREEBSD32 2434991554f2SKenneth D. Merry 2435991554f2SKenneth D. Merry struct mpr_cfg_page_req32 { 2436991554f2SKenneth D. Merry MPI2_CONFIG_PAGE_HEADER header; 2437991554f2SKenneth D. Merry uint32_t page_address; 2438991554f2SKenneth D. Merry uint32_t buf; 2439991554f2SKenneth D. Merry int len; 2440991554f2SKenneth D. Merry uint16_t ioc_status; 2441991554f2SKenneth D. Merry }; 2442991554f2SKenneth D. Merry 2443991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req32 { 2444991554f2SKenneth D. Merry MPI2_CONFIG_EXTENDED_PAGE_HEADER header; 2445991554f2SKenneth D. Merry uint32_t page_address; 2446991554f2SKenneth D. Merry uint32_t buf; 2447991554f2SKenneth D. Merry int len; 2448991554f2SKenneth D. Merry uint16_t ioc_status; 2449991554f2SKenneth D. Merry }; 2450991554f2SKenneth D. Merry 2451991554f2SKenneth D. Merry struct mpr_raid_action32 { 2452991554f2SKenneth D. Merry uint8_t action; 2453991554f2SKenneth D. Merry uint8_t volume_bus; 2454991554f2SKenneth D. Merry uint8_t volume_id; 2455991554f2SKenneth D. Merry uint8_t phys_disk_num; 2456991554f2SKenneth D. Merry uint32_t action_data_word; 2457991554f2SKenneth D. Merry uint32_t buf; 2458991554f2SKenneth D. Merry int len; 2459991554f2SKenneth D. Merry uint32_t volume_status; 2460991554f2SKenneth D. Merry uint32_t action_data[4]; 2461991554f2SKenneth D. Merry uint16_t action_status; 2462991554f2SKenneth D. Merry uint16_t ioc_status; 2463991554f2SKenneth D. Merry uint8_t write; 2464991554f2SKenneth D. Merry }; 2465991554f2SKenneth D. Merry 2466991554f2SKenneth D. Merry struct mpr_usr_command32 { 2467991554f2SKenneth D. Merry uint32_t req; 2468991554f2SKenneth D. Merry uint32_t req_len; 2469991554f2SKenneth D. Merry uint32_t rpl; 2470991554f2SKenneth D. Merry uint32_t rpl_len; 2471991554f2SKenneth D. Merry uint32_t buf; 2472991554f2SKenneth D. Merry int len; 2473991554f2SKenneth D. Merry uint32_t flags; 2474991554f2SKenneth D. Merry }; 2475991554f2SKenneth D. Merry 2476991554f2SKenneth D. Merry #define MPRIO_READ_CFG_HEADER32 _IOWR('M', 200, struct mpr_cfg_page_req32) 2477991554f2SKenneth D. Merry #define MPRIO_READ_CFG_PAGE32 _IOWR('M', 201, struct mpr_cfg_page_req32) 2478991554f2SKenneth D. Merry #define MPRIO_READ_EXT_CFG_HEADER32 _IOWR('M', 202, struct mpr_ext_cfg_page_req32) 2479991554f2SKenneth D. Merry #define MPRIO_READ_EXT_CFG_PAGE32 _IOWR('M', 203, struct mpr_ext_cfg_page_req32) 2480991554f2SKenneth D. Merry #define MPRIO_WRITE_CFG_PAGE32 _IOWR('M', 204, struct mpr_cfg_page_req32) 2481991554f2SKenneth D. Merry #define MPRIO_RAID_ACTION32 _IOWR('M', 205, struct mpr_raid_action32) 2482991554f2SKenneth D. Merry #define MPRIO_MPR_COMMAND32 _IOWR('M', 210, struct mpr_usr_command32) 2483991554f2SKenneth D. Merry 2484991554f2SKenneth D. Merry static int 2485991554f2SKenneth D. Merry mpr_ioctl32(struct cdev *dev, u_long cmd32, void *_arg, int flag, 2486991554f2SKenneth D. Merry struct thread *td) 2487991554f2SKenneth D. Merry { 2488991554f2SKenneth D. Merry struct mpr_cfg_page_req32 *page32 = _arg; 2489991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req32 *ext32 = _arg; 2490991554f2SKenneth D. Merry struct mpr_raid_action32 *raid32 = _arg; 2491991554f2SKenneth D. Merry struct mpr_usr_command32 *user32 = _arg; 2492991554f2SKenneth D. Merry union { 2493991554f2SKenneth D. Merry struct mpr_cfg_page_req page; 2494991554f2SKenneth D. Merry struct mpr_ext_cfg_page_req ext; 2495991554f2SKenneth D. Merry struct mpr_raid_action raid; 2496991554f2SKenneth D. Merry struct mpr_usr_command user; 2497991554f2SKenneth D. Merry } arg; 2498991554f2SKenneth D. Merry u_long cmd; 2499991554f2SKenneth D. Merry int error; 2500991554f2SKenneth D. Merry 2501991554f2SKenneth D. Merry switch (cmd32) { 2502991554f2SKenneth D. Merry case MPRIO_READ_CFG_HEADER32: 2503991554f2SKenneth D. Merry case MPRIO_READ_CFG_PAGE32: 2504991554f2SKenneth D. Merry case MPRIO_WRITE_CFG_PAGE32: 2505991554f2SKenneth D. Merry if (cmd32 == MPRIO_READ_CFG_HEADER32) 2506991554f2SKenneth D. Merry cmd = MPRIO_READ_CFG_HEADER; 2507991554f2SKenneth D. Merry else if (cmd32 == MPRIO_READ_CFG_PAGE32) 2508991554f2SKenneth D. Merry cmd = MPRIO_READ_CFG_PAGE; 2509991554f2SKenneth D. Merry else 2510991554f2SKenneth D. Merry cmd = MPRIO_WRITE_CFG_PAGE; 2511991554f2SKenneth D. Merry CP(*page32, arg.page, header); 2512991554f2SKenneth D. Merry CP(*page32, arg.page, page_address); 2513991554f2SKenneth D. Merry PTRIN_CP(*page32, arg.page, buf); 2514991554f2SKenneth D. Merry CP(*page32, arg.page, len); 2515991554f2SKenneth D. Merry CP(*page32, arg.page, ioc_status); 2516991554f2SKenneth D. Merry break; 2517991554f2SKenneth D. Merry 2518991554f2SKenneth D. Merry case MPRIO_READ_EXT_CFG_HEADER32: 2519991554f2SKenneth D. Merry case MPRIO_READ_EXT_CFG_PAGE32: 2520991554f2SKenneth D. Merry if (cmd32 == MPRIO_READ_EXT_CFG_HEADER32) 2521991554f2SKenneth D. Merry cmd = MPRIO_READ_EXT_CFG_HEADER; 2522991554f2SKenneth D. Merry else 2523991554f2SKenneth D. Merry cmd = MPRIO_READ_EXT_CFG_PAGE; 2524991554f2SKenneth D. Merry CP(*ext32, arg.ext, header); 2525991554f2SKenneth D. Merry CP(*ext32, arg.ext, page_address); 2526991554f2SKenneth D. Merry PTRIN_CP(*ext32, arg.ext, buf); 2527991554f2SKenneth D. Merry CP(*ext32, arg.ext, len); 2528991554f2SKenneth D. Merry CP(*ext32, arg.ext, ioc_status); 2529991554f2SKenneth D. Merry break; 2530991554f2SKenneth D. Merry 2531991554f2SKenneth D. Merry case MPRIO_RAID_ACTION32: 2532991554f2SKenneth D. Merry cmd = MPRIO_RAID_ACTION; 2533991554f2SKenneth D. Merry CP(*raid32, arg.raid, action); 2534991554f2SKenneth D. Merry CP(*raid32, arg.raid, volume_bus); 2535991554f2SKenneth D. Merry CP(*raid32, arg.raid, volume_id); 2536991554f2SKenneth D. Merry CP(*raid32, arg.raid, phys_disk_num); 2537991554f2SKenneth D. Merry CP(*raid32, arg.raid, action_data_word); 2538991554f2SKenneth D. Merry PTRIN_CP(*raid32, arg.raid, buf); 2539991554f2SKenneth D. Merry CP(*raid32, arg.raid, len); 2540991554f2SKenneth D. Merry CP(*raid32, arg.raid, volume_status); 2541991554f2SKenneth D. Merry bcopy(raid32->action_data, arg.raid.action_data, 2542991554f2SKenneth D. Merry sizeof arg.raid.action_data); 2543991554f2SKenneth D. Merry CP(*raid32, arg.raid, ioc_status); 2544991554f2SKenneth D. Merry CP(*raid32, arg.raid, write); 2545991554f2SKenneth D. Merry break; 2546991554f2SKenneth D. Merry 2547991554f2SKenneth D. Merry case MPRIO_MPR_COMMAND32: 2548991554f2SKenneth D. Merry cmd = MPRIO_MPR_COMMAND; 2549991554f2SKenneth D. Merry PTRIN_CP(*user32, arg.user, req); 2550991554f2SKenneth D. Merry CP(*user32, arg.user, req_len); 2551991554f2SKenneth D. Merry PTRIN_CP(*user32, arg.user, rpl); 2552991554f2SKenneth D. Merry CP(*user32, arg.user, rpl_len); 2553991554f2SKenneth D. Merry PTRIN_CP(*user32, arg.user, buf); 2554991554f2SKenneth D. Merry CP(*user32, arg.user, len); 2555991554f2SKenneth D. Merry CP(*user32, arg.user, flags); 2556991554f2SKenneth D. Merry break; 2557991554f2SKenneth D. Merry default: 2558991554f2SKenneth D. Merry return (ENOIOCTL); 2559991554f2SKenneth D. Merry } 2560991554f2SKenneth D. Merry 2561991554f2SKenneth D. Merry error = mpr_ioctl(dev, cmd, &arg, flag, td); 2562991554f2SKenneth D. Merry if (error == 0 && (cmd32 & IOC_OUT) != 0) { 2563991554f2SKenneth D. Merry switch (cmd32) { 2564991554f2SKenneth D. Merry case MPRIO_READ_CFG_HEADER32: 2565991554f2SKenneth D. Merry case MPRIO_READ_CFG_PAGE32: 2566991554f2SKenneth D. Merry case MPRIO_WRITE_CFG_PAGE32: 2567991554f2SKenneth D. Merry CP(arg.page, *page32, header); 2568991554f2SKenneth D. Merry CP(arg.page, *page32, page_address); 2569991554f2SKenneth D. Merry PTROUT_CP(arg.page, *page32, buf); 2570991554f2SKenneth D. Merry CP(arg.page, *page32, len); 2571991554f2SKenneth D. Merry CP(arg.page, *page32, ioc_status); 2572991554f2SKenneth D. Merry break; 2573991554f2SKenneth D. Merry 2574991554f2SKenneth D. Merry case MPRIO_READ_EXT_CFG_HEADER32: 2575991554f2SKenneth D. Merry case MPRIO_READ_EXT_CFG_PAGE32: 2576991554f2SKenneth D. Merry CP(arg.ext, *ext32, header); 2577991554f2SKenneth D. Merry CP(arg.ext, *ext32, page_address); 2578991554f2SKenneth D. Merry PTROUT_CP(arg.ext, *ext32, buf); 2579991554f2SKenneth D. Merry CP(arg.ext, *ext32, len); 2580991554f2SKenneth D. Merry CP(arg.ext, *ext32, ioc_status); 2581991554f2SKenneth D. Merry break; 2582991554f2SKenneth D. Merry 2583991554f2SKenneth D. Merry case MPRIO_RAID_ACTION32: 2584991554f2SKenneth D. Merry CP(arg.raid, *raid32, action); 2585991554f2SKenneth D. Merry CP(arg.raid, *raid32, volume_bus); 2586991554f2SKenneth D. Merry CP(arg.raid, *raid32, volume_id); 2587991554f2SKenneth D. Merry CP(arg.raid, *raid32, phys_disk_num); 2588991554f2SKenneth D. Merry CP(arg.raid, *raid32, action_data_word); 2589991554f2SKenneth D. Merry PTROUT_CP(arg.raid, *raid32, buf); 2590991554f2SKenneth D. Merry CP(arg.raid, *raid32, len); 2591991554f2SKenneth D. Merry CP(arg.raid, *raid32, volume_status); 2592991554f2SKenneth D. Merry bcopy(arg.raid.action_data, raid32->action_data, 2593991554f2SKenneth D. Merry sizeof arg.raid.action_data); 2594991554f2SKenneth D. Merry CP(arg.raid, *raid32, ioc_status); 2595991554f2SKenneth D. Merry CP(arg.raid, *raid32, write); 2596991554f2SKenneth D. Merry break; 2597991554f2SKenneth D. Merry 2598991554f2SKenneth D. Merry case MPRIO_MPR_COMMAND32: 2599991554f2SKenneth D. Merry PTROUT_CP(arg.user, *user32, req); 2600991554f2SKenneth D. Merry CP(arg.user, *user32, req_len); 2601991554f2SKenneth D. Merry PTROUT_CP(arg.user, *user32, rpl); 2602991554f2SKenneth D. Merry CP(arg.user, *user32, rpl_len); 2603991554f2SKenneth D. Merry PTROUT_CP(arg.user, *user32, buf); 2604991554f2SKenneth D. Merry CP(arg.user, *user32, len); 2605991554f2SKenneth D. Merry CP(arg.user, *user32, flags); 2606991554f2SKenneth D. Merry break; 2607991554f2SKenneth D. Merry } 2608991554f2SKenneth D. Merry } 2609991554f2SKenneth D. Merry 2610991554f2SKenneth D. Merry return (error); 2611991554f2SKenneth D. Merry } 2612991554f2SKenneth D. Merry #endif /* COMPAT_FREEBSD32 */ 2613991554f2SKenneth D. Merry 2614991554f2SKenneth D. Merry static int 2615991554f2SKenneth D. Merry mpr_ioctl_devsw(struct cdev *dev, u_long com, caddr_t arg, int flag, 2616991554f2SKenneth D. Merry struct thread *td) 2617991554f2SKenneth D. Merry { 2618991554f2SKenneth D. Merry #ifdef COMPAT_FREEBSD32 2619991554f2SKenneth D. Merry if (SV_CURPROC_FLAG(SV_ILP32)) 2620991554f2SKenneth D. Merry return (mpr_ioctl32(dev, com, arg, flag, td)); 2621991554f2SKenneth D. Merry #endif 2622991554f2SKenneth D. Merry return (mpr_ioctl(dev, com, arg, flag, td)); 2623991554f2SKenneth D. Merry } 2624