/**

 * $Id$

 * SCIF (Serial Communication Interface with FIFO) implementation - part of the 

 * SH4 standard on-chip peripheral set. The SCIF is hooked up to the DCs

 * external serial port

 *

 * Copyright (c) 2005 Nathan Keynes.

 *

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

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#include <glib.h>

#include "dream.h"

#include "mem.h"

#include "sh4/sh4core.h"

#include "sh4/sh4mmio.h"

#include "sh4/intc.h"

#include "sh4/dmac.h"

#include "clock.h"

#include "serial.h"

void SCIF_set_break(void);

void SCIF_run_to(uint32_t nanosecs);

/************************* External serial interface ************************/

/**

 * Note: serial_* operations are called from outside the SH4, and as such are

 * named relative to the external serial device. SCIF_* operations are only

 * called internally to the SH4 and so are named relative to the CPU.

 */

/**

 * Storage space for inbound/outbound data blocks. It's a little more

 * convenient for serial consumers to be able to deal with block-sized pieces

 * rather than a byte at a time, even if it makes all this look rather

 * complicated.

 *

 * Currently there's no limit on the number of blocks that can be queued up.

 */

typedef struct serial_data_block {

    uint32_t length;

    uint32_t offset;

    struct serial_data_block *next;

    char data[];

} *serial_data_block_t;

serial_data_block_t serial_recvq_head = NULL, serial_recvq_tail = NULL;

serial_device_t serial_device = NULL;

serial_device_t serial_get_device( )

{

    return serial_device;

}

serial_device_t serial_attach_device( serial_device_t dev ) 

{

    serial_device_t olddev = serial_device;

    if( serial_device != NULL )

        serial_detach_device();

    serial_device = dev;

    if( serial_device != NULL && serial_device->attach != NULL )

        serial_device->attach(serial_device);

    return olddev;

}

serial_device_t serial_detach_device( void )

{

    serial_device_t dev = serial_device;

    if( serial_device != NULL && serial_device->detach != NULL ) {

        serial_device->detach(serial_device);

    }

    serial_device = NULL;

    return dev;

}

void serial_destroy_device( serial_device_t dev )

{

    if( dev != NULL ) {

        if( serial_device == dev )

            serial_detach_device();

        if( dev->destroy )

            dev->destroy(dev);

    }

}

/**

 * Add a block of data to the serial receive queue. The data will be received

 * by the CPU at the appropriate baud rate.

 */

void serial_transmit_data( char *data, int length ) {

    if( length == 0 )

        return;

    serial_data_block_t block = 

        g_malloc( sizeof( struct serial_data_block ) + length );

    block->length = length;

    block->offset = 0;

    block->next = NULL;

    memcpy( block->data, data, length );

    if( serial_recvq_head == NULL ) {

        serial_recvq_head = serial_recvq_tail = block;

    } else {

        serial_recvq_tail->next = block;

        serial_recvq_tail = block;

    }

}

/**

 * Dequeue a byte from the serial input queue

 */

static int serial_transmit_dequeue( ) {

    if( serial_recvq_head != NULL ) {

        uint8_t val = serial_recvq_head->data[serial_recvq_head->offset++];

        if( serial_recvq_head->offset >= serial_recvq_head->length ) {

            serial_data_block_t next = serial_recvq_head->next;

            g_free( serial_recvq_head );

            serial_recvq_head = next;

            if( next == NULL )

                serial_recvq_tail = NULL;

        }

        return (int)(unsigned int)val;

    }

    return -1;

}

void serial_transmit_break() {

    SCIF_set_break();

}

/********************************* SCIF *************************************/

#define FIFO_LENGTH 16

#define FIFO_ARR_LENGTH (FIFO_LENGTH+1)

/* Serial control register flags */

#define SCSCR2_TIE  0x80

#define SCSCR2_RIE  0x40

#define SCSCR2_TE   0x20

#define SCSCR2_RE   0x10

#define SCSCR2_REIE 0x08

#define SCSCR2_CKE 0x02

#define IS_TRANSMIT_IRQ_ENABLED() (MMIO_READ(SCIF,SCSCR2) & SCSCR2_TIE)

#define IS_RECEIVE_IRQ_ENABLED() (MMIO_READ(SCIF,SCSCR2) & SCSCR2_RIE)

