/*      $NetBSD: clock.c,v 1.64 2022/06/26 18:46:14 tsutsui Exp $       */

/*
* Copyright (c) 1988 University of Utah.
* Copyright (c) 1982, 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* the Systems Programming Group of the University of Utah Computer
* Science Department.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: Utah $Hdr: clock.c 1.18 91/01/21$
*
*      @(#)clock.c     7.6 (Berkeley) 5/7/91
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: clock.c,v 1.64 2022/06/26 18:46:14 tsutsui Exp $");

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/uio.h>
#include <sys/conf.h>
#include <sys/proc.h>
#include <sys/event.h>
#include <sys/timetc.h>

#include <dev/clock_subr.h>

#include <machine/psl.h>
#include <machine/cpu.h>
#include <machine/iomap.h>
#include <machine/mfp.h>
#include <atari/dev/clockreg.h>
#include <atari/dev/clockvar.h>
#include <atari/atari/device.h>

#if defined(GPROF) && defined(PROFTIMER)
#include <machine/profile.h>
#endif

#include "ioconf.h"

static int      atari_rtc_get(todr_chip_handle_t, struct clock_ymdhms *);
static int      atari_rtc_set(todr_chip_handle_t, struct clock_ymdhms *);

/*
* The MFP clock runs at 2457600Hz. We use a {system,stat,prof}clock divider
* of 200. Therefore the timer runs at an effective rate of:
* 2457600/200 = 12288Hz.
*/
#define CLOCK_HZ        12288

static u_int clk_getcounter(struct timecounter *);

static struct timecounter clk_timecounter = {
       .tc_get_timecount = clk_getcounter,
       .tc_counter_mask = ~0u,
       .tc_frequency = CLOCK_HZ,
       .tc_name = "clock",
       .tc_quality = 100,
};

/*
* Machine-dependent clock routines.
*
* Inittodr initializes the time of day hardware which provides
* date functions.
*
* Resettodr restores the time of day hardware after a time change.
*/

struct clock_softc {
       device_t        sc_dev;
       int             sc_flags;
       struct todr_chip_handle sc_handle;
};

/*
*  'sc_flags' state info. Only used by the rtc-device functions.
*/
#define RTC_OPEN        1

static dev_type_open(rtcopen);
static dev_type_close(rtcclose);
static dev_type_read(rtcread);
static dev_type_write(rtcwrite);

static void     clockattach(device_t, device_t, void *);
static int      clockmatch(device_t, cfdata_t, void *);

CFATTACH_DECL_NEW(clock, sizeof(struct clock_softc),
   clockmatch, clockattach, NULL, NULL);

const struct cdevsw rtc_cdevsw = {
       .d_open = rtcopen,
       .d_close = rtcclose,
       .d_read = rtcread,
       .d_write = rtcwrite,
       .d_ioctl = noioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = nommap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = 0
};

void statintr(struct clockframe);

static int      twodigits(char *, int);

static int      divisor;        /* Systemclock divisor  */

/*
* Statistics and profile clock intervals and variances. Variance must
* be a power of 2. Since this gives us an even number, not an odd number,
* we discard one case and compensate. That is, a variance of 64 would
* give us offsets in [0..63]. Instead, we take offsets in [1..63].
* This is symmetric around the point 32, or statvar/2, and thus averages
* to that value (assuming uniform random numbers).
*/
#ifdef STATCLOCK
static int      statvar = 32;   /* {stat,prof}clock variance            */
static int      statmin;        /* statclock divisor - variance/2       */
static int      profmin;        /* profclock divisor - variance/2       */
static int      clk2min;        /* current, from above choices          */
#endif

static int
clockmatch(device_t parent, cfdata_t cf, void *aux)
{

       if (!strcmp("clock", aux))
               return 1;
       return 0;
}

