/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (c) 2017, Joyent, Inc.
 */

#include <sys/scsi/adapters/smrt/smrt.h>

static int smrt_attach(dev_info_t *, ddi_attach_cmd_t);
static int smrt_detach(dev_info_t *, ddi_detach_cmd_t);
static int smrt_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
static void smrt_cleanup(smrt_t *);
static int smrt_command_comparator(const void *, const void *);

/*
 * Controller soft state.  Each entry is an object of type "smrt_t".
 */
void *smrt_state;

/*
 * DMA attributes template.  Each controller will make a copy of this template
 * with appropriate customisations; e.g., the Scatter/Gather List Length.
 */
static ddi_dma_attr_t smrt_dma_attr_template = {
	.dma_attr_version =		DMA_ATTR_V0,
	.dma_attr_addr_lo =		0x0000000000000000,
	.dma_attr_addr_hi =		0xFFFFFFFFFFFFFFFF,
	.dma_attr_count_max =		0x00FFFFFF,
	.dma_attr_align =		0x20,
	.dma_attr_burstsizes =		0x20,
	.dma_attr_minxfer =		DMA_UNIT_8,
	.dma_attr_maxxfer =		0xFFFFFFFF,
	/*
	 * There is some suggestion that at least some, possibly older, Smart
	 * Array controllers cannot tolerate a DMA segment that straddles a 4GB
	 * boundary.
	 */
	.dma_attr_seg =			0xFFFFFFFF,
	.dma_attr_sgllen =		1,
	.dma_attr_granular =		512,
	.dma_attr_flags =		0
};

/*
 * Device memory access attributes for device control registers.
 */
ddi_device_acc_attr_t smrt_dev_attributes = {
	.devacc_attr_version =		DDI_DEVICE_ATTR_V0,
	.devacc_attr_endian_flags =	DDI_STRUCTURE_LE_ACC,
	.devacc_attr_dataorder =	DDI_STRICTORDER_ACC,
	.devacc_attr_access =		0
};

/*
 * Character/Block Operations Structure
 */
static struct cb_ops smrt_cb_ops = {
	.cb_rev =			CB_REV,
	.cb_flag =			D_NEW | D_MP,

	.cb_open =			scsi_hba_open,
	.cb_close =			scsi_hba_close,

	.cb_ioctl =			smrt_ioctl,

	.cb_strategy =			nodev,
	.cb_print =			nodev,
	.cb_dump =			nodev,
	.cb_read =			nodev,
	.cb_write =			nodev,
	.cb_devmap =			nodev,
	.cb_mmap =			nodev,
	.cb_segmap =			nodev,
	.cb_chpoll =			nochpoll,
	.cb_prop_op =			ddi_prop_op,
	.cb_str =			NULL,
	.cb_aread =			nodev,
	.cb_awrite =			nodev
};

/*
 * Device Operations Structure
 */
static struct dev_ops smrt_dev_ops = {
	.devo_rev =			DEVO_REV,
	.devo_refcnt =			0,

	.devo_attach =			smrt_attach,
	.devo_detach =			smrt_detach,

	.devo_cb_ops =			&smrt_cb_ops,

	.devo_getinfo =			nodev,
	.devo_identify =		nulldev,
	.devo_probe =			nulldev,
	.devo_reset =			nodev,
	.devo_bus_ops =			NULL,
	.devo_power =			nodev,
	.devo_quiesce =			nodev
};

/*
 * Linkage structures
 */
static struct modldrv smrt_modldrv = {
	.drv_modops =			&mod_driverops,
	.drv_linkinfo =			"HP Smart Array",
	.drv_dev_ops =			&smrt_dev_ops
};

static struct modlinkage smrt_modlinkage = {
	.ml_rev =			MODREV_1,
	.ml_linkage =			{ &smrt_modldrv, NULL }
};


int
_init()
{
	int r;

	VERIFY0(ddi_soft_state_init(&smrt_state, sizeof (smrt_t), 0));

	if ((r = scsi_hba_init(&smrt_modlinkage)) != 0) {
		goto fail;
	}

	if ((r = mod_install(&smrt_modlinkage)) != 0) {
		scsi_hba_fini(&smrt_modlinkage);
		goto fail;
	}

	return (r);

fail:
	ddi_soft_state_fini(&smrt_state);
	return (r);
}

int
_fini()
{
	int r;

	if ((r = mod_remove(&smrt_modlinkage)) == 0) {
		scsi_hba_fini(&smrt_modlinkage);
		ddi_soft_state_fini(&smrt_state);
	}

	return (r);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&smrt_modlinkage, modinfop));
}

