/*

 * 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 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/conf.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#include <sys/modctl.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <sys/ib/clients/iser/iser.h>

/*

 * iser.c

 *    DDI and core routines for Solaris iSER implementation.

 */

iser_state_t	*iser_state = NULL;	/* global state */

ddi_taskq_t	*iser_taskq = NULL;	/* global taskq */

/* set B_TRUE for console logging */

boolean_t iser_logging = B_FALSE;

/* Driver functions */

static int iser_attach(dev_info_t *, ddi_attach_cmd_t);

static int iser_detach(dev_info_t *, ddi_detach_cmd_t);

static int iser_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);

static int iser_open(dev_t *, int, int, cred_t *);

static int iser_close(dev_t, int, int, cred_t *);

static int iser_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

/* static int iser_close(dev_t, int, int, cred_t *); */

/* Char/Block operations */

static struct cb_ops	iser_cb_ops = {

	iser_open,		/* open */

	iser_close,		/* close */

	nodev,			/* strategy */

	nodev,			/* print */

	nodev,			/* dump */

	nodev,			/* read */

	nodev,			/* write */

	iser_ioctl,		/* ioctl */

	nodev,			/* devmap */

	nodev,			/* mmap */

	nodev,			/* segmap */

	nochpoll,		/* poll */

	ddi_prop_op,		/* prop_op */

	NULL,			/* stream */

	D_MP,			/* cb_flag */

	CB_REV,			/* rev */

	nodev,			/* int (*cb_aread)() */

	nodev,			/* int (*cb_awrite)() */

};

/* Device operations */

static struct dev_ops iser_ops = {

	DEVO_REV,		/* devo_rev, */

	0,			/* refcnt  */

	iser_getinfo,		/* getinfo */

	nulldev,		/* identify */

	nulldev,		/* probe */

	iser_attach,		/* attach */

	iser_detach,		/* detach */

	nodev,			/* reset */

	&iser_cb_ops,		/* cb_ops */

	NULL,			/* bus ops */

	NULL,			/* power */

	ddi_quiesce_not_needed	/* quiesce */

};

/* Module Driver Info */

#define	ISER_NAME_VERSION	"iSCSI Extensions for RDMA"

static struct modldrv iser_modldrv = {

	&mod_driverops,

	ISER_NAME_VERSION,

	&iser_ops,

};

/* Module Linkage */

static struct modlinkage iser_modlinkage = {

	MODREV_1,

	&iser_modldrv,

	NULL

};

/*

 * _init()

 */

int

_init(void)

{

	int	status;

	iser_state = kmem_zalloc(sizeof (iser_state_t), KM_SLEEP);

	status = mod_install(&iser_modlinkage);

	if (status != DDI_SUCCESS) {

		kmem_free(iser_state, sizeof (iser_state_t));

	}

	return (status);

}

/*

 * _info()

 */

int

_info(struct modinfo *modinfop)

{

	return (mod_info(&iser_modlinkage, modinfop));

}

/*

 * _fini()

 */

int

_fini(void)

{

	int status;

	status = mod_remove(&iser_modlinkage);

	if (status != DDI_SUCCESS) {

		return (status);

	}

	kmem_free(iser_state, sizeof (iser_state_t));

	return (DDI_SUCCESS);

}

/*

 * iser_attach()

 */

static int

iser_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)

{

	int		instance;

	int		status;

	switch (cmd) {

	case DDI_ATTACH:

		ISER_LOG(CE_CONT, "iser_attach: DDI_ATTACH");

		instance = ddi_get_instance(dip);

		iser_state->is_dip = dip;

		iser_state->is_instance = instance;

		/* Initialize the open refcnt and it's lock */

		iser_state->is_open_refcnt = 0;

		mutex_init(&iser_state->is_refcnt_lock, NULL, MUTEX_DRIVER,

		    NULL);

		iser_taskq = ddi_taskq_create(dip, "iser_taskq",

		    ISER_TASKQ_NTHREADS, TASKQ_DEFAULTPRI, 0);

		if (iser_taskq == NULL) {

			ISER_LOG(CE_CONT, "%s%d: failed to create taskq",

			    "iser", instance);

			mutex_destroy(&iser_state->is_refcnt_lock);

			return (DDI_FAILURE);

		}

		/* initialize iSER as IB service */

		status = iser_ib_init();

		if (status != DDI_SUCCESS) {

			ddi_taskq_destroy(iser_taskq);

			mutex_destroy(&iser_state->is_refcnt_lock);

			ISER_LOG(CE_CONT, "%s%d: failed to initialize IB",

			    "iser", instance);

			return (DDI_FAILURE);

		}

		status = ddi_create_minor_node(

		    dip, ddi_get_name(dip), S_IFCHR, instance,

		    DDI_PSEUDO, 0);

		if (status != DDI_SUCCESS) {

			(void) iser_ib_fini();

			ddi_taskq_destroy(iser_taskq);

			mutex_destroy(&iser_state->is_refcnt_lock);

			ISER_LOG(CE_CONT, "%s%d: failed ddi_create_minor_node",

			    "iser", instance);

			return (DDI_FAILURE);

		}

		ddi_report_dev(dip);

		return (DDI_SUCCESS);

	case DDI_RESUME:

		ISER_LOG(CE_CONT, "iser_detach: DDI_RESUME unsupported");

		return (DDI_FAILURE);

	default:

		ISER_LOG(CE_CONT, "%s%d: unknown cmd in attach (0x%x)", "iser",

		    instance, cmd);

		return (DDI_FAILURE);

	}

}

/*

 * iser_detach()

 */

static int

iser_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)