/*
* Start the real-time clock.
*/
static void
clockattach(device_t parent, device_t self, void *aux)
{
       struct clock_softc *sc = device_private(self);
       struct todr_chip_handle *tch;

       sc->sc_dev = self;
       tch = &sc->sc_handle;
       tch->todr_gettime_ymdhms = atari_rtc_get;
       tch->todr_settime_ymdhms = atari_rtc_set;
       tch->todr_setwen = NULL;

       todr_attach(tch);

       sc->sc_flags = 0;

       /*
        * Initialize Timer-A in the ST-MFP. We use a divisor of 200.
        * The MFP clock runs at 2457600Hz. Therefore the timer runs
        * at an effective rate of: 2457600/200 = 12288Hz. The
        * following expression works for 48, 64 or 96 hz.
        */
       divisor       = CLOCK_HZ/hz;
       MFP->mf_tacr  = 0;              /* Stop timer                   */
       MFP->mf_iera &= ~IA_TIMA;       /* Disable timer interrupts     */
       MFP->mf_tadr  = divisor;        /* Set divisor                  */

       clk_timecounter.tc_frequency = CLOCK_HZ;

       if (hz != 48 && hz != 64 && hz != 96) { /* XXX */
               aprint_normal(": illegal value %d for systemclock, reset to %d\n\t",
                                                               hz, 64);
               hz = 64;
       }
       aprint_normal(": system hz %d timer-A divisor 200/%d\n", hz, divisor);
       tc_init(&clk_timecounter);

#ifdef STATCLOCK
       if ((stathz == 0) || (stathz > hz) || (CLOCK_HZ % stathz))
               stathz = hz;
       if ((profhz == 0) || (profhz > (hz << 1)) || (CLOCK_HZ % profhz))
               profhz = hz << 1;

       MFP->mf_tcdcr &= 0x7;                   /* Stop timer           */
       MFP->mf_ierb  &= ~IB_TIMC;              /* Disable timer inter. */
       MFP->mf_tcdr   = CLOCK_HZ/stathz;       /* Set divisor          */

       statmin  = (CLOCK_HZ/stathz) - (statvar >> 1);
       profmin  = (CLOCK_HZ/profhz) - (statvar >> 1);
       clk2min  = statmin;
#endif /* STATCLOCK */
}

void
cpu_initclocks(void)
{

       MFP->mf_tacr  = T_Q200;         /* Start timer                  */
       MFP->mf_ipra  = (u_int8_t)~IA_TIMA;/* Clear pending interrupts  */
       MFP->mf_iera |= IA_TIMA;        /* Enable timer interrupts      */
       MFP->mf_imra |= IA_TIMA;        /*    .....                     */

#ifdef STATCLOCK
       MFP->mf_tcdcr = (MFP->mf_tcdcr & 0x7) | (T_Q200<<4); /* Start   */
       MFP->mf_iprb  = (u_int8_t)~IB_TIMC;/* Clear pending interrupts  */
       MFP->mf_ierb |= IB_TIMC;        /* Enable timer interrupts      */
       MFP->mf_imrb |= IB_TIMC;        /*    .....                     */
#endif /* STATCLOCK */
}

void
setstatclockrate(int newhz)
{

#ifdef STATCLOCK
       if (newhz == stathz)
               clk2min = statmin;
       else clk2min = profmin;
#endif /* STATCLOCK */
}

#ifdef STATCLOCK
void
statintr(struct clockframe frame)
{
       register int    var, r;

       var = statvar - 1;
       do {
               r = random() & var;
       } while (r == 0);

       /*
        * Note that we are always lagging behind as the new divisor
        * value will not be loaded until the next interrupt. This
        * shouldn't disturb the median frequency (I think ;-) ) as
        * only the value used when switching frequencies is used
        * twice. This shouldn't happen very often.
        */
       MFP->mf_tcdr = clk2min + r;

       statclock(&frame);
}
#endif /* STATCLOCK */

static u_int
clk_getcounter(struct timecounter *tc)
{
       uint32_t delta, count, cur_hardclock;
       uint8_t ipra, tadr;
       int s;
       static uint32_t lastcount;

       s = splhigh();
       cur_hardclock = getticks();
       ipra = MFP->mf_ipra;
       tadr = MFP->mf_tadr;
       delta = divisor - tadr;

       if (ipra & IA_TIMA)
               delta += divisor;
       splx(s);

       count = (divisor * cur_hardclock) + delta;
       if ((int32_t)(count - lastcount) < 0) {
               /* XXX wrapped; maybe hardclock() is blocked more than 2/HZ */
               count = lastcount + 1;
       }
       lastcount = count;

       return count;
}

#define TIMB_FREQ       614400
#define TIMB_LIMIT      256