static int
smrt_iport_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	const char *addr;
	dev_info_t *pdip;
	int instance;
	smrt_t *smrt;

	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);

	/*
	 * Note, we cannot get to our parent via the tran's tran_hba_private
	 * member.  This pointer is reset to NULL when the scsi_hba_tran_t
	 * structure is duplicated.
	 */
	addr = scsi_hba_iport_unit_address(dip);
	VERIFY(addr != NULL);
	pdip = ddi_get_parent(dip);
	instance = ddi_get_instance(pdip);
	smrt = ddi_get_soft_state(smrt_state, instance);
	VERIFY(smrt != NULL);

	if (strcmp(addr, SMRT_IPORT_VIRT) == 0) {
		if (smrt_logvol_hba_setup(smrt, dip) != DDI_SUCCESS)
			return (DDI_FAILURE);
		smrt->smrt_virt_iport = dip;
	} else if (strcmp(addr, SMRT_IPORT_PHYS) == 0) {
		if (smrt_phys_hba_setup(smrt, dip) != DDI_SUCCESS)
			return (DDI_FAILURE);
		smrt->smrt_phys_iport = dip;
	} else {
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static int
smrt_iport_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	const char *addr;
	scsi_hba_tran_t *tran;
	smrt_t *smrt;

	if (cmd != DDI_DETACH)
		return (DDI_FAILURE);

	tran = ddi_get_driver_private(dip);
	VERIFY(tran != NULL);
	smrt = tran->tran_hba_private;
	VERIFY(smrt != NULL);

	addr = scsi_hba_iport_unit_address(dip);
	VERIFY(addr != NULL);

	if (strcmp(addr, SMRT_IPORT_VIRT) == 0) {
		smrt_logvol_hba_teardown(smrt, dip);
		smrt->smrt_virt_iport = NULL;
	} else if (strcmp(addr, SMRT_IPORT_PHYS) == 0) {
		smrt_phys_hba_teardown(smrt, dip);
		smrt->smrt_phys_iport = NULL;
	} else {
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static int
smrt_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	uint32_t instance;
	smrt_t *smrt;
	boolean_t check_for_interrupts = B_FALSE;
	int r;
	char taskq_name[64];

	if (scsi_hba_iport_unit_address(dip) != NULL)
		return (smrt_iport_attach(dip, cmd));

	if (cmd != DDI_ATTACH) {
		return (DDI_FAILURE);
	}

	/*
	 * Allocate the per-controller soft state object and get
	 * a pointer to it.
	 */
	instance = ddi_get_instance(dip);
	if (ddi_soft_state_zalloc(smrt_state, instance) != DDI_SUCCESS) {
		dev_err(dip, CE_WARN, "could not allocate soft state");
		return (DDI_FAILURE);
	}
	if ((smrt = ddi_get_soft_state(smrt_state, instance)) == NULL) {
		dev_err(dip, CE_WARN, "could not get soft state");
		ddi_soft_state_free(smrt_state, instance);
		return (DDI_FAILURE);
	}

	/*
	 * Initialise per-controller state object.
	 */
	smrt->smrt_dip = dip;
	smrt->smrt_instance = instance;
	smrt->smrt_next_tag = SMRT_MIN_TAG_NUMBER;
	list_create(&smrt->smrt_commands, sizeof (smrt_command_t),
	    offsetof(smrt_command_t, smcm_link));
	list_create(&smrt->smrt_finishq, sizeof (smrt_command_t),
	    offsetof(smrt_command_t, smcm_link_finish));
	list_create(&smrt->smrt_abortq, sizeof (smrt_command_t),
	    offsetof(smrt_command_t, smcm_link_abort));
	list_create(&smrt->smrt_volumes, sizeof (smrt_volume_t),
	    offsetof(smrt_volume_t, smlv_link));
	list_create(&smrt->smrt_physicals, sizeof (smrt_physical_t),
	    offsetof(smrt_physical_t, smpt_link));
	list_create(&smrt->smrt_targets, sizeof (smrt_target_t),
	    offsetof(smrt_target_t, smtg_link_ctlr));
	avl_create(&smrt->smrt_inflight, smrt_command_comparator,
	    sizeof (smrt_command_t), offsetof(smrt_command_t,
	    smcm_node));
	cv_init(&smrt->smrt_cv_finishq, NULL, CV_DRIVER, NULL);

	smrt->smrt_init_level |= SMRT_INITLEVEL_BASIC;

	/*
	 * Perform basic device setup, including identifying the board, mapping
	 * the I2O registers and the Configuration Table.
	 */
	if (smrt_device_setup(smrt) != DDI_SUCCESS) {
		dev_err(dip, CE_WARN, "device setup failed");
		goto fail;
	}

	/*
	 * Select a Transport Method (e.g. Simple or Performant) and update
	 * the Configuration Table.  This function also waits for the
	 * controller to become ready.
	 */
	if (smrt_ctlr_init(smrt) != DDI_SUCCESS) {
		dev_err(dip, CE_WARN, "controller initialisation failed");
		goto fail;
	}

	/*
	 * Each controller may have a different Scatter/Gather Element count.
	 * Configure a per-controller set of DMA attributes with the
	 * appropriate S/G size.
	 */
	VERIFY(smrt->smrt_sg_cnt > 0);
	smrt->smrt_dma_attr = smrt_dma_attr_template;
	smrt->smrt_dma_attr.dma_attr_sgllen = smrt->smrt_sg_cnt;

	/*
	 * Now that we have selected a Transport Method, we can configure
	 * the appropriate interrupt handlers.
	 */
	if (smrt_interrupts_setup(smrt) != DDI_SUCCESS) {
		dev_err(dip, CE_WARN, "interrupt handler setup failed");
		goto fail;
	}

	/*
	 * Now that we have the correct interrupt priority, we can initialise
	 * the mutex.  This must be done before the interrupt handler is
	 * enabled.
	 */
	mutex_init(&smrt->smrt_mutex, NULL, MUTEX_DRIVER,
	    DDI_INTR_PRI(smrt->smrt_interrupt_pri));
	smrt->smrt_init_level |= SMRT_INITLEVEL_MUTEX;

	/*
	 * From this point forward, the controller is able to accept commands
	 * and (at least by polling) return command submissions.  Setting this
	 * flag allows the rest of the driver to interact with the device.
	 */
	smrt->smrt_status |= SMRT_CTLR_STATUS_RUNNING;

	if (smrt_interrupts_enable(smrt) != DDI_SUCCESS) {
		dev_err(dip, CE_WARN, "interrupt handler could not be enabled");
		goto fail;
	}

	if (smrt_ctrl_hba_setup(smrt) != DDI_SUCCESS) {
		dev_err(dip, CE_WARN, "SCSI framework setup failed");
		goto fail;
	}

	/*
	 * Set the appropriate Interrupt Mask Register bits to start
	 * command completion interrupts from the controller.
	 */
	smrt_intr_set(smrt, B_TRUE);
	check_for_interrupts = B_TRUE;

	/*
	 * Register the maintenance routine for periodic execution:
	 */
	smrt->smrt_periodic = ddi_periodic_add(smrt_periodic, smrt,
	    SMRT_PERIODIC_RATE * NANOSEC, DDI_IPL_0);
	smrt->smrt_init_level |= SMRT_INITLEVEL_PERIODIC;

	(void) snprintf(taskq_name, sizeof (taskq_name), "smrt_discover_%u",
	    instance);
	smrt->smrt_discover_taskq = ddi_taskq_create(smrt->smrt_dip, taskq_name,
	    1, TASKQ_DEFAULTPRI, 0);
	if (smrt->smrt_discover_taskq == NULL) {
		dev_err(dip, CE_WARN, "failed to create discovery task queue");
		goto fail;
	}
	smrt->smrt_init_level |= SMRT_INITLEVEL_TASKQ;

	if ((r = smrt_event_init(smrt)) != 0) {
		dev_err(dip, CE_WARN, "could not initialize event subsystem "
		    "(%d)", r);
		goto fail;
	}
	smrt->smrt_init_level |= SMRT_INITLEVEL_ASYNC_EVENT;

	if (scsi_hba_iport_register(dip, SMRT_IPORT_VIRT) != DDI_SUCCESS)
		goto fail;

	if (scsi_hba_iport_register(dip, SMRT_IPORT_PHYS) != DDI_SUCCESS)
		goto fail;

	/*
	 * Announce the attachment of this controller.
	 */
	ddi_report_dev(dip);

	return (DDI_SUCCESS);

fail:
	if (check_for_interrupts) {
		if (smrt->smrt_stats.smrts_claimed_interrupts == 0) {
			dev_err(dip, CE_WARN, "controller did not interrupt "
			    "during attach");
		}
	}
	smrt_cleanup(smrt);
	return (DDI_FAILURE);
}

static int
smrt_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	scsi_hba_tran_t *tran = (scsi_hba_tran_t *)ddi_get_driver_private(dip);
	smrt_t *smrt = (smrt_t *)tran->tran_hba_private;

	if (scsi_hba_iport_unit_address(dip) != NULL)
		return (smrt_iport_detach(dip, cmd));

	if (cmd != DDI_DETACH) {
		return (DDI_FAILURE);
	}

	/*
	 * First, check to make sure that all SCSI framework targets have
	 * detached.
	 */
	mutex_enter(&smrt->smrt_mutex);
	if (!list_is_empty(&smrt->smrt_targets)) {
		mutex_exit(&smrt->smrt_mutex);
		dev_err(smrt->smrt_dip, CE_WARN, "cannot detach; targets still "
		    "using HBA");
		return (DDI_FAILURE);
	}

	if (smrt->smrt_virt_iport != NULL || smrt->smrt_phys_iport != NULL) {
		mutex_exit(&smrt->smrt_mutex);
		dev_err(smrt->smrt_dip, CE_WARN, "cannot detach: iports still "
		    "attached");
		return (DDI_FAILURE);
	}

	/*
	 * Prevent new targets from attaching now:
	 */
	smrt->smrt_status |= SMRT_CTLR_STATUS_DETACHING;
	mutex_exit(&smrt->smrt_mutex);

	/*
	 * Clean up all remaining resources.
	 */
	smrt_cleanup(smrt);

	return (DDI_SUCCESS);
}