#define IS_RECEIVE_ERROR_IRQ_ENABLED() (MMIO_READ(SCIF,SCSCR2) & (SCSCR2_RIE|SCSCR2_REIE))

/* Receive is enabled if the RE bit is set in SCSCR2, and the ORER bit is cleared in SCLSR2 */

#define IS_RECEIVE_ENABLED() ( (MMIO_READ(SCIF,SCSCR2) & SCSCR2_RE) && ((MMIO_READ(SCIF,SCLSR2) & SCLSR2_ORER) == 0) )

/* Transmit is enabled if the TE bit is set in SCSCR2 */

#define IS_TRANSMIT_ENABLED() (MMIO_READ(SCIF,SCSCR2) & SCSCR2_TE)

#define IS_LOOPBACK_ENABLED() (MMIO_READ(SCIF,SCFCR2) & SCFCR2_LOOP)

/* Serial status register flags */

#define SCFSR2_ER   0x80

#define SCFSR2_TEND 0x40

#define SCFSR2_TDFE 0x20

#define SCFSR2_BRK  0x10

#define SCFSR2_RDF  0x02

#define SCFSR2_DR   0x01

/* FIFO control register flags */

#define SCFCR2_MCE   0x08

#define SCFCR2_TFRST 0x04

#define SCFCR2_RFRST 0x02

#define SCFCR2_LOOP  0x01

/* Line Status Register */

#define SCLSR2_ORER 0x01

struct SCIF_fifo {

    int head;

    int tail;

    int trigger;

    uint8_t data[FIFO_ARR_LENGTH];

};

int SCIF_recvq_triggers[4] = {1, 4, 8, 14};

struct SCIF_fifo SCIF_recvq = {0,0,1};

int SCIF_sendq_triggers[4] = {8, 4, 2, 1};

struct SCIF_fifo SCIF_sendq = {0,0,8};

/**

 * Flag to indicate if data was received (ie added to the receive queue)

 * during the last SCIF clock tick. Used to determine when to set the DR

 * flag.

 */

gboolean SCIF_rcvd_last_tick = FALSE;

uint32_t SCIF_tick_period = 0;

uint32_t SCIF_tick_remainder = 0;

uint32_t SCIF_slice_cycle = 0;

void SCIF_save_state( FILE *f ) 

{

    fwrite( &SCIF_recvq, sizeof(SCIF_recvq), 1, f );

    fwrite( &SCIF_sendq, sizeof(SCIF_sendq), 1, f );

    fwrite( &SCIF_rcvd_last_tick, sizeof(gboolean), 1, f );

}

int SCIF_load_state( FILE *f ) 

{

    fread( &SCIF_recvq, sizeof(SCIF_recvq), 1, f );

    fread( &SCIF_sendq, sizeof(SCIF_sendq), 1, f );

    fread( &SCIF_rcvd_last_tick, sizeof(gboolean), 1, f );

    return 0;

}

static inline uint8_t SCIF_recvq_size( ) 

{

    int val = SCIF_recvq.tail - SCIF_recvq.head;

    if( val < 0 ) {

        val = FIFO_ARR_LENGTH - SCIF_recvq.head + SCIF_recvq.tail;

    }

    return val;

}

int SCIF_recvq_dequeue( gboolean clearFlags )

{

    uint8_t result;

    uint32_t tmp, length;

    if( SCIF_recvq.head == SCIF_recvq.tail )

        return -1; /* No data */

    result = SCIF_recvq.data[SCIF_recvq.head++];

    if( SCIF_recvq.head > FIFO_LENGTH )

        SCIF_recvq.head = 0;

    /* Update data count register */

    tmp = MMIO_READ( SCIF, SCFDR2 ) & 0xF0;

    length = SCIF_recvq_size();

    MMIO_WRITE( SCIF, SCFDR2, tmp | length );

    /* Clear flags (if requested ) */

    if( clearFlags && length < SCIF_recvq.trigger ) {

        tmp = SCFSR2_RDF;

        if( length == 0 )

            tmp |= SCFSR2_DR;

        tmp = MMIO_READ( SCIF, SCFSR2 ) & (~tmp);

        MMIO_WRITE( SCIF, SCFSR2, tmp );

        /* If both flags are cleared, clear the interrupt as well */

        if( (tmp & (SCFSR2_DR|SCFSR2_RDF)) == 0 && IS_RECEIVE_IRQ_ENABLED() )

            intc_clear_interrupt( INT_SCIF_RXI );

    }

    return (int)(unsigned int)result;

}

