/*
 * 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.
 */


/*
 * This is the Beep driver for bbc based beep mechanism.
 *
 */
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/ddi_impldefs.h>
#include <sys/kmem.h>
#include <sys/devops.h>
#include <sys/bbc_beep.h>
#include <sys/beep.h>


/* Pointer to the state structure */
static void *bbc_beep_statep;


/*
 * Debug stuff
 */
#ifdef DEBUG
int bbc_beep_debug = 0;
#define	BBC_BEEP_DEBUG(args)  if (bbc_beep_debug) cmn_err args
#define	BBC_BEEP_DEBUG1(args)  if (bbc_beep_debug > 1) cmn_err args
#else
#define	BBC_BEEP_DEBUG(args)
#define	BBC_BEEP_DEBUG1(args)
#endif


/*
 * Prototypes
 */
static int bbc_beep_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int bbc_beep_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int bbc_beep_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
		void **result);
static void bbc_beep_freq(void *arg, int freq);
static void bbc_beep_on(void *arg);
static void bbc_beep_off(void *arg);
static void bbc_beep_cleanup(bbc_beep_state_t *);
static int bbc_beep_map_regs(dev_info_t *, bbc_beep_state_t *);
static bbc_beep_state_t *bbc_beep_obtain_state(dev_info_t *);
static unsigned long bbc_beep_hztocounter(int);


struct cb_ops bbc_beep_cb_ops = {
	nulldev,	/* open  */
	nulldev,	/* close */
	nulldev,	/* strategy */
	nulldev,	/* print */
	nulldev,	/* dump */
	nulldev,	/* read */
	nulldev,	/* write */
	nulldev,	/* ioctl */
	nulldev,	/* devmap */
	nulldev,	/* mmap */
	nulldev,	/* segmap */
	nochpoll,	/* poll */
	ddi_prop_op,	/* cb_prop_op */
	NULL,		/* streamtab  */
	D_64BIT | D_MP | D_NEW| D_HOTPLUG
};


static struct dev_ops bbc_beep_ops = {
	DEVO_REV,		/* Devo_rev */
	0,			/* Refcnt */
	bbc_beep_info,		/* Info */
	nulldev,		/* Identify */
	nulldev,		/* Probe */
	bbc_beep_attach,	/* Attach */
	bbc_beep_detach,	/* Detach */
	nodev,			/* Reset */
	&bbc_beep_cb_ops,	/* Driver operations */
	0,			/* Bus operations */
	ddi_power,		/* Power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};


static struct modldrv modldrv = {
	&mod_driverops, 		/* This one is a driver */
	"BBC Beep Driver", 		/* Name of the module. */
	&bbc_beep_ops,			/* Driver ops */
};


static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modldrv, NULL
};


int
_init(void)
{
	int error;

	/* Initialize the soft state structures */
	if ((error = ddi_soft_state_init(&bbc_beep_statep,
	    sizeof (bbc_beep_state_t), 1)) != 0) {

		return (error);
	}

	/* Install the loadable module */
	if ((error = mod_install(&modlinkage)) != 0) {
		ddi_soft_state_fini(&bbc_beep_statep);
	}

	return (error);
}


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


int
_fini(void)
{
	int error;

	error = mod_remove(&modlinkage);

	if (error == 0) {
		/* Release per module resources */
		ddi_soft_state_fini(&bbc_beep_statep);
	}

	return (error);
}


/*
 * Beep entry points
 */

/*
 * bbc_beep_attach:
 */
static int
bbc_beep_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int		instance;		/* Instance number */

	/* Pointer to soft state */
	bbc_beep_state_t	*bbc_beeptr = NULL;

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_attach: Start"));

	switch (cmd) {
		case DDI_ATTACH:
			break;
		case DDI_RESUME:
			return (DDI_SUCCESS);
		default:
			return (DDI_FAILURE);
	}

	/* Get the instance and create soft state */
	instance = ddi_get_instance(dip);

	if (ddi_soft_state_zalloc(bbc_beep_statep, instance) != 0) {

		return (DDI_FAILURE);
	}

	bbc_beeptr = ddi_get_soft_state(bbc_beep_statep, instance);

	if (bbc_beeptr == NULL) {

		return (DDI_FAILURE);
	}

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beeptr = 0x%p, instance %x",
	    (void *)bbc_beeptr, instance));

	/* Save the dip */
	bbc_beeptr->bbc_beep_dip = dip;

	/* Initialize beeper mode */
	bbc_beeptr->bbc_beep_mode = BBC_BEEP_OFF;

	/* Map the Beep Control and Beep counter Registers */
	if (bbc_beep_map_regs(dip, bbc_beeptr) != DDI_SUCCESS) {

		BBC_BEEP_DEBUG((CE_WARN, \
		    "bbc_beep_attach: Mapping of bbc registers failed."));

		bbc_beep_cleanup(bbc_beeptr);

		return (DDI_FAILURE);
	}

	(void) beep_init((void *)dip, bbc_beep_on, bbc_beep_off, bbc_beep_freq);

	/* Display information in the banner */
	ddi_report_dev(dip);

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_attach: dip = 0x%p done",
	    (void *)dip));

	return (DDI_SUCCESS);
}


