xref: /illumos-gate/usr/src/uts/common/io/ib/adapters/hermon/hermon_ioctl.c (revision 8b8be354)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * hermon_ioctl.c
 *    Hemron IOCTL Routines
 *
 *    Implements all ioctl access into the driver.  This includes all routines
 *    necessary for updating firmware, accessing the hermon flash device, and
 *    providing interfaces for VTS.
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/file.h>

#include <sys/ib/adapters/hermon/hermon.h>

/* Hemron HCA state pointer (extern) */
extern void	*hermon_statep;
extern int	hermon_verbose;

#define	DO_WRCONF	1
static int do_bar0 = 1;

/*
 * The ioctl declarations (for firmware flash burning, register read/write
 * (DEBUG-only), and VTS interfaces)
 */
static int hermon_ioctl_flash_read(hermon_state_t *state, dev_t dev,
    intptr_t arg, int mode);
static int hermon_ioctl_flash_write(hermon_state_t *state, dev_t dev,
    intptr_t arg, int mode);
static int hermon_ioctl_flash_erase(hermon_state_t *state, dev_t dev,
    intptr_t arg, int mode);
static int hermon_ioctl_flash_init(hermon_state_t *state, dev_t dev,
    intptr_t arg, int mode);
static int hermon_ioctl_flash_fini(hermon_state_t *state, dev_t dev);
static int hermon_ioctl_flash_cleanup(hermon_state_t *state);
static int hermon_ioctl_flash_cleanup_nolock(hermon_state_t *state);
#ifdef	DEBUG
static int hermon_ioctl_reg_write(hermon_state_t *state, intptr_t arg,
    int mode);
static int hermon_ioctl_reg_read(hermon_state_t *state, intptr_t arg,
    int mode);
#endif	/* DEBUG */
static int hermon_ioctl_write_boot_addr(hermon_state_t *state, dev_t dev,
    intptr_t arg, int mode);
static int hermon_ioctl_info(hermon_state_t *state, dev_t dev,
    intptr_t arg, int mode);
static int hermon_ioctl_ports(hermon_state_t *state, intptr_t arg,
    int mode);
static int hermon_ioctl_loopback(hermon_state_t *state, intptr_t arg,
    int mode);

/* Hemron Flash Functions */
static void hermon_flash_spi_exec_command(hermon_state_t *state,
    ddi_acc_handle_t hdl, uint32_t cmd);
static int hermon_flash_read_sector(hermon_state_t *state,
    uint32_t sector_num);
static int hermon_flash_read_quadlet(hermon_state_t *state, uint32_t *data,
    uint32_t addr);
static int hermon_flash_write_sector(hermon_state_t *state,
    uint32_t sector_num);
static int hermon_flash_spi_write_dword(hermon_state_t *state,
    uint32_t addr, uint32_t data);
static int hermon_flash_write_byte(hermon_state_t *state, uint32_t addr,
    uchar_t data);
static int hermon_flash_erase_sector(hermon_state_t *state,
    uint32_t sector_num);
static int hermon_flash_erase_chip(hermon_state_t *state);
static int hermon_flash_bank(hermon_state_t *state, uint32_t addr);
static uint32_t hermon_flash_read(hermon_state_t *state, uint32_t addr,
    int *err);
static void hermon_flash_write(hermon_state_t *state, uint32_t addr,
    uchar_t data, int *err);
static int hermon_flash_spi_wait_wip(hermon_state_t *state);
static void hermon_flash_spi_write_enable(hermon_state_t *state);
static int hermon_flash_init(hermon_state_t *state);
static int hermon_flash_cfi_init(hermon_state_t *state, uint32_t *cfi_info,
    int *intel_xcmd);
static int hermon_flash_fini(hermon_state_t *state);
static int hermon_flash_reset(hermon_state_t *state);
static uint32_t hermon_flash_read_cfg(hermon_state_t *state,
    ddi_acc_handle_t pci_config_hdl, uint32_t addr);
#ifdef DO_WRCONF
static void hermon_flash_write_cfg(hermon_state_t *state,
    ddi_acc_handle_t pci_config_hdl, uint32_t addr, uint32_t data);
static void hermon_flash_write_cfg_helper(hermon_state_t *state,
    ddi_acc_handle_t pci_config_hdl, uint32_t addr, uint32_t data);
