/*
* 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.
*/
/*
* Driver for the Power Management Controller (logical unit 8) of the
* PC87317 SuperI/O chip. The PMC contains the hardware watchdog timer.
*/
#include <sys/types.h>
#include <sys/time.h>
#include <sys/cmn_err.h>
#include <sys/param.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/clock.h>
#include <sys/reboot.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/file.h>
#include <sys/note.h>
#ifdef DEBUG
int pmc_debug_flag = 0;
#define DPRINTF(ARGLIST) if (pmc_debug_flag) printf ARGLIST;
#else
#define DPRINTF(ARGLIST)
#endif /* DEBUG */
/* Driver soft state structure */
typedef struct pmc {
dev_info_t *dip;
ddi_acc_handle_t pmc_handle;
} pmc_t;
static void *pmc_soft_state;
static int instance = -1;
/* dev_ops and cb_ops entry point function declarations */
static int pmc_attach(dev_info_t *, ddi_attach_cmd_t);
static int pmc_detach(dev_info_t *, ddi_detach_cmd_t);
static int pmc_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
/* hardware watchdog parameters */
static uint_t pmc_set_watchdog_timer(uint_t);
static uint_t pmc_clear_watchdog_timer(void);
extern volatile uint8_t *v_pmc_addr_reg;
extern volatile uint8_t *v_pmc_data_reg;
extern int watchdog_enable;
extern int watchdog_available;
extern int watchdog_activated;
extern int boothowto;
extern uint_t watchdog_timeout_seconds;
/*
* Power Management Registers and values
*/
#define PMC_WDTO 0x05 /* Watchdog Time Out */
#define PMC_CLEAR_WDTO 0x00
struct cb_ops pmc_cb_ops = {
nodev,
nodev,
nodev,
nodev,
nodev, /* dump */
nodev,
nodev,
nodev,
nodev, /* devmap */
nodev,
nodev,
nochpoll,
ddi_prop_op,
NULL, /* for STREAMS drivers */
D_NEW | D_MP, /* driver compatibility flag */
CB_REV,
nodev,
nodev
};
static struct dev_ops pmc_dev_ops = {
DEVO_REV, /* driver build version */
0, /* device reference count */
pmc_getinfo,
nulldev,
nulldev, /* probe */
pmc_attach,
pmc_detach,
nulldev, /* reset */
&pmc_cb_ops,
(struct bus_ops *)NULL,
nulldev /* power */
};
/* module configuration stuff */
extern struct mod_ops mod_driverops;
static struct modldrv modldrv = {
&mod_driverops,
"pmc driver",
&pmc_dev_ops
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
0
};
int
_init(void)
{
int e;
e = ddi_soft_state_init(&pmc_soft_state, sizeof (pmc_t), 1);
if (e != 0) {
DPRINTF(("_init: ddi_soft_state_init failed\n"));
return (e);
}
e = mod_install(&modlinkage);
if (e != 0) {
DPRINTF(("_init: mod_install failed\n"));
ddi_soft_state_fini(&pmc_soft_state);
return (e);
}
if (v_pmc_addr_reg != NULL) {
tod_ops.tod_set_watchdog_timer = pmc_set_watchdog_timer;
tod_ops.tod_clear_watchdog_timer = pmc_clear_watchdog_timer;
/*
* See if the user has enabled the watchdog timer, and if
* it's available.
*/
if (watchdog_enable) {
if (!watchdog_available) {
cmn_err(CE_WARN, "pmc: Hardware watchdog "
"unavailable");
} else if (boothowto & RB_DEBUG) {
watchdog_available = 0;
cmn_err(CE_WARN, "pmc: kernel debugger "
"detected: hardware watchdog disabled");
}
}
}
return (e);
}
int
_fini(void)
{
int e;
if (v_pmc_addr_reg != NULL)
return (DDI_FAILURE);
else {
e = mod_remove(&modlinkage);
if (e != 0)
return (e);
ddi_soft_state_fini(&pmc_soft_state);
return (DDI_SUCCESS);
}
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
static int
pmc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
_NOTE(ARGUNUSED(dip))
pmc_t *pmcp;
int instance;
switch (cmd) {
case DDI_INFO_DEVT2DEVINFO:
instance = getminor((dev_t)arg);
pmcp = (pmc_t *)ddi_get_soft_state(pmc_soft_state, instance);
if (pmcp == NULL) {
*result = (void *)NULL;
return (DDI_FAILURE);
}
*result = (void *)pmcp->dip;
return (DDI_SUCCESS);
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)(uintptr_t)getminor((dev_t)arg);
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
pmc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
pmc_t *pmcp;
uint_t wd_timout;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
if (v_pmc_addr_reg != NULL && watchdog_enable) {
int ret = 0;
wd_timout = watchdog_timeout_seconds;
mutex_enter(&tod_lock);
ret = tod_ops.tod_set_watchdog_timer(wd_timout);
mutex_exit(&tod_lock);
if (ret == 0)
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (instance != -1) {
DPRINTF(("pmc_attach: Another instance is already attached."));
return (DDI_FAILURE);
}
instance = ddi_get_instance(dip);
if (ddi_soft_state_zalloc(pmc_soft_state, instance) != DDI_SUCCESS) {
DPRINTF(("pmc_attach: Failed to allocate soft state."));
return (DDI_FAILURE);
}
pmcp = (pmc_t *)ddi_get_soft_state(pmc_soft_state, instance);
pmcp->dip = dip;
return (DDI_SUCCESS);
}
static int
pmc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
_NOTE(ARGUNUSED(dip))
pmc_t *pmcp;
switch (cmd) {
case DDI_DETACH:
/* allow detach if no hardware watchdog */
if (v_pmc_addr_reg == NULL || !watchdog_activated) {
pmcp = (pmc_t *)ddi_get_soft_state(pmc_soft_state,
instance);
if (pmcp == NULL)
return (ENXIO);
ddi_soft_state_free(pmc_soft_state, instance);
return (DDI_SUCCESS);
} else
return (DDI_FAILURE);
case DDI_SUSPEND:
if (v_pmc_addr_reg != NULL && watchdog_activated) {
mutex_enter(&tod_lock);
(void) tod_ops.tod_clear_watchdog_timer();
mutex_exit(&tod_lock);
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
/*
* Set the hardware watchdog timer; returning what we set it to.
*/
static uint_t
pmc_set_watchdog_timer(uint_t timeoutval)
{
uint_t timeoutval_minutes;
ASSERT(MUTEX_HELD(&tod_lock));
/* sanity checks */
if (watchdog_enable == 0 || watchdog_available == 0 ||
timeoutval == 0)
return (0);
/*
* Historically the timer has been counted out in seconds.
* The PC87317 counts the timeout in minutes. The default
* timeout is 10 seconds; the least we can do is one minute.
*/
timeoutval_minutes = (timeoutval + 59) / 60;
if (timeoutval_minutes > UINT8_MAX)
return (0);
*v_pmc_addr_reg = (uint8_t)PMC_WDTO;
*v_pmc_data_reg = (uint8_t)timeoutval_minutes;
watchdog_activated = 1;
/* we'll still return seconds */
return (timeoutval_minutes * 60);
}
/*
* Clear the hardware watchdog timer; returning what it was set to.
*/
static uint_t
pmc_clear_watchdog_timer(void)
{
uint_t wd_timeout;
ASSERT(MUTEX_HELD(&tod_lock));
if (watchdog_activated == 0)
return (0);
*v_pmc_addr_reg = (uint8_t)PMC_WDTO;
wd_timeout = (uint_t)*v_pmc_data_reg;
*v_pmc_data_reg = (uint8_t)PMC_CLEAR_WDTO;
watchdog_activated = 0;
/* return seconds */
return (wd_timeout * 60);
}