/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * srn	Provide apm-like interfaces to Xorg
 */

#include <sys/types.h>
#include <sys/errno.h>
#include <sys/modctl.h>
#include <sys/conf.h>		/* driver flags and functions */
#include <sys/open.h>		/* OTYP_CHR definition */
#include <sys/stat.h>		/* S_IFCHR definition */
#include <sys/pathname.h>	/* name -> dev_info xlation */
#include <sys/kmem.h>		/* memory alloc stuff */
#include <sys/debug.h>
#include <sys/pm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/epm.h>
#include <sys/vfs.h>
#include <sys/mode.h>
#include <sys/mkdev.h>
#include <sys/promif.h>
#include <sys/consdev.h>
#include <sys/ddi_impldefs.h>
#include <sys/poll.h>
#include <sys/note.h>
#include <sys/taskq.h>
#include <sys/policy.h>
#include <sys/srn.h>

/*
 * Minor number is instance<<8 + clone minor from range 1-255;
 * But only one will be allocated
 */
#define	SRN_MINOR_TO_CLONE(minor) ((minor) & (SRN_MAX_CLONE - 1))
#define	SU		0x002
#define	SG		0x004

extern kmutex_t	srn_clone_lock;	/* protects srn_clones array */
extern kcondvar_t srn_clones_cv[SRN_MAX_CLONE];
extern uint_t	srn_poll_cnt[SRN_MAX_CLONE];

/*
 * The soft state of the srn driver.  Since there will only be
 * one of these, just reference it through a static struct.
 */
static struct srnstate {
	dev_info_t	*srn_dip;		/* ptr to our dev_info node */
	int		srn_instance;		/* for ddi_get_instance() */
	uchar_t		srn_clones[SRN_MAX_CLONE]; /* unique opens	*/
	struct cred	*srn_cred[SRN_MAX_CLONE]; /* cred for each open	*/
	int		srn_type[SRN_MAX_CLONE]; /* type of handshake */
	int		srn_delivered[SRN_MAX_CLONE];
	srn_event_info_t srn_pending[SRN_MAX_CLONE];
} srn = { NULL, -1};
typedef struct srnstate *srn_state_t;

kcondvar_t	srn_clones_cv[SRN_MAX_CLONE];
uint_t		srn_poll_cnt[SRN_MAX_CLONE];	/* count of events for poll */
int		srn_apm_count;
int		srn_autosx_count;
struct pollhead	srn_pollhead[SRN_MAX_CLONE];

static int	srn_open(dev_t *, int, int, cred_t *);
static int	srn_close(dev_t, int, int, cred_t *);
static int	srn_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
static int	srn_chpoll(dev_t, short, int, short *, struct pollhead **);

static struct cb_ops srn_cb_ops = {
	srn_open,	/* open */
	srn_close,	/* close */
	nodev,		/* strategy */
	nodev,		/* print */
	nodev,		/* dump */
	nodev,		/* read */
	nodev,		/* write */
	srn_ioctl,	/* ioctl */
	nodev,		/* devmap */
	nodev,		/* mmap */
	nodev,		/* segmap */
	srn_chpoll,	/* poll */
	ddi_prop_op,	/* prop_op */
	NULL,		/* streamtab */
	D_NEW | D_MP	/* driver compatibility flag */
};

static int srn_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
    void **result);
static int srn_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int srn_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static void srn_notify(int type, int event);

static struct dev_ops srn_ops = {
	DEVO_REV,		/* devo_rev */
	0,			/* refcnt */
	srn_getinfo,		/* info */
	nulldev,		/* identify */
	nulldev,		/* probe */
	srn_attach,		/* attach */
	srn_detach,		/* detach */
	nodev,			/* reset */
	&srn_cb_ops,		/* driver operations */
	NULL,			/* bus operations */
	NULL,			/* power */
	ddi_quiesce_not_needed,		/* quiesce */
};

static struct modldrv modldrv = {
	&mod_driverops,
	"srn driver",
	&srn_ops
};

static struct modlinkage modlinkage = {
	MODREV_1, &modldrv, 0
};

/* Local functions */