static void hermon_flash_write_confirm(hermon_state_t *state,
    ddi_acc_handle_t pci_config_hdl);
#endif
static void hermon_flash_cfi_byte(uint8_t *ch, uint32_t dword, int i);
static void hermon_flash_cfi_dword(uint32_t *dword, uint8_t *ch, int i);

/* Hemron loopback test functions */
static void hermon_loopback_free_qps(hermon_loopback_state_t *lstate);
static void hermon_loopback_free_state(hermon_loopback_state_t *lstate);
static int hermon_loopback_init(hermon_state_t *state,
    hermon_loopback_state_t *lstate);
static void hermon_loopback_init_qp_info(hermon_loopback_state_t *lstate,
    hermon_loopback_comm_t *comm);
static int hermon_loopback_alloc_mem(hermon_loopback_state_t *lstate,
    hermon_loopback_comm_t *comm, int sz);
static int hermon_loopback_alloc_qps(hermon_loopback_state_t *lstate,
    hermon_loopback_comm_t *comm);
static int hermon_loopback_modify_qp(hermon_loopback_state_t *lstate,
    hermon_loopback_comm_t *comm, uint_t qp_num);
static int hermon_loopback_copyout(hermon_loopback_ioctl_t *lb,
    intptr_t arg, int mode);
static int hermon_loopback_post_send(hermon_loopback_state_t *lstate,
    hermon_loopback_comm_t *tx, hermon_loopback_comm_t *rx);
static int hermon_loopback_poll_cq(hermon_loopback_state_t *lstate,
    hermon_loopback_comm_t *comm);

/* Patchable timeout values for flash operations */
int hermon_hw_flash_timeout_gpio_sema = HERMON_HW_FLASH_TIMEOUT_GPIO_SEMA;
int hermon_hw_flash_timeout_config = HERMON_HW_FLASH_TIMEOUT_CONFIG;
int hermon_hw_flash_timeout_write = HERMON_HW_FLASH_TIMEOUT_WRITE;
int hermon_hw_flash_timeout_erase = HERMON_HW_FLASH_TIMEOUT_ERASE;

/*
 * hermon_ioctl()
 */
/* ARGSUSED */
int
hermon_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	hermon_state_t	*state;
	minor_t		instance;
	int		status;

	if (drv_priv(credp) != 0) {
		return (EPERM);
	}

	instance = HERMON_DEV_INSTANCE(dev);
	if (instance == (minor_t)-1) {
		return (EBADF);
	}

	state = ddi_get_soft_state(hermon_statep, instance);
	if (state == NULL) {
		return (EBADF);
	}

	status = 0;

	switch (cmd) {
	case HERMON_IOCTL_FLASH_READ:
		status = hermon_ioctl_flash_read(state, dev, arg, mode);
		break;

	case HERMON_IOCTL_FLASH_WRITE:
		status = hermon_ioctl_flash_write(state, dev, arg, mode);
		break;

	case HERMON_IOCTL_FLASH_ERASE:
		status = hermon_ioctl_flash_erase(state, dev, arg, mode);
		break;

	case HERMON_IOCTL_FLASH_INIT:
		status = hermon_ioctl_flash_init(state, dev, arg, mode);
		break;

	case HERMON_IOCTL_FLASH_FINI:
		status = hermon_ioctl_flash_fini(state, dev);
		break;

	case HERMON_IOCTL_INFO:
		status = hermon_ioctl_info(state, dev, arg, mode);
		break;

	case HERMON_IOCTL_PORTS:
		status = hermon_ioctl_ports(state, arg, mode);
		break;

	case HERMON_IOCTL_LOOPBACK:
		status = hermon_ioctl_loopback(state, arg, mode);
		break;

#ifdef	DEBUG
	case HERMON_IOCTL_REG_WRITE:
		status = hermon_ioctl_reg_write(state, arg, mode);
		break;

	case HERMON_IOCTL_REG_READ:
		status = hermon_ioctl_reg_read(state, arg, mode);
		break;
#endif	/* DEBUG */

	case HERMON_IOCTL_DDR_READ:
		/* XXX guard until the ioctl header is cleaned up */
		status = ENODEV;
		break;

	case HERMON_IOCTL_WRITE_BOOT_ADDR:
		status = hermon_ioctl_write_boot_addr(state, dev, arg, mode);
		break;

	default:
		status = ENOTTY;
		break;
	}
	*rvalp = status;

	return (status);
}

