/*

 * 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

 */

/*

 *

 * NOT a DDI compliant Sun Fibre Channel port driver(fp)

 *

 */

#include <sys/types.h>

#include <sys/varargs.h>

#include <sys/param.h>

#include <sys/errno.h>

#include <sys/uio.h>

#include <sys/buf.h>

#include <sys/modctl.h>

#include <sys/open.h>

#include <sys/file.h>

#include <sys/kmem.h>

#include <sys/poll.h>

#include <sys/conf.h>

#include <sys/thread.h>

#include <sys/var.h>

#include <sys/cmn_err.h>

#include <sys/stat.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#include <sys/promif.h>

#include <sys/nvpair.h>

#include <sys/byteorder.h>

#include <sys/scsi/scsi.h>

#include <sys/fibre-channel/fc.h>

#include <sys/fibre-channel/impl/fc_ulpif.h>

#include <sys/fibre-channel/impl/fc_fcaif.h>

#include <sys/fibre-channel/impl/fctl_private.h>

#include <sys/fibre-channel/impl/fc_portif.h>

#include <sys/fibre-channel/impl/fp.h>

/* These are defined in fctl.c! */

extern int did_table_size;

extern int pwwn_table_size;

static struct cb_ops fp_cb_ops = {

	fp_open,			/* open */

	fp_close,			/* close */

	nodev,				/* strategy */

	nodev,				/* print */

	nodev,				/* dump */

	nodev,				/* read */

	nodev,				/* write */

	fp_ioctl,			/* ioctl */

	nodev,				/* devmap */

	nodev,				/* mmap */

	nodev,				/* segmap */

	nochpoll,			/* chpoll */

	ddi_prop_op,			/* cb_prop_op */

	0,				/* streamtab */

	D_NEW | D_MP | D_HOTPLUG,	/* cb_flag */

	CB_REV,				/* rev */

	nodev,				/* aread */

	nodev				/* awrite */

};

static struct dev_ops fp_ops = {

	DEVO_REV,			/* build revision */

	0,				/* reference count */

	fp_getinfo,			/* getinfo */

	nulldev,			/* identify - Obsoleted */

	nulldev,			/* probe */

	fp_attach,			/* attach */

	fp_detach,			/* detach */

	nodev,				/* reset */

	&fp_cb_ops,			/* cb_ops */

	NULL,				/* bus_ops */

	fp_power,			/* power */

	ddi_quiesce_not_needed 		/* quiesce */

};

#define	FP_VERSION		"20091123-1.101"

#define	FP_NAME_VERSION		"SunFC Port v" FP_VERSION

char *fp_version = FP_NAME_VERSION;

static struct modldrv modldrv = {

	&mod_driverops,			/* Type of Module */

	FP_NAME_VERSION,		/* Name/Version of fp */

	&fp_ops				/* driver ops */

};

static struct modlinkage modlinkage = {

	MODREV_1,	/* Rev of the loadable modules system */

	&modldrv,	/* NULL terminated list of */

	NULL		/* Linkage structures */

};

static uint16_t ns_reg_cmds[] = {

	NS_RPN_ID,

	NS_RNN_ID,

	NS_RCS_ID,

	NS_RFT_ID,

	NS_RPT_ID,

	NS_RSPN_ID,

	NS_RSNN_NN

};

struct fp_xlat {

	uchar_t	xlat_state;

	int	xlat_rval;

} fp_xlat [] = {

	{ FC_PKT_SUCCESS,	FC_SUCCESS },

	{ FC_PKT_REMOTE_STOP,	FC_FAILURE },

	{ FC_PKT_LOCAL_RJT,	FC_FAILURE },

	{ FC_PKT_NPORT_RJT,	FC_ELS_PREJECT },

	{ FC_PKT_FABRIC_RJT,	FC_ELS_FREJECT },

	{ FC_PKT_LOCAL_BSY,	FC_TRAN_BUSY },

	{ FC_PKT_TRAN_BSY,	FC_TRAN_BUSY },

	{ FC_PKT_NPORT_BSY,	FC_PBUSY },

	{ FC_PKT_FABRIC_BSY,	FC_FBUSY },

	{ FC_PKT_LS_RJT,	FC_FAILURE },

	{ FC_PKT_BA_RJT,	FC_FAILURE },

	{ FC_PKT_TIMEOUT,	FC_FAILURE },

	{ FC_PKT_TRAN_ERROR,	FC_TRANSPORT_ERROR },

	{ FC_PKT_FAILURE,	FC_FAILURE },

	{ FC_PKT_PORT_OFFLINE,	FC_OFFLINE }

};