static int
smrt_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rval)
{
	int inst = MINOR2INST(getminor(dev));
	int status;

	if (secpolicy_sys_config(credp, B_FALSE) != 0) {
		return (EPERM);
	}

	/*
	 * Ensure that we have a soft state object for this instance.
	 */
	if (ddi_get_soft_state(smrt_state, inst) == NULL) {
		return (ENXIO);
	}

	switch (cmd) {
	default:
		status = scsi_hba_ioctl(dev, cmd, arg, mode, credp, rval);
		break;
	}

	return (status);
}

static void
smrt_cleanup(smrt_t *smrt)
{
	if (smrt->smrt_init_level & SMRT_INITLEVEL_ASYNC_EVENT) {
		smrt_event_fini(smrt);
		smrt->smrt_init_level &= ~SMRT_INITLEVEL_ASYNC_EVENT;
	}

	smrt_interrupts_teardown(smrt);

	if (smrt->smrt_init_level & SMRT_INITLEVEL_TASKQ) {
		ddi_taskq_destroy(smrt->smrt_discover_taskq);
		smrt->smrt_discover_taskq = NULL;
		smrt->smrt_init_level &= ~SMRT_INITLEVEL_TASKQ;
	}

	if (smrt->smrt_init_level & SMRT_INITLEVEL_PERIODIC) {
		ddi_periodic_delete(smrt->smrt_periodic);
		smrt->smrt_init_level &= ~SMRT_INITLEVEL_PERIODIC;
	}

	smrt_ctrl_hba_teardown(smrt);

	smrt_ctlr_teardown(smrt);

	smrt_device_teardown(smrt);

	if (smrt->smrt_init_level & SMRT_INITLEVEL_BASIC) {
		smrt_logvol_teardown(smrt);
		smrt_phys_teardown(smrt);

		cv_destroy(&smrt->smrt_cv_finishq);

		VERIFY(list_is_empty(&smrt->smrt_commands));
		list_destroy(&smrt->smrt_commands);
		list_destroy(&smrt->smrt_finishq);
		list_destroy(&smrt->smrt_abortq);

		VERIFY(list_is_empty(&smrt->smrt_volumes));
		list_destroy(&smrt->smrt_volumes);

		VERIFY(list_is_empty(&smrt->smrt_physicals));
		list_destroy(&smrt->smrt_physicals);

		VERIFY(list_is_empty(&smrt->smrt_targets));
		list_destroy(&smrt->smrt_targets);

		VERIFY(avl_is_empty(&smrt->smrt_inflight));
		avl_destroy(&smrt->smrt_inflight);

		smrt->smrt_init_level &= ~SMRT_INITLEVEL_BASIC;
	}

	if (smrt->smrt_init_level & SMRT_INITLEVEL_MUTEX) {
		mutex_destroy(&smrt->smrt_mutex);

		smrt->smrt_init_level &= ~SMRT_INITLEVEL_MUTEX;
	}

	VERIFY0(smrt->smrt_init_level);

	ddi_soft_state_free(smrt_state, ddi_get_instance(smrt->smrt_dip));
}

/*
 * Comparator for the "smrt_inflight" AVL tree in a "smrt_t".  This AVL tree
 * allows a tag ID to be mapped back to the relevant "smrt_command_t".
 */
static int
smrt_command_comparator(const void *lp, const void *rp)
{
	const smrt_command_t *l = lp;
	const smrt_command_t *r = rp;

	if (l->smcm_tag > r->smcm_tag) {
		return (1);
	} else if (l->smcm_tag < r->smcm_tag) {
		return (-1);
	} else {
		return (0);
	}
}