/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 (c) 1990, 1991 UNIX System Laboratories, Inc. */
/*      Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T   */
/*        All Rights Reserved   */

/*
 * Copyright (c) 1997, by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/hrtcntl.h>
#include <sys/errno.h>
#include <sys/hrtsys.h>
#include <sys/time.h>
#include <sys/timer.h>
#include <sys/cmn_err.h>

/*
 * This file contains the code that manages the hardware clocks and
 * timers.  We must provide UNIX with a HZ resolution clock and give
 * the user an interface to the timers through system calls.
 */

static int hrt_checkres(ulong res);
static int hrt_bsd_cancel(int clock);
static int hrt_checkclock(register int clock);

/*
 * Argument vectors for the various flavors of hrtsys().
 */

#define HRTCNTL         0
#define HRTALARM        1
#define HRTSLEEP        2
#define HRTCANCEL       3

struct  hrtsysa {
        int     opcode;
};

struct  hrtcntla {
        int             opcode;
        int             cmd;
        int             clk;
        interval_t      *intp;
        hrtimes_t       *hrtp;
};

struct  hrtalarma {
        int     opcode;
        hrtcmd_t        *cmdp;
        int             cmds;
};


/*
 * Hrtcntl (time control) system call.
 */


/*ARGSUSED1*/
int
hrtcntl(uap, rvp)
        register struct hrtcntla *uap;
        rval_t  *rvp;
{
        register int    error = 0;
        hrtimes_t       temptofd;

        switch (uap->cmd) {

        case HRT_TOFD:  /* Get the time of day */

                if (uap->clk != CLK_STD) {
                        error = EINVAL;
                        break;
                }

                if (copyin((caddr_t)uap->hrtp,
                    (caddr_t)&temptofd, sizeof (hrtimes_t))) {
                        error = EFAULT;
                        break;
                }

                if ((error = hrt_checkres(temptofd.hrt_res)))
                        break;

                hrt_gettofd(&temptofd);

                if (copyout((caddr_t)&temptofd,
                    (caddr_t)uap->hrtp, sizeof (hrtimes_t)))
                        error = EFAULT;

                break;

        default:
                error = EINVAL;
                break;
        }
        return (error);
}

/*
 * Hrtalarm (start one or more alarms) system call.
 */

int
hrtalarm(uap, rvp)
        register struct hrtalarma *uap;
        rval_t  *rvp;
{
        register hrtcmd_t       *cp;
        hrtcmd_t                *hrcmdp;
        uint                    alarm_cnt;
        int                     cnt;
        int                     error = 0;
        int                     cmd;
        hrtcmd_t                timecmd;
        hrtimes_t               delay_ht;


        /*
         * Return EINVAL for negative and zero counts.
         */

        if (uap->cmds <= 0)
                return (EINVAL);

        cp = &timecmd;
        hrcmdp = uap->cmdp;
        alarm_cnt = 0;

        /* Loop through and process each command. */

        for (cnt = 0; cnt < uap->cmds; cnt++, hrcmdp++) {

                if (copyin((caddr_t)hrcmdp, (caddr_t)cp, sizeof (hrtcmd_t)))
                        return (EFAULT);

                cmd = cp->hrtc_cmd;

                /*
                 * If we try to post a Berkley Timer remove
                 * previous timers.
                 */

                if (cmd == HRT_BSD || cmd == HRT_BSD_REP)
                        (void) hrt_bsd_cancel(cp->hrtc_clk);

                /*      See what kind of command we have.  */

                switch (cmd) {
                case HRT_BSD:           /* one-shot timer */
                {
                        struct itimerval itv;
                        u_int which;

                        if ((error = hrt_checkclock(cp->hrtc_clk)) != 0)
                                break;
                        switch (cp->hrtc_clk) {
                        case CLK_STD:
                                which = ITIMER_REAL;
                                break;
                        case CLK_USERVIRT:
                                which = ITIMER_VIRTUAL;
                                break;
                        case CLK_PROCVIRT:
                                which = ITIMER_PROF;
                                break;
                        default:
                                error = EINVAL;
                                goto bad;
                        }
                        itv.it_value.tv_sec = cp->hrtc_int.hrt_secs;
                        itv.it_value.tv_usec = cp->hrtc_int.hrt_rem;
                        itv.it_interval.tv_sec = 0;
                        itv.it_interval.tv_usec = 0;
                        (void) xsetitimer(which, &itv, 1);

                        break;
                }

                case HRT_BSD_REP:
                {
                        struct itimerval itv;
                        u_int which;

                        switch (cp->hrtc_clk) {
                        case CLK_STD:
                                which = ITIMER_REAL;
                                break;
                        case CLK_USERVIRT:
                                which = ITIMER_VIRTUAL;
                                break;
                        case CLK_PROCVIRT:
                                which = ITIMER_PROF;
                                break;
                        default:
                                error = EINVAL;
                                goto bad;
                        }
                        itv.it_value.tv_sec = cp->hrtc_tod.hrt_secs;
                        itv.it_value.tv_usec = cp->hrtc_tod.hrt_rem;
                        itv.it_interval.tv_sec = cp->hrtc_int.hrt_secs;
                        itv.it_interval.tv_usec = cp->hrtc_int.hrt_rem;
                        (void) xsetitimer(which, &itv, 1);

                        break;
                }

                case HRT_BSD_PEND:
                        {
                                struct itimerval itv;
                                u_int which;

                                switch (cp->hrtc_clk) {
                                case CLK_STD:
                                        which = ITIMER_REAL;
                                        break;
                                case CLK_USERVIRT:
                                        which = ITIMER_VIRTUAL;
                                        break;
                                case CLK_PROCVIRT:
                                        which = ITIMER_PROF;
                                        break;
                                default:
                                        error = EINVAL;
                                        goto bad;
                                }
                                (void) xgetitimer(which, &itv, 1);
                                delay_ht.hrt_secs = itv.it_value.tv_sec;
                                delay_ht.hrt_rem = itv.it_value.tv_usec;
                        }

                        if (copyout((caddr_t)&delay_ht,
                            (caddr_t)&hrcmdp->hrtc_int, sizeof (hrtimes_t)))
                                error = EFAULT;

                        break;

                case HRT_BSD_CANCEL:
                        if ((error = hrt_checkclock(cp->hrtc_clk)) != 0)
                                break;

                        error = hrt_bsd_cancel(cp->hrtc_clk);

                        break;

                default :
                        error = EINVAL;
                        break;
                }
bad:
                if (error) {
                        cp->hrtc_flags |= HRTF_ERROR;
                        cp->hrtc_error = error;
                } else {
                        cp->hrtc_flags |= HRTF_DONE;
                        cp->hrtc_error = 0;
                        alarm_cnt++;
                }
                if (copyout((caddr_t)&cp->hrtc_flags,
                    (caddr_t)&hrcmdp->hrtc_flags,
                    sizeof (cp->hrtc_flags) + sizeof (cp->hrtc_error))) {
                        error = EFAULT;
                        return (error);
                }
        }
        rvp->r_val1 = alarm_cnt;
        return (0);
}