static uchar_t fp_valid_alpas[] = {

	0x01, 0x02, 0x04, 0x08, 0x0F, 0x10, 0x17, 0x18, 0x1B,

	0x1D, 0x1E, 0x1F, 0x23, 0x25, 0x26, 0x27, 0x29, 0x2A,

	0x2B, 0x2C, 0x2D, 0x2E, 0x31, 0x32, 0x33, 0x34, 0x35,

	0x36, 0x39, 0x3A, 0x3C, 0x43, 0x45, 0x46, 0x47, 0x49,

	0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x51, 0x52, 0x53, 0x54,

	0x55, 0x56, 0x59, 0x5A, 0x5C, 0x63, 0x65, 0x66, 0x67,

	0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73,

	0x74, 0x75, 0x76, 0x79, 0x7A, 0x7C, 0x80, 0x81, 0x82,

	0x84, 0x88, 0x8F, 0x90, 0x97, 0x98, 0x9B, 0x9D, 0x9E,

	0x9F, 0xA3, 0xA5, 0xA6, 0xA7, 0xA9, 0xAA, 0xAB, 0xAC,

	0xAD, 0xAE, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB9,

	0xBA, 0xBC, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB,

	0xCC, 0xCD, 0xCE, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,

	0xD9, 0xDA, 0xDC, 0xE0, 0xE1, 0xE2, 0xE4, 0xE8, 0xEF

};

static struct fp_perms {

	uint16_t	fp_ioctl_cmd;

	uchar_t		fp_open_flag;

} fp_perm_list [] = {

	{ FCIO_GET_NUM_DEVS,		FP_OPEN },

	{ FCIO_GET_DEV_LIST,		FP_OPEN },

	{ FCIO_GET_SYM_PNAME,		FP_OPEN },

	{ FCIO_GET_SYM_NNAME,		FP_OPEN },

	{ FCIO_SET_SYM_PNAME,		FP_EXCL },

	{ FCIO_SET_SYM_NNAME,		FP_EXCL },

	{ FCIO_GET_LOGI_PARAMS,		FP_OPEN },

	{ FCIO_DEV_LOGIN,		FP_EXCL },

	{ FCIO_DEV_LOGOUT,		FP_EXCL },

	{ FCIO_GET_STATE,		FP_OPEN },

	{ FCIO_DEV_REMOVE,		FP_EXCL },

	{ FCIO_GET_FCODE_REV,		FP_OPEN },

	{ FCIO_GET_FW_REV,		FP_OPEN },

	{ FCIO_GET_DUMP_SIZE,		FP_OPEN },

	{ FCIO_FORCE_DUMP,		FP_EXCL },

	{ FCIO_GET_DUMP,		FP_OPEN },

	{ FCIO_GET_TOPOLOGY,		FP_OPEN },

	{ FCIO_RESET_LINK,		FP_EXCL },

	{ FCIO_RESET_HARD,		FP_EXCL },

	{ FCIO_RESET_HARD_CORE,		FP_EXCL },

	{ FCIO_DIAG,			FP_OPEN },

	{ FCIO_NS,			FP_EXCL },

	{ FCIO_DOWNLOAD_FW,		FP_EXCL },

	{ FCIO_DOWNLOAD_FCODE,		FP_EXCL },

	{ FCIO_LINK_STATUS,		FP_OPEN },

	{ FCIO_GET_HOST_PARAMS,		FP_OPEN },

	{ FCIO_GET_NODE_ID,		FP_OPEN },

	{ FCIO_SET_NODE_ID,		FP_EXCL },

	{ FCIO_SEND_NODE_ID,		FP_OPEN },

	{ FCIO_GET_ADAPTER_ATTRIBUTES,	FP_OPEN },

	{ FCIO_GET_OTHER_ADAPTER_PORTS,	FP_OPEN },

	{ FCIO_GET_ADAPTER_PORT_ATTRIBUTES,	FP_OPEN },

	{ FCIO_GET_DISCOVERED_PORT_ATTRIBUTES,	FP_OPEN },

	{ FCIO_GET_PORT_ATTRIBUTES,	FP_OPEN },

	{ FCIO_GET_ADAPTER_PORT_STATS,	FP_OPEN },

	{ FCIO_GET_ADAPTER_PORT_NPIV_ATTRIBUTES, FP_OPEN },

	{ FCIO_GET_NPIV_PORT_LIST, FP_OPEN },

	{ FCIO_DELETE_NPIV_PORT, FP_OPEN },

	{ FCIO_GET_NPIV_ATTRIBUTES, FP_OPEN },

	{ FCIO_CREATE_NPIV_PORT, FP_OPEN },

	{ FCIO_NPIV_GET_ADAPTER_ATTRIBUTES, FP_OPEN }

};

static char *fp_pm_comps[] = {

	"NAME=FC Port",

	"0=Port Down",

	"1=Port Up"

};

#ifdef	_LITTLE_ENDIAN

