/*

 * mr_sas.c: source for mr_sas driver

 *

 * MegaRAID device driver for SAS2.0 controllers

 * Copyright (c) 2008-2010, LSI Logic Corporation.

 * All rights reserved.

 *

 * Version:

 * Author:

 *		Arun Chandrashekhar

 *		Manju R

 *		Rajesh Prabhakaran

 * 		Seokmann Ju

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *

 * 3. Neither the name of the author nor the names of its contributors may be

 *    used to endorse or promote products derived from this software without

 *    specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 */

/*

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

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/file.h>

#include <sys/errno.h>

#include <sys/open.h>

#include <sys/cred.h>

#include <sys/modctl.h>

#include <sys/conf.h>

#include <sys/devops.h>

#include <sys/cmn_err.h>

#include <sys/kmem.h>

#include <sys/stat.h>

#include <sys/mkdev.h>

#include <sys/pci.h>

#include <sys/scsi/scsi.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#include <sys/atomic.h>

#include <sys/signal.h>

#include <sys/byteorder.h>

#include <sys/sdt.h>

#include <sys/fs/dv_node.h>	/* devfs_clean */

#include "mr_sas.h"

/*

 * FMA header files

 */

#include <sys/ddifm.h>

#include <sys/fm/protocol.h>

#include <sys/fm/util.h>

#include <sys/fm/io/ddi.h>

/*

 * Local static data

 */

static void	*mrsas_state = NULL;

static volatile boolean_t	mrsas_relaxed_ordering = B_TRUE;

static volatile int 	debug_level_g = CL_NONE;

static volatile int 	msi_enable = 1;

static volatile int 	ctio_enable = 1;

/* Default Timeout value to issue online controller reset */

static volatile int  debug_timeout_g  = 0xB4;

/* Simulate consecutive firmware fault */

static volatile int  debug_fw_faults_after_ocr_g  = 0;

#ifdef OCRDEBUG

/* Simulate three consecutive timeout for an IO */

static volatile int  debug_consecutive_timeout_after_ocr_g  = 0;

#endif

#pragma weak scsi_hba_open

#pragma weak scsi_hba_close

#pragma weak scsi_hba_ioctl

static ddi_dma_attr_t mrsas_generic_dma_attr = {

	DMA_ATTR_V0,		/* dma_attr_version */

	0,			/* low DMA address range */

	0xFFFFFFFFU,		/* high DMA address range */

	0xFFFFFFFFU,		/* DMA counter register  */

	8,			/* DMA address alignment */

	0x07,			/* DMA burstsizes  */

	1,			/* min DMA size */

	0xFFFFFFFFU,		/* max DMA size */

	0xFFFFFFFFU,		/* segment boundary */

	MRSAS_MAX_SGE_CNT,	/* dma_attr_sglen */

	512,			/* granularity of device */

	0			/* bus specific DMA flags */

};

int32_t mrsas_max_cap_maxxfer = 0x1000000;

/*

 * cb_ops contains base level routines

 */

static struct cb_ops mrsas_cb_ops = {

	mrsas_open,		/* open */

	mrsas_close,		/* close */

	nodev,			/* strategy */

	nodev,			/* print */

	nodev,			/* dump */

	nodev,			/* read */

	nodev,			/* write */

	mrsas_ioctl,		/* ioctl */

	nodev,			/* devmap */

	nodev,			/* mmap */

	nodev,			/* segmap */

	nochpoll,		/* poll */

	nodev,			/* cb_prop_op */

	0,			/* streamtab  */

	D_NEW | D_HOTPLUG,	/* cb_flag */

	CB_REV,			/* cb_rev */

	nodev,			/* cb_aread */

	nodev			/* cb_awrite */

};

/*

 * dev_ops contains configuration routines

 */

static struct dev_ops mrsas_ops = {

	DEVO_REV,		/* rev, */

	0,			/* refcnt */

	mrsas_getinfo,		/* getinfo */

	nulldev,		/* identify */

	nulldev,		/* probe */

	mrsas_attach,		/* attach */

	mrsas_detach,		/* detach */

#ifdef  __sparc

	mrsas_reset,		/* reset */

#else	/* __sparc */

	nodev,

#endif  /* __sparc */