/*
 * bbc_beep_detach:
 */
static int
bbc_beep_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	/* Pointer to soft state */
	bbc_beep_state_t	*bbc_beeptr = NULL;

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_detach: Start"));

	switch (cmd) {
		case DDI_SUSPEND:
			bbc_beeptr = bbc_beep_obtain_state(dip);

			if (bbc_beeptr == NULL) {

				return (DDI_FAILURE);
			}

			/*
			 * If a beep is in progress; fail suspend
			 */
			if (bbc_beeptr->bbc_beep_mode == BBC_BEEP_OFF) {
				return (DDI_SUCCESS);
			} else {
				return (DDI_FAILURE);
			}
		default:

			return (DDI_FAILURE);
	}
}


/*
 * bbc_beep_info:
 */
/* ARGSUSED */
static int
bbc_beep_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
		void *arg, void **result)
{
	dev_t dev;
	bbc_beep_state_t  *bbc_beeptr;
	int instance, error;

	switch (infocmd) {

	case DDI_INFO_DEVT2DEVINFO:
		dev = (dev_t)arg;
		instance = BEEP_UNIT(dev);

		if ((bbc_beeptr = ddi_get_soft_state(bbc_beep_statep,
		    instance)) == NULL) {

			return (DDI_FAILURE);
		}

		*result = (void *)bbc_beeptr->bbc_beep_dip;

		error = DDI_SUCCESS;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		dev = (dev_t)arg;
		instance = BEEP_UNIT(dev);

		*result = (void *)(uintptr_t)instance;

		error = DDI_SUCCESS;
		break;
	default:
		error = DDI_FAILURE;

	}

	return (error);
}


/*
 * bbc_beep_freq() :
 *	Set the frequency
 */
static void
bbc_beep_freq(void *arg, int freq)
{
	dev_info_t *dip = (dev_info_t *)arg;
	unsigned long counter;
	int8_t beep_c2 = 0;
	int8_t beep_c3 = 0;

	bbc_beep_state_t *bbc_beeptr = bbc_beep_obtain_state(dip);

	/* Convert the frequency in hz to the bbc counter value */
	counter = bbc_beep_hztocounter(freq);

	/* Extract relevant second and third byte of counter value */
	beep_c2 = (counter & 0xff00) >> 8;
	beep_c3 = (counter & 0xff0000) >> 16;

	/*
	 * We need to write individual bytes instead of writing
	 * all of 32 bits to take care of allignment problem.
	 * Write 0 to LS 8 bits and MS 8 bits
	 * Write beep_c3 to bit 8..15 and beep_c2 to bit 16..24
	 * Little Endian format
	 */
	BEEP_WRITE_COUNTER_REG(0, 0);
	BEEP_WRITE_COUNTER_REG(1, beep_c3);
	BEEP_WRITE_COUNTER_REG(2, beep_c2);
	BEEP_WRITE_COUNTER_REG(3, 0);

	BBC_BEEP_DEBUG1((CE_CONT,
	    "bbc_beep_freq: dip = 0x%p, freq = %d, counter = 0x%x : Done",
	    (void *)dip, freq, (int)counter));
}


/*
 * bbc_beep_on() :
 *	Turn the beeper on
 */
static void
bbc_beep_on(void *arg)
{
	dev_info_t *dip = (dev_info_t *)arg;
	bbc_beep_state_t *bbc_beeptr = bbc_beep_obtain_state(dip);

	BEEP_WRITE_CTRL_REG(BBC_BEEP_ON);

	bbc_beeptr->bbc_beep_mode = BBC_BEEP_ON;

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_on: dip = 0x%p done",
	    (void *)dip));
}


/*
 * bbc_beep_off() :
 * 	Turn the beeper off
 */
static void
bbc_beep_off(void *arg)
{
	dev_info_t *dip = (dev_info_t *)arg;
	bbc_beep_state_t *bbc_beeptr = bbc_beep_obtain_state(dip);

	BEEP_WRITE_CTRL_REG(BBC_BEEP_OFF);

	bbc_beeptr->bbc_beep_mode = BBC_BEEP_OFF;

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_off: dip = 0x%p done",
	    (void *)dip));
}