{

	mutex_enter(&iser_state->is_refcnt_lock);

	if (iser_state->is_open_refcnt > 0) {

		mutex_exit(&iser_state->is_refcnt_lock);

		return (DDI_FAILURE);

	}

	mutex_exit(&iser_state->is_refcnt_lock);

	mutex_destroy(&iser_state->is_refcnt_lock);

	switch (cmd) {

	case DDI_DETACH:

		ISER_LOG(CE_CONT, "iser_detach: DDI_DETACH");

		if (iser_ib_fini() != DDI_SUCCESS) {

			ISER_LOG(CE_CONT, "iser_ib_fini failed");

			return (DDI_FAILURE);

		}

		if (iser_taskq != NULL) {

			ddi_taskq_destroy(iser_taskq);

			iser_taskq = NULL;

		}

		ddi_remove_minor_node(dip, NULL);

		return (DDI_SUCCESS);

	case DDI_SUSPEND:

		ISER_LOG(CE_CONT, "iser_detach: DDI_SUSPEND unsupported");

		return (DDI_FAILURE);

	default:

		ISER_LOG(CE_CONT, "iser: unknown cmd in detach (0x%x)", cmd);

		return (DDI_FAILURE);

	}

}

/*

 * iser_getinfo()

 */

/* ARGSUSED */

static int

iser_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)

{

	switch (cmd) {

	case DDI_INFO_DEVT2DEVINFO:

		*result = (void *)iser_state->is_dip;

		return (DDI_SUCCESS);

	case DDI_INFO_DEVT2INSTANCE:

		*result = NULL;

		return (DDI_SUCCESS);

	default:

		return (DDI_FAILURE);

	}

}

/*

 * iser_open()

 */

/* ARGSUSED */

static int

iser_open(dev_t *devp, int flag, int otyp, cred_t *credp)

{

	minor_t		instance;

	int		status;

	instance = getminor(*devp);

	/* Register the transport with IDM */

	status = iser_idm_register();

	if (status != DDI_SUCCESS) {

		ISER_LOG(CE_CONT, "%s%d: failed to register with IDM",

		    "iser", instance);

		return (ENXIO);

	}

	/* Increment our open refcnt */

	mutex_enter(&iser_state->is_refcnt_lock);

	iser_state->is_open_refcnt++;

	mutex_exit(&iser_state->is_refcnt_lock);

	return (DDI_SUCCESS);

}

/*

 * iser_close()

 */

/* ARGSUSED */

static int

iser_close(dev_t devp, int flag, int otyp, cred_t *credp)

{

	ASSERT(iser_state->is_open_refcnt != 0);

	mutex_enter(&iser_state->is_refcnt_lock);

	iser_state->is_open_refcnt--;

	mutex_exit(&iser_state->is_refcnt_lock);

	return (DDI_SUCCESS);

}

iser_status_t

iser_register_service(idm_svc_t *idm_svc)

{

	return (iser_ib_register_service(idm_svc));

}

iser_status_t

iser_bind_service(idm_svc_t *idm_svc)

{

	return (iser_ib_bind_service(idm_svc));

}

void

iser_unbind_service(idm_svc_t *idm_svc)

{

	iser_ib_unbind_service(idm_svc);

}

void

iser_deregister_service(idm_svc_t *idm_svc)

{

	iser_ib_deregister_service(idm_svc);

}

/*

 * iser_path_exists

 * This function takes in a pair of endpoints and determines if an iSER path

 * exists between the two. The actual path information (required for creating

 * a RC channel) is not returned, instead a boolean value indicating if a path

 * exists is returned.

 *

 * To use an implicit source, a value of NULL is allowed for laddr.

 */

boolean_t

iser_path_exists(idm_sockaddr_t *laddr, idm_sockaddr_t *raddr)

{

	ibt_ip_addr_t		remote_ip, local_ip;

	ibt_path_info_t		path;

	int			status;

	iser_ib_conv_sockaddr2ibtaddr(raddr, &remote_ip);

	iser_ib_conv_sockaddr2ibtaddr(laddr, &local_ip);

	status = iser_ib_get_paths(&local_ip, &remote_ip, &path, NULL);

	return ((status == IBT_SUCCESS) ? B_TRUE : B_FALSE);

}

/*

 * iser_channel_alloc

 * This function allocates a reliable communication channel between the

 * given endpoints.

 */

iser_chan_t *

iser_channel_alloc(idm_sockaddr_t *laddr, idm_sockaddr_t *raddr)

{

	ibt_ip_addr_t		remote_ip, local_ip;

	iser_ib_conv_sockaddr2ibtaddr(raddr, &remote_ip);

	iser_ib_conv_sockaddr2ibtaddr(laddr, &local_ip);

	return (iser_ib_alloc_rc_channel(&local_ip, &remote_ip));

}

/*

 * iser_channel_open

 * This function opens the already allocated communication channel between the

 * two endpoints.

 */

iser_status_t

iser_channel_open(iser_chan_t *chan)

{

	return (iser_ib_open_rc_channel(chan));

}

/*

 * iser_channel_close

 * This function closes the already opened communication channel between the

 * two endpoints.

 */

void

iser_channel_close(iser_chan_t *chan)

{

	iser_ib_close_rc_channel(chan);

}

/*

 * iser_channel_free

 * This function frees the channel between the given endpoints

 */

void

iser_channel_free(iser_chan_t *chan)

{

	iser_ib_free_rc_channel(chan);

}

/* ARGSUSED */

static int

iser_ioctl(dev_t devp, int cmd, intptr_t arg, int mode, cred_t *credp,

    int *rvalp)

{

	return (DDI_SUCCESS);

}