/*
* 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);
}