int
_init(void)
{
	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

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

static int
srn_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int		i;
	extern void (*srn_signal)(int, int);

	switch (cmd) {

	case DDI_ATTACH:
		if (srn.srn_instance != -1)	/* Only allow one instance */
			return (DDI_FAILURE);
		srn.srn_instance = ddi_get_instance(dip);
		if (ddi_create_minor_node(dip, "srn", S_IFCHR,
		    (srn.srn_instance << 8) + 0, DDI_PSEUDO, 0)
		    != DDI_SUCCESS) {
			return (DDI_FAILURE);
		}
		srn.srn_dip = dip;	/* srn_init and getinfo depend on it */

		for (i = 0; i < SRN_MAX_CLONE; i++)
			cv_init(&srn_clones_cv[i], NULL, CV_DEFAULT, NULL);

		srn.srn_instance = ddi_get_instance(dip);
		mutex_enter(&srn_clone_lock);
		srn_signal = srn_notify;
		mutex_exit(&srn_clone_lock);
		ddi_report_dev(dip);
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}

/* ARGSUSED */
static int
srn_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int i;
	extern int srn_inuse;
	extern void (*srn_signal)(int, int);

	switch (cmd) {
	case DDI_DETACH:

		mutex_enter(&srn_clone_lock);
		while (srn_inuse) {
			mutex_exit(&srn_clone_lock);
			delay(1);
			mutex_enter(&srn_clone_lock);
		}
		srn_signal = NULL;
		mutex_exit(&srn_clone_lock);

		for (i = 0; i < SRN_MAX_CLONE; i++)
			cv_destroy(&srn_clones_cv[i]);

		ddi_remove_minor_node(dip, NULL);
		srn.srn_instance = -1;
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}


#ifdef DEBUG
char *srn_cmd_string;
int srn_cmd;
#endif

/*
 * Returns true if permission granted by credentials
 * XXX
 */
static int
srn_perms(int perm, cred_t *cr)
{
	if ((perm & SU) && secpolicy_power_mgmt(cr) == 0) /* privileged? */
		return (1);
	if ((perm & SG) && (crgetgid(cr) == 0))	/* group 0 is ok */
		return (1);
	return (0);
}

static int
srn_chpoll(dev_t dev, short events, int anyyet, short *reventsp,
	struct pollhead **phpp)
{
	extern struct pollhead srn_pollhead[];	/* common/os/sunpm.c */
	int	clone;

	clone = SRN_MINOR_TO_CLONE(getminor(dev));
	if ((events & (POLLIN | POLLRDNORM)) && srn_poll_cnt[clone]) {
		*reventsp |= (POLLIN | POLLRDNORM);
	} else {
		*reventsp = 0;
		if (!anyyet) {
			*phpp = &srn_pollhead[clone];
		}
	}
	return (0);
}

/*ARGSUSED*/
static int
srn_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	dev_t	dev;
	int	instance;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (srn.srn_instance == -1)
			return (DDI_FAILURE);
		*result = srn.srn_dip;
		return (DDI_SUCCESS);

	case DDI_INFO_DEVT2INSTANCE:
		dev = (dev_t)arg;
		instance = getminor(dev) >> 8;
		*result = (void *)(uintptr_t)instance;
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}


/*ARGSUSED1*/
static int
srn_open(dev_t *devp, int flag, int otyp, cred_t *cr)
{
	int		clone;

	if (otyp != OTYP_CHR)
		return (EINVAL);

	mutex_enter(&srn_clone_lock);
	for (clone = 1; clone < SRN_MAX_CLONE - 1; clone++)
		if (!srn.srn_clones[clone])
			break;

	if (clone == SRN_MAX_CLONE) {
		mutex_exit(&srn_clone_lock);
		return (ENXIO);
	}
	srn.srn_cred[clone] = cr;
	ASSERT(srn_apm_count >= 0);
	srn_apm_count++;
	srn.srn_type[clone] = SRN_TYPE_APM;
	crhold(cr);

	*devp = makedevice(getmajor(*devp), (srn.srn_instance << 8) +
	    clone);
	srn.srn_clones[clone] = 1;
	srn.srn_cred[clone] = cr;
	crhold(cr);
	mutex_exit(&srn_clone_lock);
	PMD(PMD_SX, ("srn open OK\n"))
	return (0);
}