gboolean SCIF_recvq_enqueue( uint8_t value )

{

    uint32_t tmp, length;

    int newpos = SCIF_recvq.tail + 1;

    if( newpos > FIFO_LENGTH )

        newpos = 0;

    if( newpos == SCIF_recvq.head ) {

        /* FIFO full - set ORER and discard the value */

        MMIO_WRITE( SCIF, SCLSR2, SCLSR2_ORER );

        if( IS_RECEIVE_ERROR_IRQ_ENABLED() )

            intc_raise_interrupt( INT_SCIF_ERI );

        return FALSE;

    }

    SCIF_recvq.data[SCIF_recvq.tail] = value;

    /* Update data count register */

    tmp = MMIO_READ( SCIF, SCFDR2 ) & 0xF0;

    length = SCIF_recvq_size();

    MMIO_WRITE( SCIF, SCFDR2, tmp | length );

    /* Update status register */

    tmp = MMIO_READ( SCIF, SCFSR2 );

    if( length >= SCIF_recvq.trigger ) {

        tmp |= SCFSR2_RDF;

        if( IS_RECEIVE_IRQ_ENABLED() ) 

            intc_raise_interrupt( INT_SCIF_RXI );

        DMAC_trigger( DMAC_SCIF_RDF );

    }

    MMIO_WRITE( SCIF, SCFSR2, tmp );

    return TRUE;

}

/**

 * Reset the receive FIFO to its initial state. Manual is unclear as to

 * whether this also clears flags/interrupts, but we're assuming here that

 * it does until proven otherwise.

 */

void SCIF_recvq_clear( void ) 

{

    SCIF_recvq.head = SCIF_recvq.tail = 0;

    MMIO_WRITE( SCIF, SCFDR2, MMIO_READ( SCIF, SCFDR2 ) & 0xF0 );

    MMIO_WRITE( SCIF, SCFSR2, MMIO_READ( SCIF, SCFSR2 ) & ~(SCFSR2_DR|SCFSR2_RDF) );

    if( IS_RECEIVE_IRQ_ENABLED() )

        intc_clear_interrupt( INT_SCIF_RXI );

}

static inline uint8_t SCIF_sendq_size( ) 

{

    int val = SCIF_sendq.tail - SCIF_sendq.head;

    if( val < 0 ) {

        val = FIFO_ARR_LENGTH - SCIF_sendq.head + SCIF_sendq.tail;

    }

    return val;

}

/**

 * Dequeue one byte from the SCIF transmit queue (ie transmit the byte),

 * updating all status flags as required.

 * @return The byte dequeued, or -1 if the queue is empty.

 */

int SCIF_sendq_dequeue( )

{

    uint8_t result;

    uint32_t tmp, length;

    if( SCIF_sendq.head == SCIF_sendq.tail )

        return -1; /* No data */

    /* Update queue head pointer */

    result = SCIF_sendq.data[SCIF_sendq.head++];

    if( SCIF_sendq.head > FIFO_LENGTH )

        SCIF_sendq.head = 0;

    /* Update data count register */

    tmp = MMIO_READ( SCIF, SCFDR2 ) & 0x0F;

    length = SCIF_sendq_size();

    MMIO_WRITE( SCIF, SCFDR2, tmp | (length << 8) );

    /* Update status register */

    if( length <= SCIF_sendq.trigger ) {

        tmp = MMIO_READ( SCIF, SCFSR2 ) | SCFSR2_TDFE;

        if( length == 0 )

            tmp |= SCFSR2_TEND; /* Transmission ended - no data waiting */

        if( IS_TRANSMIT_IRQ_ENABLED() ) 

            intc_raise_interrupt( INT_SCIF_TXI );

        DMAC_trigger( DMAC_SCIF_TDE );

        MMIO_WRITE( SCIF, SCFSR2, tmp );

    }

    return (int)(unsigned int)result;

}

/**

 * Enqueue a single byte in the SCIF transmit queue. If the queue is full,

 * the value will be discarded.

 * @param value to be queued.

 * @param clearFlags TRUE if the TEND/TDFE flags should be cleared

 *   if the queue exceeds the trigger level. (According to the manual,

 *   DMAC writes will clear the flag, whereas regular SH4 writes do NOT

 *   automatically clear it. Go figure).

 * @return gboolean TRUE if the value was queued, FALSE if the queue was

 *   full.

 */

