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


/*
 * Excalibur fans watchdog module
 */

#include <sys/conf.h>
#include <sys/types.h>
#include <sys/mkdev.h>
#include <sys/ddi.h>
#include <sys/stat.h>
#include <sys/modctl.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/ksynch.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/xcalwd.h>
#include <sys/policy.h>
#include <sys/platform_module.h>

extern  struct  mod_ops mod_driverops;

#define MINOR_DEVICE_NAME       "xcalwd"

/*
 * Define your per instance state data
 */
typedef struct xcalwd_state {
        kmutex_t        lock;
        boolean_t       started;
        int             intvl;
        timeout_id_t    tid;
        dev_info_t      *dip;
} xcalwd_state_t;

/*
 * Pointer to soft states
 */
static  void    *xcalwd_statep;

/*
 * dev_ops
 */
static  int     xcalwd_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
        void *arg, void **resultp);
static  int     xcalwd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static  int     xcalwd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);

/*
 * cb_ops
 */
static  int     xcalwd_open(dev_t *devp, int flag, int otyp, cred_t *credp);
static  int     xcalwd_close(dev_t dev, int flag, int otyp, cred_t *credp);
static  int     xcalwd_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
                        cred_t *credp, int *rvalp);
/*
 * timeout handler
 */
static  void    xcalwd_timeout(void *arg);

/*
 * cb_ops
 */
static struct cb_ops xcalwd_cb_ops = {
        xcalwd_open,                    /* open */
        xcalwd_close,                   /* close */
        nodev,                          /* strategy */
        nodev,                          /* print */
        nodev,                          /* dump */
        nodev,                          /* read */
        nodev,                          /* write */
        xcalwd_ioctl,                   /* ioctl */
        nodev,                          /* devmap */
        nodev,                          /* mmap */
        nodev,                          /* segmap */
        nochpoll,                       /* chpoll */
        ddi_prop_op,                    /* prop_op */
        NULL,                           /* streamtab */
        D_NEW | D_MP | D_64BIT,         /* cb_flag */
        CB_REV,                         /* rev */
        nodev,                          /* int (*cb_aread)() */
        nodev                           /* int (*cb_awrite)() */
};

/*
 * dev_ops
 */
static struct dev_ops xcalwd_dev_ops = {
        DEVO_REV,                       /* devo_rev */
        0,                              /* devo_refcnt */
        xcalwd_getinfo,                 /* getinfo */
        nulldev,                        /* identify */
        nulldev,                        /* probe */
        xcalwd_attach,                  /* attach */
        xcalwd_detach,                  /* detach */
        nodev,                          /* devo_reset */
        &xcalwd_cb_ops,                 /* devo_cb_ops */
        NULL,                           /* devo_bus_ops */
        NULL,                           /* devo_power */
        ddi_quiesce_not_needed,                 /* devo_quiesce */
};

/*
 * modldrv
 */
static struct modldrv xcalwd_modldrv = {
        &mod_driverops,                 /* drv_modops */
        "Excalibur watchdog timer v1.7 ",       /* drv_linkinfo */
        &xcalwd_dev_ops         /* drv_dev_ops */
};

/*
 * modlinkage
 */
static struct modlinkage xcalwd_modlinkage = {
        MODREV_1,
        &xcalwd_modldrv,
        NULL
};

int
_init(void)
{
        int             error;

        /*
         * Initialize the module state structure
         */
        error = ddi_soft_state_init(&xcalwd_statep,
            sizeof (xcalwd_state_t), 0);
        if (error) {
                return (error);
        }

        /*
         * Link the driver into the system
         */
        error = mod_install(&xcalwd_modlinkage);
        if (error) {
                ddi_soft_state_fini(&xcalwd_statep);
                return (error);
        }
        return (0);
}

int
_fini(void)
{
        int             error;

        error = mod_remove(&xcalwd_modlinkage);
        if (error != 0) {
                return (error);
        }

        /*
         * Cleanup resources allocated in _init
         */
        ddi_soft_state_fini(&xcalwd_statep);
        return (0);
}

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