/*ARGSUSED1*/
static int
srn_close(dev_t dev, int flag, int otyp, cred_t *cr)
{
	int clone;

	if (otyp != OTYP_CHR)
		return (EINVAL);

	clone = SRN_MINOR_TO_CLONE(getminor(dev));
	PMD(PMD_SX, ("srn_close: minor %x, clone %x\n", getminor(dev),
	    clone))
	mutex_enter(&srn_clone_lock);
	crfree(srn.srn_cred[clone]);
	srn.srn_cred[clone] = 0;
	srn_poll_cnt[clone] = 0;
	if (srn.srn_pending[clone].ae_type || srn.srn_delivered[clone]) {
		srn.srn_pending[clone].ae_type = 0;
		srn.srn_delivered[clone] = 0;
		cv_signal(&srn_clones_cv[clone]);
	}
	switch (srn.srn_type[clone]) {
	case SRN_TYPE_AUTOSX:
		ASSERT(srn_autosx_count);
		srn_autosx_count--;
		break;
	case SRN_TYPE_APM:
		ASSERT(srn_apm_count);
		srn_apm_count--;
		break;
	default:
		ASSERT(0);
		return (EINVAL);
	}
	srn.srn_clones[clone] = 0;
	mutex_exit(&srn_clone_lock);
	return (0);
}

/*ARGSUSED*/
static int
srn_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval_p)
{
	int clone = SRN_MINOR_TO_CLONE(getminor(dev));

	PMD(PMD_SX, ("ioctl: %x: begin\n", cmd))

	switch (cmd) {
	case SRN_IOC_NEXTEVENT:
	case SRN_IOC_SUSPEND:
	case SRN_IOC_RESUME:
	case SRN_IOC_AUTOSX:
		break;
	default:
		return (ENOTTY);
	}

	if (!srn_perms(SU | SG, srn.srn_cred[clone])) {
		return (EPERM);
	}
	switch (cmd) {
	case SRN_IOC_AUTOSX:
		PMD(PMD_SX, ("SRN_IOC_AUTOSX entered\n"))
		mutex_enter(&srn_clone_lock);
		if (!srn.srn_clones[clone]) {
			PMD(PMD_SX, (" ioctl !srn_clones--EINVAL\n"))
			mutex_exit(&srn_clone_lock);
			return (EINVAL);
		}
		if (srn.srn_pending[clone].ae_type) {
			PMD(PMD_SX, ("AUTOSX while pending--EBUSY\n"))
			mutex_exit(&srn_clone_lock);
			return (EBUSY);
		}
		if (srn.srn_type[clone] == SRN_TYPE_AUTOSX) {
			PMD(PMD_SX, ("AUTOSX already--EBUSY\n"))
			mutex_exit(&srn_clone_lock);
			return (EBUSY);
		}
		ASSERT(srn.srn_type[clone] == SRN_TYPE_APM);
		srn.srn_type[clone] = SRN_TYPE_AUTOSX;
		srn_apm_count--;
		ASSERT(srn_apm_count >= 0);
		ASSERT(srn_autosx_count >= 0);
		srn_autosx_count++;
		mutex_exit(&srn_clone_lock);
		PMD(PMD_SX, ("SRN_IOC_AUTOSX returns success\n"))
		return (0);

	case SRN_IOC_NEXTEVENT:
		/*
		 * return the next suspend or resume event;  there should
		 * be one, cause we only get called if we've signalled a
		 * poll data completion
		 * then wake up the kernel thread sleeping for the delivery
		 */
		PMD(PMD_SX, ("SRN_IOC_NEXTEVENT entered\n"))
		mutex_enter(&srn_clone_lock);
		if (srn_poll_cnt[clone] == 0) {
			mutex_exit(&srn_clone_lock);
			PMD(PMD_SX, ("SRN_IOC_NEXTEVENT clone %d "
			    "EWOULDBLOCK\n", clone))
			return (EWOULDBLOCK);
		}
		ASSERT(srn.srn_pending[clone].ae_type);
		if (ddi_copyout(&srn.srn_pending[clone], (void *)arg,
		    sizeof (srn_event_info_t), mode) != 0) {
			mutex_exit(&srn_clone_lock);
			PMD(PMD_SX, ("SRN_IOC_NEXTEVENT clone %d EFAULT\n",
			    clone))
			return (EFAULT);
		}
		if (srn.srn_type[clone] == SRN_TYPE_APM)
			srn.srn_delivered[clone] =
			    srn.srn_pending[clone].ae_type;
		PMD(PMD_SX, ("SRN_IOC_NEXTEVENT clone %d delivered %x\n",
		    clone, srn.srn_pending[clone].ae_type))
		srn_poll_cnt[clone] = 0;
		mutex_exit(&srn_clone_lock);
		return (0);

	case SRN_IOC_SUSPEND:
		/* ack suspend */
		PMD(PMD_SX, ("SRN_IOC_SUSPEND entered clone %d\n", clone))
		mutex_enter(&srn_clone_lock);
		if (srn.srn_delivered[clone] != SRN_SUSPEND_REQ) {
			mutex_exit(&srn_clone_lock);
			PMD(PMD_SX, ("SRN_IOC_SUSPEND EINVAL\n"))
			return (EINVAL);
		}
		srn.srn_delivered[clone] = 0;
		srn.srn_pending[clone].ae_type = 0;
		/* notify the kernel suspend thread  to continue */
		PMD(PMD_SX, ("SRN_IOC_SUSPEND clone %d ok\n", clone))
		cv_signal(&srn_clones_cv[clone]);
		mutex_exit(&srn_clone_lock);
		return (0);

	case SRN_IOC_RESUME:
		/* ack resume */
		PMD(PMD_SX, ("SRN_IOC_RESUME entered clone %d\n", clone))
		mutex_enter(&srn_clone_lock);
		if (srn.srn_delivered[clone] != SRN_NORMAL_RESUME) {
			mutex_exit(&srn_clone_lock);
			PMD(PMD_SX, ("SRN_IOC_RESUME EINVAL\n"))
			return (EINVAL);
		}
		srn.srn_delivered[clone] = 0;
		srn.srn_pending[clone].ae_type = 0;
		/* notify the kernel resume thread  to continue */
		PMD(PMD_SX, ("SRN_IOC_RESUME ok for clone %d\n", clone))
		cv_signal(&srn_clones_cv[clone]);
		mutex_exit(&srn_clone_lock);
		return (0);

	default:
		PMD(PMD_SX, ("srn_ioctl unknown cmd EINVAL\n"))
		return (EINVAL);
	}
}
/*
 * A very simple handshake with the srn driver,
 * only one outstanding event at a time.
 * The OS delivers the event and depending on type,
 * either blocks waiting for the ack, or drives on
 */