gboolean SCIF_sendq_enqueue( uint8_t value, gboolean clearFlags )

{

    uint32_t tmp, length;

    int newpos = SCIF_sendq.tail + 1;

    if( newpos > FIFO_LENGTH )

        newpos = 0;

    if( newpos == SCIF_sendq.head ) {

        /* FIFO full - discard */

        return FALSE;

    }

    SCIF_sendq.data[SCIF_sendq.tail] = value;

    SCIF_sendq.tail = newpos;

    /* Update data count register */

    tmp = MMIO_READ( SCIF, SCFDR2 ) & 0x0F;

    length = SCIF_sendq_size();

    MMIO_WRITE( SCIF, SCFDR2, tmp | (length << 8) );

    /* Update flags if requested */

    if( clearFlags ) {

        tmp = SCFSR2_TEND;

        if( length > SCIF_sendq.trigger ) {

            tmp |= SCFSR2_TDFE;

            if( IS_TRANSMIT_IRQ_ENABLED() )

                intc_clear_interrupt( INT_SCIF_TXI );

        }

        tmp = MMIO_READ( SCIF, SCFSR2 ) & (~tmp);

        MMIO_WRITE( SCIF, SCFSR2, tmp );

    }

    return TRUE;

}

void SCIF_sendq_clear( void ) 

{

    SCIF_sendq.head = SCIF_sendq.tail = 0;

    MMIO_WRITE( SCIF, SCFDR2, MMIO_READ( SCIF, SCFDR2 ) & 0x0F );

    MMIO_WRITE( SCIF, SCFSR2, MMIO_READ( SCIF, SCFSR2 ) | SCFSR2_TEND | SCFSR2_TDFE );

    if( IS_TRANSMIT_IRQ_ENABLED() ) {

        intc_raise_interrupt( INT_SCIF_TXI );

        DMAC_trigger( DMAC_SCIF_TDE );

    }

}

/**

 * Update the SCFSR2 status register with the given mask (ie clear any values

 * that are set to 0 in the mask. According to a strict reading of the doco

 * though, the bits will only actually clear if the flag state is no longer

 * true, so we need to recheck everything...

 */

void SCIF_update_status( uint32_t mask )

{

    uint32_t value = MMIO_READ( SCIF, SCFSR2 );

    uint32_t result = value & mask;

    uint32_t sendq_size = SCIF_sendq_size();

    uint32_t recvq_size = SCIF_recvq_size();

    if( sendq_size != 0 )

        result |= SCFSR2_TEND;

    if( sendq_size <= SCIF_sendq.trigger )

        result |= SCFSR2_TDFE;

    else if( (result & SCFSR2_TDFE) == 0 && IS_TRANSMIT_IRQ_ENABLED() )

        intc_clear_interrupt( INT_SCIF_TXI );

    if( recvq_size >= SCIF_recvq.trigger )

        result |= SCFSR2_RDF;

    if( (value & SCFSR2_DR) != 0 && (result & SCFSR2_DR) == 0 &&

            recvq_size != 0 )

        result |= SCFSR2_DR;

    if( (result & (SCFSR2_DR|SCFSR2_RDF)) == 0 && IS_RECEIVE_IRQ_ENABLED() )

        intc_clear_interrupt( INT_SCIF_RXI );

    if( IS_RECEIVE_ERROR_IRQ_ENABLED() ) {

        if( (result & SCFSR2_BRK) == 0 )

            intc_clear_interrupt( INT_SCIF_BRI );

        if( (result & SCFSR2_ER) == 0 && 

                (MMIO_READ( SCIF, SCLSR2 ) & SCLSR2_ORER) == 0 )

            intc_clear_interrupt( INT_SCIF_ERI );

    }

    MMIO_WRITE( SCIF, SCFSR2, result );

}

/**

 * Set the break detected flag

 */

void SCIF_set_break( void ) 

{

    MMIO_WRITE( SCIF, SCFSR2, MMIO_READ( SCIF, SCFSR2 ) | SCFSR2_BRK );

    if( IS_RECEIVE_ERROR_IRQ_ENABLED() )

        intc_raise_interrupt( INT_SCIF_BRI );

}

