*

 * Permission is hereby granted, free of charge, to any person obtaining a

 *

 *

 *

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/signal.h>

#include <sys/stream.h>

#include <sys/stropts.h>

#include <sys/kmem.h>

#ifndef _DDICT

#include <sys/vuid_event.h>

#else

#include "vuid_event.h"

#endif /* _DDICT */

#include <sys/modctl.h>

#include <sys/cmn_err.h>

#ifndef _DDICT

#include <sys/fbio.h>

#else

#include "fbio.h"

#endif /* _DDICT */

#include <sys/ddi.h>

#include <sys/file.h>

#include <sys/sunddi.h>

#include <sys/systm.h>

#include "hwcio.h"

/* NOTE: datamodel size-invariant ILP32/LP64 */

struct msctrl {		/* same as R5 PtrCtrl struct */

	int num;

	int den;

	int threshold;

	unsigned char id;

};

/* NOTE: datamodel size-invariant ILP32/LP64 */

struct hwcrec {

	struct fbcurpos		cursor_position;

	struct hwc_limits	limits;

	struct msctrl		ctrl;

	dev_t			screen_dev_t;

	int			hwc_enabled;

	int			at_border;

};

static int hwcopen(queue_t *q, dev_t *dev, int oflag, int sflag, cred_t *credp);

static int hwcclose(queue_t *);

static int hwcwput(queue_t *, mblk_t *);

static int hwcrput(queue_t *, mblk_t *);

static void hwcioctl(queue_t *, mblk_t *);

static void hwciocdata(queue_t *, mblk_t *);

static void hwc_spos(queue_t *q, mblk_t *mp);

static void hwc_scursor(queue_t *q, mblk_t *mp);

#ifndef _DDICT

static void hwc_set_cursor_pos(dev_t, struct fbcurpos *);

static void hwc_set_cursor(dev_t, struct fbcursor *);

#endif /* _DDICT */

static void hwc_state_free(struct copyresp *s);

static struct module_info hwcmiinfo = {

	0,

	"hwc",

	0,

	INFPSZ,

	2048,

	128

};

static struct qinit hwcrinit = {

	hwcrput,

	(int (*)())NULL,

	hwcopen,

	hwcclose,

	(int (*)())NULL,

	&hwcmiinfo,

	NULL

};

static struct module_info hwcmoinfo = {

	0,

	"hwc",

	0,

	INFPSZ,

	2048,

	128

};

static struct qinit hwcwinit = {

	hwcwput,

	(int (*)())NULL,

	hwcopen,

	hwcclose,

	(int (*)())NULL,

	&hwcmoinfo,

	NULL

};

static struct streamtab hwc_info = {

	&hwcrinit,

	&hwcwinit,

	NULL,

	NULL,

};

static struct fmodsw fsw = {

	"hwc",

	&hwc_info,

	(D_NEW|D_MP|D_MTPERMOD)

};

/*

 * Module linkage information for the kernel.

 */

extern struct mod_ops mod_strmodops;

static struct modlstrmod modlstrmod = {

	&mod_strmodops, "streams module for hardware cursor support", &fsw

};

static struct modlinkage modlinkage = {

	MODREV_1, &modlstrmod, NULL

};

int

_init(void)

{

	return (mod_install(&modlinkage));

}

int

_info(struct modinfo *modinfop)

{

	return (mod_info(&modlinkage, modinfop));

}

int

_fini(void)

{

	return (mod_remove(&modlinkage));

}

#define	ABS(x)	((x) < 0 ? -(x) : (x))

#define	ACKNAK(q, mp, iocp, type) {		\

	mp->b_datap->db_type = type;		\

	iocp->ioc_count = 0;			\

	qreply(q, mp);				\

	}

#define	IOCACK(q, mp, iocp)	ACKNAK(q, mp, iocp, M_IOCACK)

#define	IOCNAK(q, mp, iocp)	ACKNAK(q, mp, iocp, M_IOCNAK)

#define	CKTRANSPARENT(q, mp)			\

	if (iocp->ioc_count != TRANSPARENT) {	\

		if (mp->b_cont) {		\

			freemsg(mp->b_cont);	\

			mp->b_cont = NULL;	\

		}				\

		mp->b_datap->db_type = M_IOCNAK; \

		qreply(q, mp);			\

		return;				\

	}

#define	COPYIN(q, mp, cqp, cpsize) {		\

	cqp = (struct copyreq *)mp->b_rptr;	\

	cqp->cq_addr = (caddr_t)*(long *)mp->b_cont->b_rptr; \

	if (mp->b_cont)				\

		freemsg(mp->b_cont);		\

	mp->b_cont = NULL;			\

	cqp->cq_size = cpsize;			\

	cqp->cq_flag = 0;			\

	mp->b_datap->db_type = M_COPYIN;	\

	mp->b_wptr = mp->b_rptr + sizeof (struct copyreq); \

	qreply(q, mp);				\

	}