/*
 * hermon_ioctl_flash_read()
 */
static int
hermon_ioctl_flash_read(hermon_state_t *state, dev_t dev, intptr_t arg,
    int mode)
{
	hermon_flash_ioctl_t ioctl_info;
	int status = 0;

	/*
	 * Check that flash init ioctl has been called first.  And check
	 * that the same dev_t that called init is the one calling read now.
	 */
	mutex_enter(&state->hs_fw_flashlock);
	if ((state->hs_fw_flashdev != dev) ||
	    (state->hs_fw_flashstarted == 0)) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EIO);
	}

	/* copy user struct to kernel */
#ifdef _MULTI_DATAMODEL
	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
		hermon_flash_ioctl32_t info32;

		if (ddi_copyin((void *)arg, &info32,
		    sizeof (hermon_flash_ioctl32_t), mode) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}
		ioctl_info.af_type = info32.af_type;
		ioctl_info.af_sector = (caddr_t)(uintptr_t)info32.af_sector;
		ioctl_info.af_sector_num = info32.af_sector_num;
		ioctl_info.af_addr = info32.af_addr;
	} else
#endif /* _MULTI_DATAMODEL */
	if (ddi_copyin((void *)arg, &ioctl_info, sizeof (hermon_flash_ioctl_t),
	    mode) != 0) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EFAULT);
	}

	/*
	 * Determine type of READ ioctl
	 */
	switch (ioctl_info.af_type) {
	case HERMON_FLASH_READ_SECTOR:
		/* Check if sector num is too large for flash device */
		if (ioctl_info.af_sector_num >=
		    (state->hs_fw_device_sz >> state->hs_fw_log_sector_sz)) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}

		/* Perform the Sector Read */
		if ((status = hermon_flash_reset(state)) != 0 ||
		    (status = hermon_flash_read_sector(state,
		    ioctl_info.af_sector_num)) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (status);
		}

		/* copyout the firmware sector image data */
		if (ddi_copyout(&state->hs_fw_sector[0],
		    &ioctl_info.af_sector[0], 1 << state->hs_fw_log_sector_sz,
		    mode) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}
		break;

	case HERMON_FLASH_READ_QUADLET:
		/* Check if addr is too large for flash device */
		if (ioctl_info.af_addr >= state->hs_fw_device_sz) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}

		/* Perform the Quadlet Read */
		if ((status = hermon_flash_reset(state)) != 0 ||
		    (status = hermon_flash_read_quadlet(state,
		    &ioctl_info.af_quadlet, ioctl_info.af_addr)) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (status);
		}
		break;

	default:
		mutex_exit(&state->hs_fw_flashlock);
		return (EINVAL);
	}

	/* copy results back to userland */
#ifdef _MULTI_DATAMODEL
	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
		hermon_flash_ioctl32_t info32;

		info32.af_quadlet = ioctl_info.af_quadlet;
		info32.af_type = ioctl_info.af_type;
		info32.af_sector_num = ioctl_info.af_sector_num;
		info32.af_sector = (caddr32_t)(uintptr_t)ioctl_info.af_sector;
		info32.af_addr = ioctl_info.af_addr;

		if (ddi_copyout(&info32, (void *)arg,
		    sizeof (hermon_flash_ioctl32_t), mode) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}
	} else
#endif /* _MULTI_DATAMODEL */
	if (ddi_copyout(&ioctl_info, (void *)arg,
	    sizeof (hermon_flash_ioctl_t), mode) != 0) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EFAULT);
	}

	mutex_exit(&state->hs_fw_flashlock);
	return (status);
}

/*
 * hermon_ioctl_flash_write()
 */
static int
hermon_ioctl_flash_write(hermon_state_t *state, dev_t dev, intptr_t arg,
    int mode)
{
	hermon_flash_ioctl_t	ioctl_info;
	int status = 0;

	/*
	 * Check that flash init ioctl has been called first.  And check
	 * that the same dev_t that called init is the one calling write now.
	 */
	mutex_enter(&state->hs_fw_flashlock);
	if ((state->hs_fw_flashdev != dev) ||
	    (state->hs_fw_flashstarted == 0)) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EIO);
	}

	/* copy user struct to kernel */