	&mrsas_cb_ops,		/* char/block ops */

	NULL,			/* bus ops */

	NULL,			/* power */

#ifdef	__sparc

	ddi_quiesce_not_needed

#else	/* __sparc */

	mrsas_quiesce		/* quiesce */

#endif	/* __sparc */

};

static struct modldrv modldrv = {

	&mod_driverops,		/* module type - driver */

	MRSAS_VERSION,

	&mrsas_ops,		/* driver ops */

};

static struct modlinkage modlinkage = {

	MODREV_1,	/* ml_rev - must be MODREV_1 */

	&modldrv,	/* ml_linkage */

	NULL		/* end of driver linkage */

};

static struct ddi_device_acc_attr endian_attr = {

	DDI_DEVICE_ATTR_V1,

	DDI_STRUCTURE_LE_ACC,

	DDI_STRICTORDER_ACC,

	DDI_DEFAULT_ACC

};

/*

 * ************************************************************************** *

 *                                                                            *

 *         common entry points - for loadable kernel modules                  *

 *                                                                            *

 * ************************************************************************** *

 */

int

_init(void)

{

	int ret;

	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));

	ret = ddi_soft_state_init(&mrsas_state,

	    sizeof (struct mrsas_instance), 0);

	if (ret != DDI_SUCCESS) {

		con_log(CL_ANN, (CE_WARN, "mr_sas: could not init state"));

		return (ret);

	}

	if ((ret = scsi_hba_init(&modlinkage)) != DDI_SUCCESS) {

		con_log(CL_ANN, (CE_WARN, "mr_sas: could not init scsi hba"));

		ddi_soft_state_fini(&mrsas_state);

		return (ret);

	}

	ret = mod_install(&modlinkage);

	if (ret != DDI_SUCCESS) {

		con_log(CL_ANN, (CE_WARN, "mr_sas: mod_install failed"));

		scsi_hba_fini(&modlinkage);

		ddi_soft_state_fini(&mrsas_state);

	}

	return (ret);

}

int

_info(struct modinfo *modinfop)

{

	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));

	return (mod_info(&modlinkage, modinfop));

}

int

_fini(void)

{

	int ret;

	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));

	if ((ret = mod_remove(&modlinkage)) != DDI_SUCCESS)

		return (ret);

	scsi_hba_fini(&modlinkage);

	ddi_soft_state_fini(&mrsas_state);

	return (ret);

}

/*

 * ************************************************************************** *

 *                                                                            *

 *               common entry points - for autoconfiguration                  *

 *                                                                            *

 * ************************************************************************** *

 */

static int

mrsas_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)