const static int SCIF_CLOCK_MULTIPLIER[4] = {1, 4, 16, 64};

/**

 * Calculate the current line speed.

 */

void SCIF_update_line_speed( void )

{

    /* If CKE1 is set, use the external clock as a base */

    if( MMIO_READ( SCIF, SCSCR2 ) & SCSCR2_CKE ) {

    } else {

        /* Otherwise, SH4 peripheral clock divided by n */

        int mult = SCIF_CLOCK_MULTIPLIER[MMIO_READ( SCIF, SCSMR2 ) & 0x03];

        /* Then process the bitrate register */

        int bbr = MMIO_READ( SCIF, SCBRR2 ) & 0xFF;

        SCIF_tick_period = sh4_peripheral_period * (32 * mult * (bbr+1));

        int baudrate = 1000000000 / SCIF_tick_period;

        if( serial_device != NULL && serial_device->set_line_speed != NULL )

            serial_device->set_line_speed( serial_device, baudrate );

        /*

	  clock_set_tick_rate( CLOCK_SCIF, baudrate / 10 );

         */

    }

}

MMIO_REGION_READ_FN( SCIF, reg )

{

    SCIF_run_to(sh4r.slice_cycle);

    reg &= 0xFFF;

    switch( reg ) {

    case SCFRDR2: /* Receive data */

        return SCIF_recvq_dequeue(FALSE);

    default:

        return MMIO_READ( SCIF, reg );

    }

}

MMIO_REGION_READ_DEFSUBFNS(SCIF)

MMIO_REGION_WRITE_FN( SCIF, reg, val )

{

    SCIF_run_to(sh4r.slice_cycle);

    uint32_t tmp;

    reg &= 0xFFF;

    switch( reg ) {

    case SCSMR2: /* Serial mode register */

        /* Bit 6 => 0 = 8-bit, 1 = 7-bit

         * Bit 5 => 0 = Parity disabled, 1 = parity enabled

         * Bit 4 => 0 = Even parity, 1 = Odd parity

         * Bit 3 => 0 = 1 stop bit, 1 = 2 stop bits

         * Bits 0-1 => Clock select 00 = P, 01 = P/4, 10 = P/16, 11 = P/64

         */

        val &= 0x007B;

        if( serial_device != NULL ) {

            serial_device->set_line_params( serial_device, val );

        }

        tmp = MMIO_READ( SCIF, SCSMR2 );

        if( (tmp & 0x03) != (val & 0x03) ) {

            /* Clock change */

            SCIF_update_line_speed( );

        }

        /* Save for later read-back */

        MMIO_WRITE( SCIF, SCSMR2, val );

        break;

    case SCBRR2: /* Bit rate register */

        MMIO_WRITE( SCIF, SCBRR2, val );

        SCIF_update_line_speed( );

        break;

    case SCSCR2: /* Serial control register */

        /* Bit 7 => Transmit-FIFO-data-empty interrupt enabled 

         * Bit 6 => Receive-data-full interrupt enabled 

         * Bit 5 => Transmit enable 

         * Bit 4 => Receive enable 

         * Bit 3 => Receive-error/break interrupt enabled

         * Bit 1 => Clock enable

         */

        val &= 0x00FA;

        /* Clear any interrupts that just became disabled */

        if( (val & SCSCR2_TIE) == 0 )

            intc_clear_interrupt( INT_SCIF_TXI );

        if( (val & SCSCR2_RIE) == 0 )

            intc_clear_interrupt( INT_SCIF_RXI );

        if( (val & (SCSCR2_RIE|SCSCR2_REIE)) == 0 ) {

            intc_clear_interrupt( INT_SCIF_ERI );

            intc_clear_interrupt( INT_SCIF_BRI );

        }

        MMIO_WRITE( SCIF, reg, val );

        break;

    case SCFTDR2: /* Transmit FIFO data register */

        SCIF_sendq_enqueue( val, FALSE );

        break;

    case SCFSR2: /* Serial status register */

        /* Bits 12-15 Parity error count

         * Bits 8-11 Framing erro count 

         * Bit 7 - Receive error

         * Bit 6 - Transmit end

         * Bit 5 - Transmit FIFO data empty

         * Bit 4 - Break detect

         * Bit 3 - Framing error

         * Bit 2 - Parity error

         * Bit 1 - Receive FIFO data full

         * Bit 0 - Receive data ready

         */

        /* Clear off any flags/interrupts that are being set to 0 */

        SCIF_update_status( val );

        break;

    case SCFCR2: /* FIFO control register */

        val &= 0x0F;

        SCIF_recvq.trigger = SCIF_recvq_triggers[val >> 6];

        SCIF_sendq.trigger = SCIF_sendq_triggers[(val >> 4) & 0x03];

        if( val & SCFCR2_TFRST ) {

            SCIF_sendq_clear();

        }

        if( val & SCFCR2_RFRST ) {

            SCIF_recvq_clear();

        }

        MMIO_WRITE( SCIF, reg, val );

        break;

    case SCSPTR2: /* Serial Port Register */

        MMIO_WRITE( SCIF, reg, val );

        /* NOT IMPLEMENTED - 'direct' serial I/O */

        if( val != 0 ) {

            WARN( "SCSPTR2 not implemented: Write %08X", val );

        }

        break;

    case SCLSR2:

        val = val & SCLSR2_ORER;

        if( val == 0 ) {

            MMIO_WRITE( SCIF, SCLSR2, val );

            if( (MMIO_READ( SCIF, SCFSR2 ) & SCFSR2_ER) == 0 &&

                    IS_RECEIVE_ERROR_IRQ_ENABLED() ) 

                intc_clear_interrupt( INT_SCIF_ERI );

        }

        break;

    }

}