void
init_delay(void)
{

       /*
        * Initialize Timer-B in the ST-MFP. This timer is used by
        * the 'delay' function below. This timer is setup to be
        * continueously counting from 255 back to zero at a
        * frequency of 614400Hz. We do this *early* in the
        * initialisation process.
        */
       MFP->mf_tbcr  = 0;              /* Stop timer                   */
       MFP->mf_iera &= ~IA_TIMB;       /* Disable timer interrupts     */
       MFP->mf_tbdr  = 0;
       MFP->mf_tbcr  = T_Q004; /* Start timer                  */
}

/*
* Wait "n" microseconds.
* Relies on MFP-Timer B counting down from TIMB_LIMIT at TIMB_FREQ Hz.
* Note: timer had better have been programmed before this is first used!
*/
void
delay(unsigned int n)
{
       int     ticks, otick, remaining;

       /*
        * Read the counter first, so that the rest of the setup overhead is
        * counted.
        */
       otick = MFP->mf_tbdr;

       if (n <= UINT_MAX / TIMB_FREQ) {
               /*
                * For unsigned arithmetic, division can be replaced with
                * multiplication with the inverse and a shift.
                */
               remaining = n * TIMB_FREQ / 1000000;
       } else {
               /* This is a very long delay.
                * Being slow here doesn't matter.
                */
               remaining = (unsigned long long) n * TIMB_FREQ / 1000000;
       }

       while (remaining > 0) {
               ticks = MFP->mf_tbdr;
               if (ticks > otick)
                       remaining -= TIMB_LIMIT - (ticks - otick);
               else
                       remaining -= otick - ticks;
               otick = ticks;
       }
}

#ifdef GPROF
/*
* profclock() is expanded in line in lev6intr() unless profiling kernel.
* Assumes it is called with clock interrupts blocked.
*/
profclock(void *pc, int ps)
{

       /*
        * Came from user mode.
        * If this process is being profiled record the tick.
        */
       if (USERMODE(ps)) {
               if (p->p_stats.p_prof.pr_scale)
                       addupc(pc, &curproc->p_stats.p_prof, 1);
       }
       /*
        * Came from kernel (supervisor) mode.
        * If we are profiling the kernel, record the tick.
        */
       else if (profiling < 2) {
               register int s = pc - s_lowpc;

               if (s < s_textsize)
                       kcount[s / (HISTFRACTION * sizeof(*kcount))]++;
       }
       /*
        * Kernel profiling was on but has been disabled.
        * Mark as no longer profiling kernel and if all profiling done,
        * disable the clock.
        */
       if (profiling && (profon & PRF_KERNEL)) {
               profon &= ~PRF_KERNEL;
               if (profon == PRF_NONE)
                       stopprofclock();
       }
}
#endif

/***********************************************************************
*                   Real Time Clock support                           *
***********************************************************************/

u_int mc146818_read(void *cookie, u_int regno)
{
       struct rtc *rtc = cookie;

       rtc->rtc_regno = regno;
       return rtc->rtc_data & 0xff;
}

void mc146818_write(void *cookie, u_int regno, u_int value)
{
       struct rtc *rtc = cookie;

       rtc->rtc_regno = regno;
       rtc->rtc_data  = value;
}

static int
atari_rtc_get(todr_chip_handle_t todr, struct clock_ymdhms *dtp)
{
       int                     sps;
       mc_todregs              clkregs;
       u_int                   regb;

       sps = splhigh();
       regb = mc146818_read(RTC, MC_REGB);
       MC146818_GETTOD(RTC, &clkregs);
       splx(sps);

       regb &= MC_REGB_24HR|MC_REGB_BINARY;
       if (regb != (MC_REGB_24HR|MC_REGB_BINARY)) {
               printf("Error: Nonstandard RealTimeClock Configuration -"
                       " value ignored\n"
                       "       A write to /dev/rtc will correct this.\n");
                       return 0;
       }
       if (clkregs[MC_SEC] > 59)
               return -1;
       if (clkregs[MC_MIN] > 59)
               return -1;
       if (clkregs[MC_HOUR] > 23)
               return -1;
       if (range_test(clkregs[MC_DOM], 1, 31))
               return -1;
       if (range_test(clkregs[MC_MONTH], 1, 12))
               return -1;
       if (clkregs[MC_YEAR] > 99)
               return -1;

       dtp->dt_year = clkregs[MC_YEAR] + GEMSTARTOFTIME;
       dtp->dt_mon  = clkregs[MC_MONTH];
       dtp->dt_day  = clkregs[MC_DOM];
       dtp->dt_hour = clkregs[MC_HOUR];
       dtp->dt_min  = clkregs[MC_MIN];
       dtp->dt_sec  = clkregs[MC_SEC];

       return 0;
}