#ifdef _MULTI_DATAMODEL
	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
		hermon_flash_ioctl32_t info32;

		if (ddi_copyin((void *)arg, &info32,
		    sizeof (hermon_flash_ioctl32_t), mode) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}
		ioctl_info.af_type = info32.af_type;
		ioctl_info.af_sector = (caddr_t)(uintptr_t)info32.af_sector;
		ioctl_info.af_sector_num = info32.af_sector_num;
		ioctl_info.af_addr = info32.af_addr;
		ioctl_info.af_byte = info32.af_byte;
	} else
#endif /* _MULTI_DATAMODEL */
	if (ddi_copyin((void *)arg, &ioctl_info,
	    sizeof (hermon_flash_ioctl_t), mode) != 0) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EFAULT);
	}

	/*
	 * Determine type of WRITE ioctl
	 */
	switch (ioctl_info.af_type) {
	case HERMON_FLASH_WRITE_SECTOR:
		/* Check if sector num is too large for flash device */
		if (ioctl_info.af_sector_num >=
		    (state->hs_fw_device_sz >> state->hs_fw_log_sector_sz)) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}

		/* copy in fw sector image data */
		if (ddi_copyin(&ioctl_info.af_sector[0],
		    &state->hs_fw_sector[0], 1 << state->hs_fw_log_sector_sz,
		    mode) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}

		/* Perform Write Sector */
		status = hermon_flash_write_sector(state,
		    ioctl_info.af_sector_num);
		break;

	case HERMON_FLASH_WRITE_BYTE:
		/* Check if addr is too large for flash device */
		if (ioctl_info.af_addr >= state->hs_fw_device_sz) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}

		/* Perform Write Byte */
		/*
		 * CMJ -- is a reset really needed before and after writing
		 * each byte?  This code came from arbel, but we should look
		 * into this.  Also, for SPI, no reset is actually performed.
		 */
		if ((status = hermon_flash_bank(state,
		    ioctl_info.af_addr)) != 0 ||
		    (status = hermon_flash_reset(state)) != 0 ||
		    (status = hermon_flash_write_byte(state,
		    ioctl_info.af_addr, ioctl_info.af_byte)) != 0 ||
		    (status = hermon_flash_reset(state)) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (status);
		}
		break;

	default:
		status = EINVAL;
		break;
	}

	mutex_exit(&state->hs_fw_flashlock);
	return (status);
}

/*
 * hermon_ioctl_flash_erase()
 */
static int
hermon_ioctl_flash_erase(hermon_state_t *state, dev_t dev, intptr_t arg,
    int mode)
{
	hermon_flash_ioctl_t	ioctl_info;
	int status = 0;

	/*
	 * Check that flash init ioctl has been called first.  And check
	 * that the same dev_t that called init is the one calling erase now.
	 */
	mutex_enter(&state->hs_fw_flashlock);
	if ((state->hs_fw_flashdev != dev) ||
	    (state->hs_fw_flashstarted == 0)) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EIO);
	}

	/* copy user struct to kernel */
#ifdef _MULTI_DATAMODEL
	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
		hermon_flash_ioctl32_t info32;

		if (ddi_copyin((void *)arg, &info32,
		    sizeof (hermon_flash_ioctl32_t), mode) != 0) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}
		ioctl_info.af_type = info32.af_type;
		ioctl_info.af_sector_num = info32.af_sector_num;
	} else
#endif /* _MULTI_DATAMODEL */
	if (ddi_copyin((void *)arg, &ioctl_info, sizeof (hermon_flash_ioctl_t),
	    mode) != 0) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EFAULT);
	}

	/*
	 * Determine type of ERASE ioctl
	 */
	switch (ioctl_info.af_type) {
	case HERMON_FLASH_ERASE_SECTOR:
		/* Check if sector num is too large for flash device */
		if (ioctl_info.af_sector_num >=
		    (state->hs_fw_device_sz >> state->hs_fw_log_sector_sz)) {
			mutex_exit(&state->hs_fw_flashlock);
			return (EFAULT);
		}

		/* Perform Sector Erase */
		status = hermon_flash_erase_sector(state,
		    ioctl_info.af_sector_num);
		break;

	case HERMON_FLASH_ERASE_CHIP:
		/* Perform Chip Erase */
		status = hermon_flash_erase_chip(state);
		break;

	default:
		status = EINVAL;
		break;
	}

	mutex_exit(&state->hs_fw_flashlock);
	return (status);
}

