// SPDX-License-Identifier: GPL-2.0-or-later
/******************************************************************************
 *
 *      (C)Copyright 1998,1999 SysKonnect,
 *      a business unit of Schneider & Koch & Co. Datensysteme GmbH.
 *
 *      See the file "skfddi.c" for further information.
 *
 *      The information in this file is provided "AS IS" without warranty.
 *
 ******************************************************************************/

/*
        SMT timer
*/

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

static void timer_done(struct s_smc *smc, int restart);

void smt_timer_init(struct s_smc *smc)
{
        smc->t.st_queue = NULL;
        smc->t.st_fast.tm_active = FALSE ;
        smc->t.st_fast.tm_next = NULL;
        hwt_init(smc) ;
}

void smt_timer_stop(struct s_smc *smc, struct smt_timer *timer)
{
        struct smt_timer        **prev ;
        struct smt_timer        *tm ;

        /*
         * remove timer from queue
         */
        timer->tm_active = FALSE ;
        if (smc->t.st_queue == timer && !timer->tm_next) {
                hwt_stop(smc) ;
        }
        for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next ) {
                if (tm == timer) {
                        *prev = tm->tm_next ;
                        if (tm->tm_next) {
                                tm->tm_next->tm_delta += tm->tm_delta ;
                        }
                        return ;
                }
        }
}

void smt_timer_start(struct s_smc *smc, struct smt_timer *timer, u_long time,
                     u_long token)
{
        struct smt_timer        **prev ;
        struct smt_timer        *tm ;
        u_long                  delta = 0 ;

        time /= 16 ;            /* input is uS, clock ticks are 16uS */
        if (!time)
                time = 1 ;
        smt_timer_stop(smc,timer) ;
        timer->tm_smc = smc ;
        timer->tm_token = token ;
        timer->tm_active = TRUE ;
        if (!smc->t.st_queue) {
                smc->t.st_queue = timer ;
                timer->tm_next = NULL;
                timer->tm_delta = time ;
                hwt_start(smc,time) ;
                return ;
        }
        /*
         * timer correction
         */
        timer_done(smc,0) ;

        /*
         * find position in queue
         */
        delta = 0 ;
        for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next ) {
                if (delta + tm->tm_delta > time) {
                        break ;
                }
                delta += tm->tm_delta ;
        }
        /* insert in queue */
        *prev = timer ;
        timer->tm_next = tm ;
        timer->tm_delta = time - delta ;
        if (tm)
                tm->tm_delta -= timer->tm_delta ;
        /*
         * start new with first
         */
        hwt_start(smc,smc->t.st_queue->tm_delta) ;
}

void smt_force_irq(struct s_smc *smc)
{
        smt_timer_start(smc,&smc->t.st_fast,32L, EV_TOKEN(EVENT_SMT,SM_FAST)); 
}

void smt_timer_done(struct s_smc *smc)
{
        timer_done(smc,1) ;
}

static void timer_done(struct s_smc *smc, int restart)
{
        u_long                  delta ;
        struct smt_timer        *tm ;
        struct smt_timer        *next ;
        struct smt_timer        **last ;
        int                     done = 0 ;

        delta = hwt_read(smc) ;
        last = &smc->t.st_queue ;
        tm = smc->t.st_queue ;
        while (tm && !done) {
                if (delta >= tm->tm_delta) {
                        tm->tm_active = FALSE ;
                        delta -= tm->tm_delta ;
                        last = &tm->tm_next ;
                        tm = tm->tm_next ;
                }
                else {
                        tm->tm_delta -= delta ;
                        delta = 0 ;
                        done = 1 ;
                }
        }
        *last = NULL;
        next = smc->t.st_queue ;
        smc->t.st_queue = tm ;

        for ( tm = next ; tm ; tm = next) {
                next = tm->tm_next ;
                timer_event(smc,tm->tm_token) ;
        }

        if (restart && smc->t.st_queue)
                hwt_start(smc,smc->t.st_queue->tm_delta) ;
}