#define	COPYACK(q, mp, iocp) {			\

	iocp->ioc_error = 0;			\

	iocp->ioc_rval = 0;			\

	if (mp->b_cont)				\

		freemsg(mp->b_cont);		\

	mp->b_cont = NULL;			\

	IOCACK(q, mp, iocp);			\

	}

#define	COPYNACK(q, mp, iocp) {			\

	iocp->ioc_error = 0;			\

	iocp->ioc_rval = 0;			\

	if (mp->b_cont)				\

		freemsg(mp->b_cont);		\

	mp->b_cont = NULL;			\

	IOCNAK(q, mp, iocp);			\

	}

/*bugid: 4338558 hwc mem. leaks */

#define	CK_RVAL(csp,mp)	\

	if (csp->cp_rval) {			\

		hwc_state_free(csp); \

		freemsg(mp);	\

		return;				\

	}

/*ARGSUSED*/

static int

hwcopen(queue_t *q, dev_t *dev, int oflag, int sflag, cred_t *credp)

{

	struct hwcrec *hwcptr;

	if (q->q_ptr != NULL)

		return (0);		/* already attached */

	if (!groupmember(0, ddi_get_cred()))

		return (EPERM);

	if ((hwcptr = kmem_alloc(sizeof (struct hwcrec), KM_SLEEP)) == NULL)

		return (ENOMEM);

	hwcptr->hwc_enabled = 0;

	hwcptr->at_border = 0;

	hwcptr->ctrl.num = 2;

	hwcptr->ctrl.den = 1;

	hwcptr->ctrl.threshold = 4;

	/* save the instance pointer in private data  */

	q->q_ptr = (void *)hwcptr;

	WR(q)->q_ptr = (void *)hwcptr;

	qprocson(q);

	return (0);

}

static int

hwcclose(queue_t *q)

{

	struct hwcrec *hwcptr = (struct hwcrec *)q->q_ptr; /* instance data */

	qprocsoff(q);

#ifndef _DDICT

	if (hwcptr->hwc_enabled) {

		struct fbcursor fbcursor;

		fbcursor.set = FB_CUR_SETCUR;

		fbcursor.enable = 0;

		hwc_set_cursor(hwcptr->screen_dev_t, &fbcursor);

	}

#endif /* _DDICT */

	/* free the per-instance data */

	kmem_free(hwcptr, sizeof (*hwcptr));

	q->q_ptr = NULL;

	WR(q)->q_ptr = NULL;

	return (0);

}

/*

 * read queue put procedure.

 */

static int

hwcrput(queue_t *q, mblk_t *mp)