/**

 * Actions for a single tick of the serial clock, defined as the transmission

 * time of a single frame.

 *

 * If transmit queue is non-empty:

 *    Transmit one byte and remove from queue

 * If input receive source is non-empty:

 *    Transfer one byte to the receive queue (if queue is full, byte is lost)

 * If recvq is non-empty, less than the trigger level, and no data has been

 *    received in the last 2 ticks (including this one), set the DR flag and

 *    IRQ if appropriate.

 */

void SCIF_clock_tick( void ) 

{

    gboolean rcvd = FALSE;

    if( IS_LOOPBACK_ENABLED() ) {

        if( IS_TRANSMIT_ENABLED() ) {

            int val = SCIF_sendq_dequeue();

            if( val != -1 && IS_RECEIVE_ENABLED() ) {

                SCIF_recvq_enqueue( val );

                rcvd = TRUE;

            }

        }

    } else {

        if( IS_TRANSMIT_ENABLED() ) {

            int val = SCIF_sendq_dequeue();

            if( val != -1 && serial_device != NULL && 

                    serial_device->receive_data != NULL ) {

                serial_device->receive_data( serial_device, val );

            }

        }

        if( IS_RECEIVE_ENABLED() ) {

            int val = serial_transmit_dequeue();

            if( val != -1 ) {

                SCIF_recvq_enqueue( val );

                rcvd = TRUE;

            }

        }

    }

    /* Check if we need to set the DR flag */

    if( !rcvd && !SCIF_rcvd_last_tick &&

            SCIF_recvq.head != SCIF_recvq.tail &&

            SCIF_recvq_size() < SCIF_recvq.trigger ) {

        uint32_t tmp = MMIO_READ( SCIF, SCFSR2 );

        if( (tmp & SCFSR2_DR) == 0 ) {

            MMIO_WRITE( SCIF, SCFSR2, tmp | SCFSR2_DR );

            if( IS_RECEIVE_IRQ_ENABLED() )

                intc_raise_interrupt( INT_SCIF_RXI );

            DMAC_trigger( DMAC_SCIF_RDF );

        }

    }

    SCIF_rcvd_last_tick = rcvd;

}

void SCIF_reset( void )

{

    SCIF_recvq_clear();

    SCIF_sendq_clear();

    SCIF_update_line_speed();

}

void SCIF_run_to( uint32_t nanosecs )

{

    SCIF_tick_remainder += nanosecs - SCIF_slice_cycle;

    while( SCIF_tick_remainder >= SCIF_tick_period ) {

        SCIF_tick_remainder -= SCIF_tick_period;

        SCIF_clock_tick();

    }

    SCIF_slice_cycle = nanosecs;

}

void SCIF_run_slice( uint32_t nanosecs )

{

    SCIF_run_to(nanosecs);

    SCIF_slice_cycle = 0;

}