/*ARGSUSED*/
static int
xcalwd_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
    void *arg, void **resultp)
{
        int     retval;
        dev_t   dev = (dev_t)arg;
        int     instance;
        xcalwd_state_t  *tsp;

        retval = DDI_FAILURE;
        switch (cmd) {
        case DDI_INFO_DEVT2DEVINFO:
                instance = getminor(dev);
                tsp = ddi_get_soft_state(xcalwd_statep, instance);
                if (tsp == NULL)
                        *resultp = NULL;
                else {
                        *resultp = tsp->dip;
                        retval = DDI_SUCCESS;
                }
                break;
        case DDI_INFO_DEVT2INSTANCE:
                *resultp = (void *)(uintptr_t)getminor(dev);
                retval = DDI_SUCCESS;
                break;
        default:
                break;
        }
        return (retval);
}

static int
xcalwd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int             instance;
        xcalwd_state_t  *tsp;

        switch (cmd) {
        case DDI_ATTACH:
                instance = ddi_get_instance(dip);

                if (&plat_fan_blast == NULL) {
                        cmn_err(CE_WARN, "missing plat_fan_blast function");
                        return (DDI_FAILURE);
                }

                if (ddi_soft_state_zalloc(xcalwd_statep, instance) !=
                    DDI_SUCCESS) {
                        cmn_err(CE_WARN, "attach could not alloc"
                            "%d state structure", instance);
                        return (DDI_FAILURE);
                }

                tsp = ddi_get_soft_state(xcalwd_statep, instance);
                if (tsp == NULL) {
                        cmn_err(CE_WARN, "get state failed %d",
                            instance);
                        return (DDI_FAILURE);
                }

                if (ddi_create_minor_node(dip, MINOR_DEVICE_NAME,
                    S_IFCHR, instance, DDI_PSEUDO, 0) == DDI_FAILURE) {
                        cmn_err(CE_WARN, "create minor node failed\n");
                        return (DDI_FAILURE);
                }

                mutex_init(&tsp->lock, NULL, MUTEX_DRIVER, NULL);
                tsp->started = B_FALSE;
                tsp->intvl = 0;
                tsp->tid = 0;
                tsp->dip = dip;
                ddi_report_dev(dip);
                return (DDI_SUCCESS);

        case DDI_RESUME:
                return (DDI_SUCCESS);
        default:
                break;
        }
        return (DDI_FAILURE);
}

static int
xcalwd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        xcalwd_state_t  *tsp;
        int                     instance;

        switch (cmd) {
        case DDI_DETACH:
                instance = ddi_get_instance(dip);
                tsp = ddi_get_soft_state(xcalwd_statep, instance);
                ddi_remove_minor_node(dip, NULL);
                mutex_destroy(&tsp->lock);
                ddi_soft_state_free(xcalwd_statep, instance);
                return (DDI_SUCCESS);
        case DDI_SUSPEND:
                return (DDI_SUCCESS);
        default:
                break;
        }
        return (DDI_FAILURE);
}

/*
 * Watchdog timeout handler that calls plat_fan_blast to take
 * the failsafe action.
 */
static void
xcalwd_timeout(void *arg)
{
        int     instance = (int)(uintptr_t)arg;
        xcalwd_state_t  *tsp;

        if (instance < 0)
                return;

        tsp = ddi_get_soft_state(xcalwd_statep, instance);
        if (tsp == NULL)
                return;

        mutex_enter(&tsp->lock);
        if (tsp->started == B_FALSE || tsp->tid == 0) {
                tsp->tid = 0;
                mutex_exit(&tsp->lock);
                return;
        }
        mutex_exit(&tsp->lock);

        plat_fan_blast();
}

/*ARGSUSED*/
static int
xcalwd_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{
        int                     instance;

        if (secpolicy_sys_config(credp, B_FALSE) != 0)
                return (EPERM);

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

        instance = getminor(*devp);
        if (instance < 0)
                return (ENXIO);

        if (ddi_get_soft_state(xcalwd_statep, instance) == NULL) {
                return (ENXIO);
        }

        return (0);
}