{

	static Firm_event *ev;

	struct hwcrec *hwcptr = (struct hwcrec *)q->q_ptr; /* instance data */

	switch (mp->b_datap->db_type) {

	case M_FLUSH:

		if (*mp->b_rptr & FLUSHW)

			flushq(WR(q), FLUSHDATA);

		if (*mp->b_rptr & FLUSHR)

			flushq(q, FLUSHDATA);

		putnext(q, mp);

		return (0);

	case M_DATA:

		ev = (Firm_event *)mp->b_rptr;

		if (ev->id == LOC_X_DELTA) {

			int tmpx;

			/* check for acceleration threshold */

			if (ABS(ev->value) > hwcptr->ctrl.threshold)

				tmpx = hwcptr->cursor_position.x +

				    ((ev->value * hwcptr->ctrl.num) /

				    hwcptr->ctrl.den);

			else

				tmpx = hwcptr->cursor_position.x + ev->value;

			/* bound cursor to screen */

			if (tmpx >= hwcptr->limits.x2) {

				if (hwcptr->limits.confined) {

					tmpx = hwcptr->limits.x2 - 1;

					/*

					 * if the cursor was already at

					 * the limit just toss event.

					 */

					if (hwcptr->cursor_position.x == tmpx) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.x = (short)tmpx;

				} else {

					/*

					 * If we're already on an X

					 * boundary of the screen, only

					 * send change border events

					 * until server has acknowledged

					 * crossing.

					 */

					if (hwcptr->at_border&0x1) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.x =

					    hwcptr->limits.x2;

					hwcptr->at_border |= 0x1;

				}

			} else if (tmpx < hwcptr->limits.x1) {

				if (hwcptr->limits.confined) {

					if (hwcptr->cursor_position.x ==

					    hwcptr->limits.x1) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.x =

					    hwcptr->limits.x1;

				} else {

					if (hwcptr->at_border&0x1) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.x = -1;

					hwcptr->at_border |= 0x1;

				}

			} else {

				hwcptr->cursor_position.x = (short)tmpx;

				hwcptr->at_border &= ~0x1;

			}

			if (ev->value) {

				ev->id = LOC_X_ABSOLUTE;

				ev->value = hwcptr->cursor_position.x;

#ifndef _DDICT

				if (hwcptr->hwc_enabled)

					hwc_set_cursor_pos(hwcptr->screen_dev_t,

					    &hwcptr->cursor_position);

#endif /* _DDICT */

			}

		}

		if (ev->id == LOC_Y_DELTA) {

			int tmpy;

			/* need to invert y-axis */

			if (ABS(ev->value) > hwcptr->ctrl.threshold)

				tmpy = hwcptr->cursor_position.y -

				    ((ev->value * hwcptr->ctrl.num) /

				    hwcptr->ctrl.den);

			else

				tmpy = hwcptr->cursor_position.y - ev->value;

			if (tmpy >= hwcptr->limits.y2) {

				if (hwcptr->limits.confined) {

					tmpy = hwcptr->limits.y2 - 1;

					/*

					 * if the cursor was already at

					 * the limit just toss event.

					 */

					if (hwcptr->cursor_position.y == tmpy) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.y = (short)tmpy;

				} else {

					if (hwcptr->at_border&0x2) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.y =

					    hwcptr->limits.y2;

					hwcptr->at_border |= 0x2;

				}

			} else if (tmpy < hwcptr->limits.y1) {

				if (hwcptr->limits.confined) {

					if (hwcptr->cursor_position.y ==

					    hwcptr->limits.y1) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.y =

					    hwcptr->limits.y1;

				} else {

					if (hwcptr->at_border&0x2) {

						freemsg(mp);

						return (0);

					}

					hwcptr->cursor_position.y = -1;

					hwcptr->at_border |= 0x2;

				}

			} else {

				hwcptr->cursor_position.y = (short)tmpy;

				hwcptr->at_border &= ~0x2;

			}

			if (ev->value) {

				ev->id = LOC_Y_ABSOLUTE;

				ev->value = hwcptr->cursor_position.y;

#ifndef _DDICT

				if (hwcptr->hwc_enabled)

					hwc_set_cursor_pos(hwcptr->screen_dev_t,

					    &hwcptr->cursor_position);

#endif /* _DDICT */

			}

		}

		(void) putnext(q, mp);

		return (0);

	default:

		(void) putnext(q, mp);

		return (0);

	}

}

/*

 * Line discipline output queue put procedure: handles M_IOCTL

 * messages.

 */

static int

hwcwput(queue_t *q, mblk_t *mp)

{

	switch (mp->b_datap->db_type) {

	case M_FLUSH:

		if (*mp->b_rptr & FLUSHW)

			flushq(q, FLUSHDATA);

		if (*mp->b_rptr & FLUSHR)

			flushq(RD(q), FLUSHDATA);

		putnext(q, mp);

		break;

	case M_IOCTL:		/* process user ioctl() */

		hwcioctl(q, mp);

		break;

	case M_IOCDATA:		/* retrieve ioctl() data */

		hwciocdata(q, mp);

		break;

	default:

		(void) putnext(q, mp);	/* pass it down the line */

		break;

	}

	return (0);

}

static void

hwcioctl(queue_t *q, mblk_t *mp)

{

	struct iocblk *iocp;

	struct copyreq *cqp;

	mblk_t	*tmp;

	struct hwc_state *stp;

	iocp = (struct iocblk *)mp->b_rptr;

	switch (iocp->ioc_cmd) {

	case HWCGVERSION: {	/* Get the HWC module version */

		int transparent = 0;

		if (iocp->ioc_count == TRANSPARENT) {

			transparent = 1;

			cqp = (struct copyreq *)mp->b_rptr;

			cqp->cq_size = sizeof (int);

			cqp->cq_addr = (caddr_t)*(long *)mp->b_cont->b_rptr;

			cqp->cq_flag = 0;

		}

		if (mp->b_cont)

			freemsg(mp->b_cont); /* over written below */

		if ((mp->b_cont = allocb(sizeof (int), BPRI_MED)) == NULL) {

			mp->b_datap->db_type = M_IOCNAK;

			iocp->ioc_error = EAGAIN;

			qreply(q, mp);

			break;

		}

		*(int *)mp->b_cont->b_wptr = HWCVERSION;

		mp->b_cont->b_wptr += sizeof (int);

		if (transparent) {

			mp->b_cont->b_datap->db_type = M_DATA;

			mp->b_datap->db_type = M_COPYOUT;

			mp->b_wptr = mp->b_rptr + sizeof (struct copyreq);

		} else {

			mp->b_datap->db_type = M_IOCACK;