/*
 * hermon_ioctl_flash_init()
 */
static int
hermon_ioctl_flash_init(hermon_state_t *state, dev_t dev, intptr_t arg,
    int mode)
{
	hermon_flash_init_ioctl_t init_info;
	int ret;
	int intel_xcmd = 0;
	ddi_acc_handle_t pci_hdl = hermon_get_pcihdl(state);

	/* initialize the FMA retry loop */
	hermon_pio_init(fm_loop_cnt, fm_status, fm_test);

	state->hs_fw_sector = NULL;

	/*
	 * init cannot be called more than once.  If we have already init'd the
	 * flash, return directly.
	 */
	mutex_enter(&state->hs_fw_flashlock);
	if (state->hs_fw_flashstarted == 1) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EINVAL);
	}

	/* copyin the user struct to kernel */
	if (ddi_copyin((void *)arg, &init_info,
	    sizeof (hermon_flash_init_ioctl_t), mode) != 0) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EFAULT);
	}

	/* Init Flash */
	if ((ret = hermon_flash_init(state)) != 0) {
		if (ret == EIO) {
			goto pio_error;
		}
		mutex_exit(&state->hs_fw_flashlock);
		return (ret);
	}

	/* Read CFI info */
	if ((ret = hermon_flash_cfi_init(state, &init_info.af_cfi_info[0],
	    &intel_xcmd)) != 0) {
		if (ret == EIO) {
			goto pio_error;
		}
		mutex_exit(&state->hs_fw_flashlock);
		return (ret);
	}

	/*
	 * Return error if the command set is unknown.
	 */
	if (state->hs_fw_cmdset == HERMON_FLASH_UNKNOWN_CMDSET) {
		if ((ret = hermon_ioctl_flash_cleanup_nolock(state)) != 0) {
			if (ret == EIO) {
				goto pio_error;
			}
			mutex_exit(&state->hs_fw_flashlock);
			return (ret);
		}
		mutex_exit(&state->hs_fw_flashlock);
		return (EFAULT);
	}

	/* the FMA retry loop starts. */
	hermon_pio_start(state, pci_hdl, pio_error,
	    fm_loop_cnt, fm_status, fm_test);

	/* Read HWREV - least significant 8 bits is revision ID */
	init_info.af_hwrev = pci_config_get32(pci_hdl,
	    HERMON_HW_FLASH_CFG_HWREV) & 0xFF;

	/* the FMA retry loop ends. */
	hermon_pio_end(state, pci_hdl, pio_error, fm_loop_cnt,
	    fm_status, fm_test);

	/* Fill in the firmwate revision numbers */
	init_info.af_fwrev.afi_maj	= state->hs_fw.fw_rev_major;
	init_info.af_fwrev.afi_min	= state->hs_fw.fw_rev_minor;
	init_info.af_fwrev.afi_sub	= state->hs_fw.fw_rev_subminor;

	/* Alloc flash mem for one sector size */
	state->hs_fw_sector = (uint32_t *)kmem_zalloc(1 <<
	    state->hs_fw_log_sector_sz, KM_SLEEP);

	/* Set HW part number and length */
	init_info.af_pn_len = state->hs_hca_pn_len;
	if (state->hs_hca_pn_len != 0) {
		(void) memcpy(init_info.af_hwpn, state->hs_hca_pn,
		    state->hs_hca_pn_len);
	}

	/* Copy ioctl results back to userland */
	if (ddi_copyout(&init_info, (void *)arg,
	    sizeof (hermon_flash_init_ioctl_t), mode) != 0) {
		if ((ret = hermon_ioctl_flash_cleanup_nolock(state)) != 0) {
			if (ret == EIO) {
				goto pio_error;
			}
			mutex_exit(&state->hs_fw_flashlock);
			return (ret);
		}
		mutex_exit(&state->hs_fw_flashlock);
		return (EFAULT);
	}

	/* Set flash state to started */
	state->hs_fw_flashstarted = 1;
	state->hs_fw_flashdev	  = dev;

	mutex_exit(&state->hs_fw_flashlock);

	/*
	 * If "flash init" is successful, add an "on close" callback to the
	 * current dev node to ensure that "flash fini" gets called later
	 * even if the userland process prematurely exits.
	 */
	ret = hermon_umap_db_set_onclose_cb(dev,
	    HERMON_ONCLOSE_FLASH_INPROGRESS,
	    (int (*)(void *))hermon_ioctl_flash_cleanup, state);
	if (ret != DDI_SUCCESS) {
		int status = hermon_ioctl_flash_fini(state, dev);
		if (status != 0) {
			if (status == EIO) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_IOCTL);
				return (EIO);
			}
			return (status);
		}
	}
	return (0);