#define	MAKE_BE_32(x)	{						\

		uint32_t	*ptr1, i;				\

		ptr1 = (uint32_t *)(x);					\

		for (i = 0; i < sizeof (*(x)) / sizeof (uint32_t); i++) { \

			*ptr1 = BE_32(*ptr1);				\

			ptr1++;						\

		}							\

	}

#else

#define	MAKE_BE_32(x)

#endif

static uchar_t fp_verbosity = (FP_WARNING_MESSAGES | FP_FATAL_MESSAGES);

static uint32_t fp_options = 0;

static int fp_cmd_wait_cnt = FP_CMDWAIT_DELAY;

static int fp_retry_delay = FP_RETRY_DELAY;	/* retry after this delay */

static int fp_retry_count = FP_RETRY_COUNT;	/* number of retries */

unsigned int fp_offline_ticker;			/* seconds */

/*

 * Driver global variable to anchor the list of soft state structs for

 * all fp driver instances.  Used with the Solaris DDI soft state functions.

 */

static void *fp_driver_softstate;

static clock_t	fp_retry_ticks;

static clock_t	fp_offline_ticks;

static int fp_retry_ticker;

static uint32_t fp_unsol_buf_count = FP_UNSOL_BUF_COUNT;

static uint32_t fp_unsol_buf_size = FP_UNSOL_BUF_SIZE;

static int		fp_log_size = FP_LOG_SIZE;

static int		fp_trace = FP_TRACE_DEFAULT;

static fc_trace_logq_t	*fp_logq = NULL;

int fp_get_adapter_paths(char *pathList, int count);

static void fp_log_port_event(fc_local_port_t *port, char *subclass);

static void fp_log_target_event(fc_local_port_t *port, char *subclass,

    la_wwn_t tgt_pwwn, uint32_t port_id);

static uint32_t fp_map_remote_port_state(uint32_t rm_state);

static void fp_init_symbolic_names(fc_local_port_t *port);

/*

 * Perform global initialization

 */

int

_init(void)

{

	int ret;

	if ((ret = ddi_soft_state_init(&fp_driver_softstate,

	    sizeof (struct fc_local_port), 8)) != 0) {

		return (ret);

	}

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

		ddi_soft_state_fini(&fp_driver_softstate);

		return (ret);

	}

	fp_logq = fc_trace_alloc_logq(fp_log_size);

	if ((ret = mod_install(&modlinkage)) != 0) {

		fc_trace_free_logq(fp_logq);

		ddi_soft_state_fini(&fp_driver_softstate);

		scsi_hba_fini(&modlinkage);

	}

	return (ret);

}

/*

 * Prepare for driver unload

 */

int

_fini(void)

{

	int ret;

	if ((ret = mod_remove(&modlinkage)) == 0) {

		fc_trace_free_logq(fp_logq);

		ddi_soft_state_fini(&fp_driver_softstate);

		scsi_hba_fini(&modlinkage);

	}

	return (ret);

}

/*

 * Request mod_info() to handle all cases

 */

int

_info(struct modinfo *modinfo)

{

	return (mod_info(&modlinkage, modinfo));

}

/*

 * fp_attach:

 *

 * The respective cmd handlers take care of performing

 * ULP related invocations

 */

static int

fp_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)

{

	int rval;

	/*

	 * We check the value of fp_offline_ticker at this

	 * point. The variable is global for the driver and

	 * not specific to an instance.

	 *

	 * If there is no user-defined value found in /etc/system

	 * or fp.conf, then we use 90 seconds (FP_OFFLINE_TICKER).

	 * The minimum setting for this offline timeout according

	 * to the FC-FS2 standard (Fibre Channel Framing and

	 * Signalling-2, see www.t11.org) is R_T_TOV == 100msec.

	 *

	 * We do not recommend setting the value to less than 10

	 * seconds (RA_TOV) or more than 90 seconds. If this

	 * variable is greater than 90 seconds then drivers above

	 * fp (fcp, sd, scsi_vhci, vxdmp et al) might complain.

	 */

	fp_offline_ticker = ddi_prop_get_int(DDI_DEV_T_ANY,

	    dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "fp_offline_ticker",

	    FP_OFFLINE_TICKER);

	if ((fp_offline_ticker < 10) ||

	    (fp_offline_ticker > 90)) {

		cmn_err(CE_WARN, "Setting fp_offline_ticker to "

		    "%d second(s). This is outside the "

		    "recommended range of 10..90 seconds",

		    fp_offline_ticker);

	}

	/*

	 * Tick every second when there are commands to retry.

	 * It should tick at the least granular value of pkt_timeout

	 * (which is one second)

	 */

	fp_retry_ticker = 1;

	fp_retry_ticks = drv_usectohz(fp_retry_ticker * 1000 * 1000);

	fp_offline_ticks = drv_usectohz(fp_offline_ticker * 1000 * 1000);

	switch (cmd) {

	case DDI_ATTACH:

		rval = fp_attach_handler(dip);

		break;

	case DDI_RESUME:

		rval = fp_resume_handler(dip);

		break;

	default:

		rval = DDI_FAILURE;

		break;

	}

	return (rval);

}