/*
 * bbc_beep_map_regs() :
 *
 *	The Keyboard Beep Control Register and Keyboard Beep Counter Register
 *	should be mapped into a non-cacheable portion of the  system
 *	addressable space.
 */
static int
bbc_beep_map_regs(dev_info_t *dip, bbc_beep_state_t *bbc_beeptr)
{
	ddi_device_acc_attr_t attr;

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_map_regs: Start\n"));

	/* The host controller will be little endian */
	attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	attr.devacc_attr_endian_flags  = DDI_STRUCTURE_LE_ACC;
	attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

	/* Map in operational registers */
	if (ddi_regs_map_setup(dip, 0,
	    (caddr_t *)&bbc_beeptr->bbc_beep_regsp,
	    0,
	    sizeof (bbc_beep_regs_t),
	    &attr,
	    &bbc_beeptr->bbc_beep_regs_handle) != DDI_SUCCESS) {

		return (DDI_FAILURE);
	}

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_map_regs: done\n"));

	return (DDI_SUCCESS);
}


/*
 * bbc_beep_obtain_state:
 */
static bbc_beep_state_t *
bbc_beep_obtain_state(dev_info_t *dip)
{
	int instance = ddi_get_instance(dip);

	bbc_beep_state_t *state = ddi_get_soft_state(bbc_beep_statep, instance);

	ASSERT(state != NULL);

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_obtain_state: done"));

	return (state);
}


/*
 * bbc_beep_cleanup :
 *	Cleanup soft state
 */
static void
bbc_beep_cleanup(bbc_beep_state_t *bbc_beeptr)
{
	int instance = ddi_get_instance(bbc_beeptr->bbc_beep_dip);

	ddi_soft_state_free(bbc_beep_statep, instance);

	BBC_BEEP_DEBUG1((CE_CONT, "bbc_beep_cleanup: done"));
}


/*
 * bbc_beep_hztocounter() :
 *	Given a frequency in hz, find out the value to
 *	be set in the Keyboard Beep Counter register
 *	BBC beeper uses the following formula to calculate
 * 	frequency. The formulae is :
 *	frequency generated = system freq /2^(n+2)
 *	Where n = position of the bit of counter register
 *	that is turned on and can range between 10 to 18.
 *	So in this function, the inputs are frequency generated
 *	and system frequency and we need to find out n, i.e, which
 *	bit to turn on.(Ref. to Section 4.2.22 of the BBC programming
 *	manual).
 */
unsigned long
bbc_beep_hztocounter(int freq)
{
	int 		i;
	unsigned long	counter;
	int 		newfreq, oldfreq;

	int		system_freq;

	/*
	 * Get system frequency for the root dev_info properties
	 */
	system_freq = ddi_prop_get_int(DDI_DEV_T_ANY, ddi_root_node(),
	    0, "clock-frequency", 0);

	oldfreq = 0;

	/*
	 * Calculate frequency by turning on ith bit and
	 * matching it with the passed frequency and we do this
	 * in a loop for all the relevant bits
	 */
	for (i = BBC_BEEP_MIN_SHIFT, counter = 1 << BBC_BEEP_MSBIT;
	    i >= BBC_BEEP_MAX_SHIFT; i--, counter >>= 1) {

		/*
		 * Calculate the frequency by dividing the system
		 * frequency by 2^i
		 */
		newfreq = system_freq >> i;

		/*
		 * Check if we turn on the ith bit, the
		 * frequency matches exactly or not
		 */
		if (newfreq == freq) {
			/*
			 * Exact match of passed frequency with the
			 * counter value
			 */

			return (counter);
		}

		/*
		 * If calculated frequency is bigger
		 * return the passed frequency
		 */
		if (newfreq > freq) {

			if (i == BBC_BEEP_MIN_SHIFT) {
				/* Input freq is less than the possible min */

				return (counter);
			}

			/*
			 * Find out the nearest frequency to the passed
			 * frequency by comparing the difference between
			 * the calculated frequency and the passed frequency
			 */
			if ((freq - oldfreq) > (newfreq - freq)) {
				/* Return new counter corres. to newfreq */

				return (counter);
			}

			/* Return old counter corresponding to oldfreq */

			return (counter << 1);
		}

		oldfreq = newfreq;
	}

	/*
	 * Input freq is greater than the possible max;
	 * Back off the counter value and return max counter
	 * value possible in the register
	 */
	return (counter << 1);
}