pio_error:
	mutex_exit(&state->hs_fw_flashlock);
	hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_IOCTL);
	return (EIO);
}

/*
 * hermon_ioctl_flash_fini()
 */
static int
hermon_ioctl_flash_fini(hermon_state_t *state, dev_t dev)
{
	int ret;

	/*
	 * Check that flash init ioctl has been called first.  And check
	 * that the same dev_t that called init is the one calling fini now.
	 */
	mutex_enter(&state->hs_fw_flashlock);
	if ((state->hs_fw_flashdev != dev) ||
	    (state->hs_fw_flashstarted == 0)) {
		mutex_exit(&state->hs_fw_flashlock);
		return (EINVAL);
	}

	if ((ret = hermon_ioctl_flash_cleanup_nolock(state)) != 0) {
		mutex_exit(&state->hs_fw_flashlock);
		if (ret == EIO) {
			hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_IOCTL);
		}
		return (ret);
	}
	mutex_exit(&state->hs_fw_flashlock);

	/*
	 * If "flash fini" is successful, remove the "on close" callback
	 * that was setup during "flash init".
	 */
	ret = hermon_umap_db_clear_onclose_cb(dev,
	    HERMON_ONCLOSE_FLASH_INPROGRESS);
	if (ret != DDI_SUCCESS) {
		return (EFAULT);
	}
	return (0);
}


/*
 * hermon_ioctl_flash_cleanup()
 */
static int
hermon_ioctl_flash_cleanup(hermon_state_t *state)
{
	int status;

	mutex_enter(&state->hs_fw_flashlock);
	status = hermon_ioctl_flash_cleanup_nolock(state);
	mutex_exit(&state->hs_fw_flashlock);

	return (status);
}


/*
 * hermon_ioctl_flash_cleanup_nolock()
 */
static int
hermon_ioctl_flash_cleanup_nolock(hermon_state_t *state)
{
	int status;
	ASSERT(MUTEX_HELD(&state->hs_fw_flashlock));

	/* free flash mem */
	if (state->hs_fw_sector) {
		kmem_free(state->hs_fw_sector, 1 << state->hs_fw_log_sector_sz);
	}

	/* Fini the Flash */
	if ((status = hermon_flash_fini(state)) != 0)
		return (status);

	/* Set flash state to fini */
	state->hs_fw_flashstarted = 0;
	state->hs_fw_flashdev	  = 0;
	return (0);
}


/*
 * hermon_ioctl_info()
 */