/*

 * fp_detach:

 *

 * If a ULP fails to handle cmd request converse of

 * cmd is invoked for ULPs that previously succeeded

 * cmd request.

 */

static int

fp_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)

{

	int			rval = DDI_FAILURE;

	fc_local_port_t		*port;

	fc_attach_cmd_t		converse;

	uint8_t			cnt;

	if ((port = ddi_get_soft_state(fp_driver_softstate,

	    ddi_get_instance(dip))) == NULL) {

		return (DDI_FAILURE);

	}

	mutex_enter(&port->fp_mutex);

	if (port->fp_ulp_attach) {

		mutex_exit(&port->fp_mutex);

		return (DDI_FAILURE);

	}

	switch (cmd) {

	case DDI_DETACH:

		if (port->fp_task != FP_TASK_IDLE) {

			mutex_exit(&port->fp_mutex);

			return (DDI_FAILURE);

		}

		/* Let's attempt to quit the job handler gracefully */

		port->fp_soft_state |= FP_DETACH_INPROGRESS;

		mutex_exit(&port->fp_mutex);

		converse = FC_CMD_ATTACH;

		if (fctl_detach_ulps(port, FC_CMD_DETACH,

		    &modlinkage) != FC_SUCCESS) {

			mutex_enter(&port->fp_mutex);

			port->fp_soft_state &= ~FP_DETACH_INPROGRESS;

			mutex_exit(&port->fp_mutex);

			rval = DDI_FAILURE;

			break;

		}

		mutex_enter(&port->fp_mutex);

		for (cnt = 0; (port->fp_job_head) && (cnt < fp_cmd_wait_cnt);

		    cnt++) {

			mutex_exit(&port->fp_mutex);

			delay(drv_usectohz(1000000));

			mutex_enter(&port->fp_mutex);

		}

		if (port->fp_job_head) {

			mutex_exit(&port->fp_mutex);

			rval = DDI_FAILURE;

			break;

		}

		mutex_exit(&port->fp_mutex);

		rval = fp_detach_handler(port);

		break;

	case DDI_SUSPEND:

		mutex_exit(&port->fp_mutex);

		converse = FC_CMD_RESUME;

		if (fctl_detach_ulps(port, FC_CMD_SUSPEND,

		    &modlinkage) != FC_SUCCESS) {

			rval = DDI_FAILURE;

			break;

		}

		if ((rval = fp_suspend_handler(port)) != DDI_SUCCESS) {

			(void) callb_generic_cpr(&port->fp_cpr_info,

			    CB_CODE_CPR_RESUME);

		}

		break;

	default:

		mutex_exit(&port->fp_mutex);

		break;

	}

	/*

	 * Use softint to perform reattach.  Mark fp_ulp_attach so we

	 * don't attempt to do this repeatedly on behalf of some persistent

	 * caller.

	 */

	if (rval != DDI_SUCCESS) {

		mutex_enter(&port->fp_mutex);

		port->fp_ulp_attach = 1;

		/*

		 * If the port is in the low power mode then there is

		 * possibility that fca too could be in low power mode.

		 * Try to raise the power before calling attach ulps.

		 */

		if ((port->fp_soft_state & FP_SOFT_POWER_DOWN) &&

		    (!(port->fp_soft_state & FP_SOFT_NO_PMCOMP))) {

			mutex_exit(&port->fp_mutex);

			(void) pm_raise_power(port->fp_port_dip,

			    FP_PM_COMPONENT, FP_PM_PORT_UP);

		} else {

			mutex_exit(&port->fp_mutex);

		}

		fp_attach_ulps(port, converse);

		mutex_enter(&port->fp_mutex);

		while (port->fp_ulp_attach) {

			cv_wait(&port->fp_attach_cv, &port->fp_mutex);

		}

		port->fp_soft_state &= ~FP_DETACH_INPROGRESS;

		/*

		 * Mark state as detach failed so asynchronous ULP attach

		 * events (downstream, not the ones we're initiating with

		 * the call to fp_attach_ulps) are not honored.	 We're

		 * really still in pending detach.

		 */

		port->fp_soft_state |= FP_DETACH_FAILED;

		mutex_exit(&port->fp_mutex);

	}

	return (rval);

}

/*

 * fp_getinfo:

 *   Given the device number, return either the

 *   dev_info_t pointer or the instance number.