hwt.c

Go to the documentation of this file.

/******************************************************************************
 *
 *  (C)Copyright 1998,1999 SysKonnect,
 *  a business unit of Schneider & Koch & Co. Datensysteme GmbH.
 *
 *  See the file "skfddi.c" for further information.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  The information in this file is provided "AS IS" without warranty.
 *
 ******************************************************************************/

/*
 * Timer Driver for FBI board (timer chip 82C54)
 */

/*
 * Modifications:
 *
 *  28-Jun-1994 sw  Edit v1.6.
 *          MCA: Added support for the SK-NET FDDI-FM2 adapter. The
 *           following functions have been added(+) or modified(*):
 *           hwt_start(*), hwt_stop(*), hwt_restart(*), hwt_read(*)
 */

#include "h/types.h"
#include "h/fddi.h"
#include "h/smc.h"

#ifndef lint
static const char ID_sccs[] = "@(#)hwt.c    1.13 97/04/23 (C) SK " ;
#endif

/*
 * Prototypes of local functions.
 */
/* 28-Jun-1994 sw - Note: hwt_restart() is also used in module 'drvfbi.c'. */
/*static void hwt_restart() ; */

/************************
 *
 *  hwt_start
 *
 *  Start hardware timer (clock ticks are 16us).
 *
 *  void hwt_start(
 *      struct s_smc *smc,
 *      u_long time) ;
 * In
 *  smc - A pointer to the SMT Context structure.
 *
 *  time - The time in units of 16us to load the timer with.
 * Out
 *  Nothing.
 *
 ************************/
#define HWT_MAX (65000)

void hwt_start(struct s_smc *smc, u_long time)
{
    u_short cnt ;

    if (time > HWT_MAX)
        time = HWT_MAX ;

    smc->hw.t_start = time ;
    smc->hw.t_stop = 0L ;

    cnt = (u_short)time ;
    /*
     * if time < 16 us
     *  time = 16 us
     */
    if (!cnt)
        cnt++ ;

    outpd(ADDR(B2_TI_INI), (u_long) cnt * 200) ;    /* Load timer value. */
    outpw(ADDR(B2_TI_CRTL), TIM_START) ;        /* Start timer. */

    smc->hw.timer_activ = TRUE ;
}

/************************
 *
 *  hwt_stop
 *
 *  Stop hardware timer.
 *
 *  void hwt_stop(
 *      struct s_smc *smc) ;
 * In
 *  smc - A pointer to the SMT Context structure.
 * Out
 *  Nothing.
 *
 ************************/
void hwt_stop(struct s_smc *smc)
{
    outpw(ADDR(B2_TI_CRTL), TIM_STOP) ;
    outpw(ADDR(B2_TI_CRTL), TIM_CL_IRQ) ;

    smc->hw.timer_activ = FALSE ;
}

/************************
 *
 *  hwt_init
 *
 *  Initialize hardware timer.
 *
 *  void hwt_init(
 *      struct s_smc *smc) ;
 * In
 *  smc - A pointer to the SMT Context structure.
 * Out
 *  Nothing.
 *
 ************************/
void hwt_init(struct s_smc *smc)
{
    smc->hw.t_start = 0 ;
    smc->hw.t_stop  = 0 ;
    smc->hw.timer_activ = FALSE ;

    hwt_restart(smc) ;
}

/************************
 *
 *  hwt_restart
 *
 *  Clear timer interrupt.
 *
 *  void hwt_restart(
 *      struct s_smc *smc) ;
 * In
 *  smc - A pointer to the SMT Context structure.
 * Out
 *  Nothing.
 *
 ************************/
void hwt_restart(struct s_smc *smc)
{
    hwt_stop(smc) ;
}

/************************
 *
 *  hwt_read
 *
 *  Stop hardware timer and read time elapsed since last start.
 *
 *  u_long hwt_read(smc) ;
 * In
 *  smc - A pointer to the SMT Context structure.
 * Out
 *  The elapsed time since last start in units of 16us.
 *
 ************************/
u_long hwt_read(struct s_smc *smc)
{
    u_short tr ;
    u_long  is ;

    if (smc->hw.timer_activ) {
        hwt_stop(smc) ;
        tr = (u_short)((inpd(ADDR(B2_TI_VAL))/200) & 0xffff) ;

        is = GET_ISR() ;
        /* Check if timer expired (or wraparound). */
        if ((tr > smc->hw.t_start) || (is & IS_TIMINT)) {
            hwt_restart(smc) ;
            smc->hw.t_stop = smc->hw.t_start ;
        }
        else
            smc->hw.t_stop = smc->hw.t_start - tr ;
    }
    return smc->hw.t_stop;
}

#ifdef  PCI
/************************
 *
 *  hwt_quick_read
 *
 *  Stop hardware timer and read timer value and start the timer again.
 *
 *  u_long hwt_read(smc) ;
 * In
 *  smc - A pointer to the SMT Context structure.
 * Out
 *  current timer value in units of 80ns.
 *
 ************************/
u_long hwt_quick_read(struct s_smc *smc)
{
    u_long interval ;
    u_long time ;

    interval = inpd(ADDR(B2_TI_INI)) ;
    outpw(ADDR(B2_TI_CRTL), TIM_STOP) ;
    time = inpd(ADDR(B2_TI_VAL)) ;
    outpd(ADDR(B2_TI_INI),time) ;
    outpw(ADDR(B2_TI_CRTL), TIM_START) ;
    outpd(ADDR(B2_TI_INI),interval) ;

    return time;
}

/************************
 *
 *  hwt_wait_time(smc,start,duration)
 *
 *  This function returnes after the amount of time is elapsed
 *  since the start time.
 * 
 * para start       start time
 *  duration    time to wait
 *
 * NOTE: The function will return immediately, if the timer is not
 *   started
 ************************/
void hwt_wait_time(struct s_smc *smc, u_long start, long int duration)
{
    long    diff ;
    long    interval ;
    int wrapped ;

    /*
     * check if timer is running
     */
    if (smc->hw.timer_activ == FALSE ||
        hwt_quick_read(smc) == hwt_quick_read(smc)) {
        return ;
    }

    interval = inpd(ADDR(B2_TI_INI)) ;
    if (interval > duration) {
        do {
            diff = (long)(start - hwt_quick_read(smc)) ;
            if (diff < 0) {
                diff += interval ;
            }
        } while (diff <= duration) ;
    }
    else {
        diff = interval ;
        wrapped = 0 ;
        do {
            if (!wrapped) {
                if (hwt_quick_read(smc) >= start) {
                    diff += interval ;
                    wrapped = 1 ;
                }
            }
            else {
                if (hwt_quick_read(smc) < start) {
                    wrapped = 0 ;
                }
            }
        } while (diff <= duration) ;
    }
}
#endif