static int
hermon_ioctl_info(hermon_state_t *state, dev_t dev, intptr_t arg, int mode)
{
	hermon_info_ioctl_t	 info;
	hermon_flash_init_ioctl_t init_info;

	/*
	 * Access to Hemron VTS ioctls is not allowed in "maintenance mode".
	 */
	if (state->hs_operational_mode == HERMON_MAINTENANCE_MODE) {
		return (EFAULT);
	}

	/* copyin the user struct to kernel */
	if (ddi_copyin((void *)arg, &info, sizeof (hermon_info_ioctl_t),
	    mode) != 0) {
		return (EFAULT);
	}

	/*
	 * Check ioctl revision
	 */
	if (info.ai_revision != HERMON_VTS_IOCTL_REVISION) {
		return (EINVAL);
	}

	/*
	 * If the 'fw_device_sz' has not been initialized yet, we initialize it
	 * here.  This is done by leveraging the
	 * hermon_ioctl_flash_init()/fini() calls.  We also hold our own mutex
	 * around this operation in case we have multiple VTS threads in
	 * process at the same time.
	 */
	mutex_enter(&state->hs_info_lock);
	if (state->hs_fw_device_sz == 0) {
		if (hermon_ioctl_flash_init(state, dev, (intptr_t)&init_info,
		    (FKIOCTL | mode)) != 0) {
			mutex_exit(&state->hs_info_lock);
			return (EFAULT);
		}
		(void) hermon_ioctl_flash_fini(state, dev);
	}
	mutex_exit(&state->hs_info_lock);

	info.ai_hw_rev		 = state->hs_revision_id;
	info.ai_flash_sz	 = state->hs_fw_device_sz;
	info.ai_fw_rev.afi_maj	 = state->hs_fw.fw_rev_major;
	info.ai_fw_rev.afi_min	 = state->hs_fw.fw_rev_minor;
	info.ai_fw_rev.afi_sub	 = state->hs_fw.fw_rev_subminor;

	/* Copy ioctl results back to user struct */
	if (ddi_copyout(&info, (void *)arg, sizeof (hermon_info_ioctl_t),
	    mode) != 0) {
		return (EFAULT);
	}

	return (0);
}

/*
 * hermon_ioctl_ports()
 */
static int
hermon_ioctl_ports(hermon_state_t *state, intptr_t arg, int mode)
{
	hermon_ports_ioctl_t	info;
	hermon_stat_port_ioctl_t	portstat;
	ibt_hca_portinfo_t	pi;
	uint_t			tbl_size;
	ib_gid_t		*sgid_tbl;
	ib_pkey_t		*pkey_tbl;
	int			i;

	/*
	 * Access to Hemron VTS ioctls is not allowed in "maintenance mode".
	 */
	if (state->hs_operational_mode == HERMON_MAINTENANCE_MODE) {
		return (EFAULT);
	}

	/* copyin the user struct to kernel */
#ifdef _MULTI_DATAMODEL
	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
		hermon_ports_ioctl32_t info32;

		if (ddi_copyin((void *)arg, &info32,
		    sizeof (hermon_ports_ioctl32_t), mode) != 0) {
			return (EFAULT);
		}
		info.ap_revision  = info32.ap_revision;
		info.ap_ports	  =
		    (hermon_stat_port_ioctl_t *)(uintptr_t)info32.ap_ports;
		info.ap_num_ports = info32.ap_num_ports;

	} else
#endif /* _MULTI_DATAMODEL */
	if (ddi_copyin((void *)arg, &info, sizeof (hermon_ports_ioctl_t),
	    mode) != 0) {
		return (EFAULT);
	}

	/*
	 * Check ioctl revision
	 */
	if (info.ap_revision != HERMON_VTS_IOCTL_REVISION) {
		return (EINVAL);
	}

	/* Allocate space for temporary GID table/PKey table */
	tbl_size = (1 << state->hs_cfg_profile->cp_log_max_gidtbl);
	sgid_tbl = (ib_gid_t *)kmem_zalloc(tbl_size * sizeof (ib_gid_t),
	    KM_SLEEP);
	tbl_size = (1 << state->hs_cfg_profile->cp_log_max_pkeytbl);
	pkey_tbl = (ib_pkey_t *)kmem_zalloc(tbl_size * sizeof (ib_pkey_t),
	    KM_SLEEP);

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sgid_tbl, *pkey_tbl))

	/*
	 * Setup the number of ports, then loop through all ports and
	 * query properties of each.
	 */
	info.ap_num_ports = (uint8_t)state->hs_cfg_profile->cp_num_ports;
	for (i = 0; i < info.ap_num_ports; i++) {
		/*
		 * Get portstate information from the device.  If
		 * hermon_port_query() fails, leave zeroes in user
		 * struct port entry and continue.
		 */
		bzero(&pi, sizeof (ibt_hca_portinfo_t));
		pi.p_sgid_tbl = sgid_tbl;
		pi.p_pkey_tbl = pkey_tbl;
		(void) hermon_port_query(state, i + 1, &pi);

		portstat.asp_port_num	= pi.p_port_num;
		portstat.asp_state	= pi.p_linkstate;
		portstat.asp_guid	= pi.p_sgid_tbl[0].gid_guid;

		/*
		 * Copy queried port results back to user struct.  If
		 * this fails, then break out of loop, attempt to copy
		 * out remaining info to user struct, and return (without
		 * error).
		 */
		if (ddi_copyout(&portstat,
		    &(((hermon_stat_port_ioctl_t *)info.ap_ports)[i]),
		    sizeof (hermon_stat_port_ioctl_t), mode) != 0) {
			break;
		}
	}

	/* Free the temporary space used for GID table/PKey table */
	tbl_size = (1 << state->hs_cfg_profile->cp_log_max_gidtbl);
	kmem_free(sgid_tbl, tbl_size * sizeof (ib_gid_t));
	tbl_size = (1 << state->hs_cfg_profile->cp_log_max_pkeytbl);
	kmem_free(pkey_tbl, tbl_size * sizeof (ib_pkey_t));

	/* Copy ioctl results back to user struct */