static int
atari_rtc_set(todr_chip_handle_t todr, struct clock_ymdhms *dtp)
{
       int s;
       mc_todregs clkregs;

       clkregs[MC_YEAR] = dtp->dt_year - GEMSTARTOFTIME;
       clkregs[MC_MONTH] = dtp->dt_mon;
       clkregs[MC_DOM] = dtp->dt_day;
       clkregs[MC_HOUR] = dtp->dt_hour;
       clkregs[MC_MIN] = dtp->dt_min;
       clkregs[MC_SEC] = dtp->dt_sec;

       s = splclock();
       MC146818_PUTTOD(RTC, &clkregs);
       splx(s);

       return 0;
}

/***********************************************************************
*                   RTC-device support                                *
***********************************************************************/
static int
rtcopen(dev_t dev, int flag, int mode, struct lwp *l)
{
       int                     unit = minor(dev);
       struct clock_softc      *sc;

       sc = device_lookup_private(&clock_cd, unit);
       if (sc == NULL)
               return ENXIO;
       if (sc->sc_flags & RTC_OPEN)
               return EBUSY;

       sc->sc_flags = RTC_OPEN;
       return 0;
}

static int
rtcclose(dev_t dev, int flag, int mode, struct lwp *l)
{
       int                     unit = minor(dev);
       struct clock_softc      *sc = device_lookup_private(&clock_cd, unit);

       sc->sc_flags = 0;
       return 0;
}

static int
rtcread(dev_t dev, struct uio *uio, int flags)
{
       mc_todregs              clkregs;
       int                     s, length;
       char                    buffer[16 + 1];

       s = splhigh();
       MC146818_GETTOD(RTC, &clkregs);
       splx(s);

       snprintf(buffer, sizeof(buffer), "%4d%02d%02d%02d%02d.%02d\n",
           clkregs[MC_YEAR] + GEMSTARTOFTIME,
           clkregs[MC_MONTH], clkregs[MC_DOM],
           clkregs[MC_HOUR], clkregs[MC_MIN], clkregs[MC_SEC]);

       if (uio->uio_offset > strlen(buffer))
               return 0;

       length = strlen(buffer) - uio->uio_offset;
       if (length > uio->uio_resid)
               length = uio->uio_resid;

       return uiomove((void *)buffer, length, uio);
}

static int
twodigits(char *buffer, int pos)
{
       int result = 0;

       if (buffer[pos] >= '0' && buffer[pos] <= '9')
               result = (buffer[pos] - '0') * 10;
       if (buffer[pos+1] >= '0' && buffer[pos+1] <= '9')
               result += (buffer[pos+1] - '0');
       return result;
}

static int
rtcwrite(dev_t dev, struct uio *uio, int flags)
{
       mc_todregs              clkregs;
       int                     s, length, error;
       char                    buffer[16];

       /*
        * We require atomic updates!
        */
       length = uio->uio_resid;
       if (uio->uio_offset || (length != sizeof(buffer)
           && length != sizeof(buffer) - 1))
               return EINVAL;

       if ((error = uiomove((void *)buffer, sizeof(buffer), uio)))
               return error;

       if (length == sizeof(buffer) && buffer[sizeof(buffer) - 1] != '\n')
               return EINVAL;

       s = splclock();
       mc146818_write(RTC, MC_REGB,
           mc146818_read(RTC, MC_REGB) | MC_REGB_24HR | MC_REGB_BINARY);
       MC146818_GETTOD(RTC, &clkregs);
       splx(s);

       clkregs[MC_SEC]   = twodigits(buffer, 13);
       clkregs[MC_MIN]   = twodigits(buffer, 10);
       clkregs[MC_HOUR]  = twodigits(buffer, 8);
       clkregs[MC_DOM]   = twodigits(buffer, 6);
       clkregs[MC_MONTH] = twodigits(buffer, 4);
       s = twodigits(buffer, 0) * 100 + twodigits(buffer, 2);
       clkregs[MC_YEAR]  = s - GEMSTARTOFTIME;

       s = splclock();
       MC146818_PUTTOD(RTC, &clkregs);
       splx(s);

       return 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.