{

	int		instance_no;

	int		nregs;

	uint8_t		added_isr_f = 0;

	uint8_t		added_soft_isr_f = 0;

	uint8_t		create_devctl_node_f = 0;

	uint8_t		create_scsi_node_f = 0;

	uint8_t		create_ioc_node_f = 0;

	uint8_t		tran_alloc_f = 0;

	uint8_t 	irq;

	uint16_t	vendor_id;

	uint16_t	device_id;

	uint16_t	subsysvid;

	uint16_t	subsysid;

	uint16_t	command;

	off_t		reglength = 0;

	int		intr_types = 0;

	char		*data;

	scsi_hba_tran_t		*tran;

	ddi_dma_attr_t  tran_dma_attr;

	struct mrsas_instance	*instance;

	con_log(CL_ANN1, (CE_NOTE, "chkpnt:%s:%d", __func__, __LINE__));

	/* CONSTCOND */

	ASSERT(NO_COMPETING_THREADS);

	instance_no = ddi_get_instance(dip);

	/*

	 * check to see whether this device is in a DMA-capable slot.

	 */

	if (ddi_slaveonly(dip) == DDI_SUCCESS) {

		con_log(CL_ANN, (CE_WARN,

		    "mr_sas%d: Device in slave-only slot, unused",

		    instance_no));

		return (DDI_FAILURE);

	}

	switch (cmd) {

		case DDI_ATTACH:

			con_log(CL_DLEVEL1, (CE_NOTE, "mr_sas: DDI_ATTACH"));

			/* allocate the soft state for the instance */

			if (ddi_soft_state_zalloc(mrsas_state, instance_no)

			    != DDI_SUCCESS) {

				con_log(CL_ANN, (CE_WARN,

				    "mr_sas%d: Failed to allocate soft state",

				    instance_no));

				return (DDI_FAILURE);

			}

			instance = (struct mrsas_instance *)ddi_get_soft_state

			    (mrsas_state, instance_no);

			if (instance == NULL) {

				con_log(CL_ANN, (CE_WARN,

				    "mr_sas%d: Bad soft state", instance_no));

				ddi_soft_state_free(mrsas_state, instance_no);

				return (DDI_FAILURE);

			}

			bzero((caddr_t)instance,

			    sizeof (struct mrsas_instance));

			instance->func_ptr = kmem_zalloc(

			    sizeof (struct mrsas_func_ptr), KM_SLEEP);

			ASSERT(instance->func_ptr);

			/* Setup the PCI configuration space handles */

			if (pci_config_setup(dip, &instance->pci_handle) !=

			    DDI_SUCCESS) {

				con_log(CL_ANN, (CE_WARN,

				    "mr_sas%d: pci config setup failed ",

				    instance_no));

				kmem_free(instance->func_ptr,

				    sizeof (struct mrsas_func_ptr));

				ddi_soft_state_free(mrsas_state, instance_no);

				return (DDI_FAILURE);

			}

			if (ddi_dev_nregs(dip, &nregs) != DDI_SUCCESS) {

				con_log(CL_ANN, (CE_WARN,

				    "mr_sas: failed to get registers."));

				pci_config_teardown(&instance->pci_handle);

				kmem_free(instance->func_ptr,

				    sizeof (struct mrsas_func_ptr));

				ddi_soft_state_free(mrsas_state, instance_no);

				return (DDI_FAILURE);

			}

			vendor_id = pci_config_get16(instance->pci_handle,

			    PCI_CONF_VENID);

			device_id = pci_config_get16(instance->pci_handle,

			    PCI_CONF_DEVID);

			subsysvid = pci_config_get16(instance->pci_handle,

			    PCI_CONF_SUBVENID);

			subsysid = pci_config_get16(instance->pci_handle,

			    PCI_CONF_SUBSYSID);

			pci_config_put16(instance->pci_handle, PCI_CONF_COMM,

			    (pci_config_get16(instance->pci_handle,

			    PCI_CONF_COMM) | PCI_COMM_ME));

			irq = pci_config_get8(instance->pci_handle,

			    PCI_CONF_ILINE);

			con_log(CL_DLEVEL1, (CE_CONT, "mr_sas%d: "

			    "0x%x:0x%x 0x%x:0x%x, irq:%d drv-ver:%s",

			    instance_no, vendor_id, device_id, subsysvid,

			    subsysid, irq, MRSAS_VERSION));

			/* enable bus-mastering */

			command = pci_config_get16(instance->pci_handle,

			    PCI_CONF_COMM);

			if (!(command & PCI_COMM_ME)) {

				command |= PCI_COMM_ME;

				pci_config_put16(instance->pci_handle,

				    PCI_CONF_COMM, command);

				con_log(CL_ANN, (CE_CONT, "mr_sas%d: "

				    "enable bus-mastering", instance_no));

			} else {

				con_log(CL_DLEVEL1, (CE_CONT, "mr_sas%d: "

				"bus-mastering already set", instance_no));

			}

			/* initialize function pointers */

			if ((device_id == PCI_DEVICE_ID_LSI_2108VDE) ||

			    (device_id == PCI_DEVICE_ID_LSI_2108V)) {

				con_log(CL_DLEVEL1, (CE_CONT, "mr_sas%d: "

				    "2108V/DE detected", instance_no));

				instance->func_ptr->read_fw_status_reg =

				    read_fw_status_reg_ppc;

				instance->func_ptr->issue_cmd = issue_cmd_ppc;

				instance->func_ptr->issue_cmd_in_sync_mode =

				    issue_cmd_in_sync_mode_ppc;

				instance->func_ptr->issue_cmd_in_poll_mode =

				    issue_cmd_in_poll_mode_ppc;

				instance->func_ptr->enable_intr =

				    enable_intr_ppc;

				instance->func_ptr->disable_intr =

				    disable_intr_ppc;

				instance->func_ptr->intr_ack = intr_ack_ppc;

			} else {

				con_log(CL_ANN, (CE_WARN,

				    "mr_sas: Invalid device detected"));

				pci_config_teardown(&instance->pci_handle);

				kmem_free(instance->func_ptr,

				    sizeof (struct mrsas_func_ptr));

				ddi_soft_state_free(mrsas_state, instance_no);

				return (DDI_FAILURE);

			}

			instance->baseaddress = pci_config_get32(

			    instance->pci_handle, PCI_CONF_BASE0);

			instance->baseaddress &= 0x0fffc;

			instance->dip		= dip;

			instance->vendor_id	= vendor_id;

			instance->device_id	= device_id;

			instance->subsysvid	= subsysvid;

			instance->subsysid	= subsysid;

			instance->instance	= instance_no;

			/* Initialize FMA */

			instance->fm_capabilities = ddi_prop_get_int(

			    DDI_DEV_T_ANY, instance->dip, DDI_PROP_DONTPASS,

			    "fm-capable", DDI_FM_EREPORT_CAPABLE |

			    DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE

			    | DDI_FM_ERRCB_CAPABLE);

			mrsas_fm_init(instance);

			/* Initialize Interrupts */

			if ((ddi_dev_regsize(instance->dip,

			    REGISTER_SET_IO_2108, &reglength) != DDI_SUCCESS) ||

			    reglength < MINIMUM_MFI_MEM_SZ) {

				return (DDI_FAILURE);

			}

			if (reglength > DEFAULT_MFI_MEM_SZ) {

				reglength = DEFAULT_MFI_MEM_SZ;

				con_log(CL_DLEVEL1, (CE_NOTE,

				    "mr_sas: register length to map is "

				    "0x%lx bytes", reglength));

			}

			if (ddi_regs_map_setup(instance->dip,

			    REGISTER_SET_IO_2108, &instance->regmap, 0,

			    reglength, &endian_attr, &instance->regmap_handle)

			    != DDI_SUCCESS) {

				con_log(CL_ANN, (CE_NOTE,

				    "mr_sas: couldn't map control registers"));

				goto fail_attach;

			}

			/*

			 * Disable Interrupt Now.

			 * Setup Software interrupt

			 */

			instance->func_ptr->disable_intr(instance);

			if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,

			    "mrsas-enable-msi", &data) == DDI_SUCCESS) {

				if (strncmp(data, "no", 3) == 0) {

					msi_enable = 0;

					con_log(CL_ANN1, (CE_WARN,

					    "msi_enable = %d disabled",

					    msi_enable));

				}

				ddi_prop_free(data);

			}

			con_log(CL_DLEVEL1, (CE_WARN, "msi_enable = %d",

			    msi_enable));

			/* Check for all supported interrupt types */

			if (ddi_intr_get_supported_types(

			    dip, &intr_types) != DDI_SUCCESS) {

				con_log(CL_ANN, (CE_WARN,

				    "ddi_intr_get_supported_types() failed"));

				goto fail_attach;

			}

			con_log(CL_DLEVEL1, (CE_NOTE,

			    "ddi_intr_get_supported_types() ret: 0x%x",

			    intr_types));

			/* Initialize and Setup Interrupt handler */

			if (msi_enable && (intr_types & DDI_INTR_TYPE_MSIX)) {

				if (mrsas_add_intrs(instance,

				    DDI_INTR_TYPE_MSIX) != DDI_SUCCESS) {

					con_log(CL_ANN, (CE_WARN,

					    "MSIX interrupt query failed"));

					goto fail_attach;

				}

				instance->intr_type = DDI_INTR_TYPE_MSIX;

			} else if (msi_enable && (intr_types &

			    DDI_INTR_TYPE_MSI)) {

				if (mrsas_add_intrs(instance,

				    DDI_INTR_TYPE_MSI) != DDI_SUCCESS) {

					con_log(CL_ANN, (CE_WARN,

					    "MSI interrupt query failed"));

					goto fail_attach;

				}

				instance->intr_type = DDI_INTR_TYPE_MSI;

			} else if (intr_types & DDI_INTR_TYPE_FIXED) {

				msi_enable = 0;