void
srn_notify(int type, int event)
{
	int clone, count;
	PMD(PMD_SX, ("srn_notify entered with type %d, event 0x%x\n",
	    type, event));
	ASSERT(mutex_owned(&srn_clone_lock));
	switch (type) {
	case SRN_TYPE_APM:
		if (srn_apm_count == 0) {
			PMD(PMD_SX, ("no apm types\n"))
			return;
		}
		count = srn_apm_count;
		break;
	case SRN_TYPE_AUTOSX:
		if (srn_autosx_count == 0) {
			PMD(PMD_SX, ("no autosx types\n"))
			return;
		}
		count = srn_autosx_count;
		break;
	default:
		ASSERT(0);
		break;
	}
	ASSERT(count > 0);
	PMD(PMD_SX, ("count %d\n", count))
	for (clone = 0; clone < SRN_MAX_CLONE; clone++) {
		if (srn.srn_type[clone] == type) {
			if (type == SRN_TYPE_APM) {
				ASSERT(srn.srn_pending[clone].ae_type == 0);
				ASSERT(srn_poll_cnt[clone] == 0);
				ASSERT(srn.srn_delivered[clone] == 0);
			}
			srn.srn_pending[clone].ae_type = event;
			srn_poll_cnt[clone] = 1;
			PMD(PMD_SX, ("pollwake %d\n", clone))
			pollwakeup(&srn_pollhead[clone], (POLLRDNORM | POLLIN));
			count--;
			if (count == 0)
				break;
		}
	}
	if (type == SRN_TYPE_AUTOSX) {		/* we don't wait */
		PMD(PMD_SX, ("Not waiting for AUTOSX ack\n"))
		return;
	}
	ASSERT(type == SRN_TYPE_APM);
	/* otherwise wait for acks */
restart:
	/*
	 * We wait untill all of the pending events are cleared.
	 * We have to start over every time we do a cv_wait because
	 * we give up the mutex and can be re-entered
	 */
	for (clone = 1; clone < SRN_MAX_CLONE; clone++) {
		if (srn.srn_clones[clone] == 0 ||
		    srn.srn_type[clone] != SRN_TYPE_APM)
			continue;
		if (srn.srn_pending[clone].ae_type) {
			PMD(PMD_SX, ("srn_notify waiting for ack for clone %d, "
			    "event %x\n", clone, event))
			cv_wait(&srn_clones_cv[clone], &srn_clone_lock);
			goto restart;
		}
	}
	PMD(PMD_SX, ("srn_notify done with %x\n", event))
}