#ifdef _MULTI_DATAMODEL
	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
		hermon_ports_ioctl32_t info32;

		info32.ap_revision  = info.ap_revision;
		info32.ap_ports	    = (caddr32_t)(uintptr_t)info.ap_ports;
		info32.ap_num_ports = info.ap_num_ports;

		if (ddi_copyout(&info32, (void *)arg,
		    sizeof (hermon_ports_ioctl32_t), mode) != 0) {
			return (EFAULT);
		}
	} else
#endif /* _MULTI_DATAMODEL */
	if (ddi_copyout(&info, (void *)arg, sizeof (hermon_ports_ioctl_t),
	    mode) != 0) {
		return (EFAULT);
	}

	return (0);
}

/*
 * hermon_ioctl_loopback()
 */
static int
hermon_ioctl_loopback(hermon_state_t *state, intptr_t arg, int mode)
{
	hermon_loopback_ioctl_t	lb;
	hermon_loopback_state_t	lstate;
	ibt_hca_portinfo_t 	pi;
	uint_t			tbl_size, loopmax, max_usec;
	ib_gid_t		*sgid_tbl;
	ib_pkey_t		*pkey_tbl;
	int			j, iter, ret;

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(lstate))

	/*
	 * Access to Hemron VTS ioctls is not allowed in "maintenance mode".
	 */
	if (state->hs_operational_mode == HERMON_MAINTENANCE_MODE) {
		return (EFAULT);
	}

	/* copyin the user struct to kernel */
#ifdef _MULTI_DATAMODEL
	if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
		hermon_loopback_ioctl32_t lb32;

		if (ddi_copyin((void *)arg, &lb32,
		    sizeof (hermon_loopback_ioctl32_t), mode) != 0) {
			return (EFAULT);
		}
		lb.alb_revision	    = lb32.alb_revision;
		lb.alb_send_buf	    = (caddr_t)(uintptr_t)lb32.alb_send_buf;
		lb.alb_fail_buf	    = (caddr_t)(uintptr_t)lb32.alb_fail_buf;
		lb.alb_buf_sz	    = lb32.alb_buf_sz;
		lb.alb_num_iter	    = lb32.alb_num_iter;
		lb.alb_pass_done    = lb32.alb_pass_done;
		lb.alb_timeout	    = lb32.alb_timeout;
		lb.alb_error_type   = lb32.alb_error_type;
		lb.alb_port_num	    = lb32.alb_port_num;
		lb.alb_num_retry    = lb32.alb_num_retry;
	} else
#endif /* _MULTI_DATAMODEL */
	if (ddi_copyin((void *)arg, &lb, sizeof (hermon_loopback_ioctl_t),
	    mode) != 0) {
		return (EFAULT);
	}

	/* Initialize the internal loopback test state structure */
	bzero(&lstate, sizeof (hermon_loopback_state_t));

	/*
	 * Check ioctl revision
	 */
	if (lb.alb_revision != HERMON_VTS_IOCTL_REVISION) {
		lb.alb_error_type = HERMON_LOOPBACK_INVALID_REVISION;
		(void) hermon_loopback_copyout(&lb, arg, mode);
		return (EINVAL);
	}

	/* Validate that specified port number is legal */