/*ARGSUSED*/
static int
xcalwd_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
        xcalwd_state_t  *tsp;
        int                     instance;
        timeout_id_t            tid;

        instance = getminor(dev);
        if (instance < 0)
                return (ENXIO);
        tsp = ddi_get_soft_state(xcalwd_statep, instance);
        if (tsp == NULL)
                return (ENXIO);

        mutex_enter(&tsp->lock);
        if (tsp->started == B_FALSE) {
                tsp->tid = 0;
                mutex_exit(&tsp->lock);
                return (0);
        }
        /*
         * The watchdog is enabled. Cancel the pending timer
         * and call plat_fan_blast.
         */
        tsp->started = B_FALSE;
        tid = tsp->tid;
        tsp->tid = 0;
        mutex_exit(&tsp->lock);
        if (tid != 0)
                (void) untimeout(tid);
        plat_fan_blast();

        return (0);
}

/*
 * These are private ioctls for PICL environmental control plug-in
 * to use. The plug-in enables the watchdog before performing
 * altering fan speeds. It also periodically issues a keepalive
 * to the watchdog to cancel and reinstate the watchdog timer.
 * The watchdog timeout handler when executed with the watchdog
 * enabled sets fans to full blast by calling plat_fan_blast.
 */
/*ARGSUSED*/
static int
xcalwd_ioctl(dev_t dev, int cmd, intptr_t arg, int flag,
    cred_t *cred_p, int *rvalp)
{
        int             instance;
        xcalwd_state_t  *tsp;
        int             intvl;
        int             o_intvl;
        boolean_t       curstate;
        timeout_id_t    tid;

        if (secpolicy_sys_config(cred_p, B_FALSE) != 0)
                return (EPERM);

        instance = getminor(dev);
        if (instance < 0)
                return (ENXIO);

        tsp = ddi_get_soft_state(xcalwd_statep, instance);
        if (tsp == NULL)
                return (ENXIO);

        switch (cmd) {
        case XCALWD_STOPWATCHDOG:
                /*
                 * cancels any pending timer and disables the timer.
                 */
                tid = 0;
                mutex_enter(&tsp->lock);
                if (tsp->started == B_FALSE) {
                        mutex_exit(&tsp->lock);
                        return (0);
                }
                tid = tsp->tid;
                tsp->started = B_FALSE;
                tsp->tid = 0;
                mutex_exit(&tsp->lock);
                if (tid != 0)
                        (void) untimeout(tid);
                return (0);
        case XCALWD_STARTWATCHDOG:
                if (ddi_copyin((void *)arg, &intvl, sizeof (intvl), flag))
                        return (EFAULT);
                if (intvl == 0)
                        return (EINVAL);

                mutex_enter(&tsp->lock);
                o_intvl = tsp->intvl;
                mutex_exit(&tsp->lock);

                if (ddi_copyout((const void *)&o_intvl, (void *)arg,
                    sizeof (o_intvl), flag))
                        return (EFAULT);

                mutex_enter(&tsp->lock);
                if (tsp->started == B_TRUE) {
                        mutex_exit(&tsp->lock);
                        return (EINVAL);
                }
                tsp->intvl = intvl;
                tsp->tid = realtime_timeout(xcalwd_timeout,
                    (void *)(uintptr_t)instance,
                    drv_usectohz(1000000) * tsp->intvl);
                tsp->started = B_TRUE;
                mutex_exit(&tsp->lock);
                return (0);
        case XCALWD_KEEPALIVE:
                tid = 0;
                mutex_enter(&tsp->lock);
                tid = tsp->tid;
                tsp->tid = 0;
                mutex_exit(&tsp->lock);
                if (tid != 0)
                        (void) untimeout(tid);  /* cancel */

                mutex_enter(&tsp->lock);
                if (tsp->started == B_TRUE)     /* reinstate */
                        tsp->tid = realtime_timeout(xcalwd_timeout,
                            (void *)(uintptr_t)instance,
                            drv_usectohz(1000000) * tsp->intvl);
                mutex_exit(&tsp->lock);
                return (0);
        case XCALWD_GETSTATE:
                mutex_enter(&tsp->lock);
                curstate = tsp->started;
                mutex_exit(&tsp->lock);
                if (ddi_copyout((const void *)&curstate, (void *)arg,
                    sizeof (curstate), flag))
                        return (EFAULT);
                return (0);
        default:
                return (EINVAL);
        }
        /*NOTREACHED*/
}