/*
 * Cancel BSD timers
 */

static int
hrt_bsd_cancel(int clock)
{
        struct itimerval itv;
        u_int which;

        switch (clock) {
        case CLK_STD:
                which = ITIMER_REAL;
                break;
        case CLK_USERVIRT:
                which = ITIMER_VIRTUAL;
                break;
        case CLK_PROCVIRT:
                which = ITIMER_PROF;
                break;
        default:
                return (EINVAL);
        }
        itv.it_value.tv_sec = 0;
        itv.it_value.tv_usec = 0;
        (void) xsetitimer(which, &itv, 1);
        return (0);
}


/*
 * Return 0 if "res" is a legal resolution. Otherwise,
 * return an error code, ERANGE.
 */

static int
hrt_checkres(ulong res)
{
        if (res == 0 || res > NANOSEC)
                return (ERANGE);
        return (0);
}

/*
 * Return 0 if "clock" is a valid clock. Otherwise,
 * return an error code, EINVAL.
 */

static int
hrt_checkclock(register int clock)
{
        switch (clock)
        case CLK_STD:
        case CLK_USERVIRT:
        case CLK_PROCVIRT:
                return (0);

        return (EINVAL);
}


/*
 * Set the current time of day in a specified resolution into
 * a hrtimes_t structure.
 */
void
hrt_gettofd(hrtimes_t *td)
{
        ulong new_res = td->hrt_res;
        timestruc_t ts;

        gethrestime(&ts);
        td->hrt_secs = ts.tv_sec;
        td->hrt_rem = ts.tv_nsec;
        td->hrt_res = NANOSEC;

        if (new_res != td->hrt_res) {
                td->hrt_rem /= NANOSEC / new_res;
                td->hrt_res = new_res;
        }
}


/*
 * System entry point for hrtcntl, hrtalarm
 * system calls.
 */

int
hrtsys(uap, rvp)
        register struct hrtsysa *uap;
        rval_t *rvp;
{
        register int    error;

        switch (uap->opcode) {
        case    HRTCNTL:
                error = hrtcntl((struct hrtcntla *)uap, rvp);
                break;
        case    HRTALARM:
                error = hrtalarm((struct hrtalarma *)uap, rvp);
                break;
        default:
                error = EINVAL;
                break;
        }

        return (error);
}