//=============================================================================
//
//      external_timer.c - Cyclone Diagnostics
//
//=============================================================================
// ####ECOSGPLCOPYRIGHTBEGIN####                                            
// -------------------------------------------                              
// This file is part of eCos, the Embedded Configurable Operating System.   
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
//
// eCos 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 or (at your option) any later      
// version.                                                                 
//
// eCos 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.                                                        
//
// You should have received a copy of the GNU General Public License        
// along with eCos; if not, write to the Free Software Foundation, Inc.,    
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
//
// As a special exception, if other files instantiate templates or use      
// macros or inline functions from this file, or you compile this file      
// and link it with other works to produce a work based on this file,       
// this file does not by itself cause the resulting work to be covered by   
// the GNU General Public License. However the source code for this file    
// must still be made available in accordance with section (3) of the GNU   
// General Public License v2.                                               
//
// This exception does not invalidate any other reasons why a work based    
// on this file might be covered by the GNU General Public License.         
// -------------------------------------------                              
// ####ECOSGPLCOPYRIGHTEND####                                              
//=============================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):   Scott Coulter, Jeff Frazier, Eric Breeden
// Contributors:
// Date:        2001-01-25
// Purpose:     
// Description: 
//
//####DESCRIPTIONEND####
//
//===========================================================================*/

#include <redboot.h>
#include <cyg/hal/hal_iop310.h>        // Hardware definitions
#include <cyg/hal/hal_intr.h>          // Interrupt names
#include "iq80310.h"
#include "test_menu.h"

extern int enable_external_interrupt (int int_id);
extern int disable_external_interrupt (int int_id);
extern int isr_connect(int int_num, void (*handler)(int), int arg);
extern int isr_disconnect(int int_num);
extern char xgetchar(void);

volatile int timer_ticks;

/* interrupt handler for the PAL-based external timer */
void ext_timer_handler (int arg)
{
    /* increment tick counter */
    timer_ticks++;

    /* to clear the timer interrupt, clear the timer interrupt
       enable, then re-set the int. enable bit */
    /* 01/05/01 jwf */
    /*	_restart_tmr(); */

    EXT_TIMER_INT_DISAB();
    EXT_TIMER_INT_ENAB();

    return;
}


/* timer count must be written 8 bits at a time */
void write_timer_count (UINT32 count)
{
    UINT8 cnt_word;

    /* first ensure that there are only 22 bits of count data */
    count &= 0x003fffff;

    /* grab least significant 8 bits of timer value */
    cnt_word = (UINT8)(count & 0xff);
    *TIMER_LA0_REG_ADDR = cnt_word;

    /* grab next 8 bits of timer value */
    count = (count >> 8);
    cnt_word = (UINT8)(count & 0xff);
    *TIMER_LA1_REG_ADDR = cnt_word;

    /* grab last 6 bits of timer value */
    count = (count >> 8);
    cnt_word = (UINT8)(count & 0x3f);
    *TIMER_LA2_REG_ADDR = cnt_word;

    return;
}

/* timer must be read 6 bits at a time */
UINT32 read_timer_count (void)
{
    UINT8 timer_cnt0, timer_cnt1, timer_cnt2, timer_cnt3;
    UINT8 timer_byte0, timer_byte1, timer_byte2;
    UINT32 count;

    /* first read latches the count */
    timer_cnt0 = (*TIMER_LA0_REG_ADDR & TIMER_COUNT_MASK);
    timer_cnt1 = (*TIMER_LA1_REG_ADDR & TIMER_COUNT_MASK);
    timer_cnt2 = (*TIMER_LA2_REG_ADDR & TIMER_COUNT_MASK);
    timer_cnt3 = (*TIMER_LA3_REG_ADDR & 0xf);	/* only 4 bits in most sig. */

    /* now build up the count value */
    timer_byte0 = (((timer_cnt0 & 0x20) >> 1) | (timer_cnt0 & 0x1f));
    timer_byte1 = (((timer_cnt1 & 0x20) >> 1) | (timer_cnt1 & 0x1f));
    timer_byte2 = (((timer_cnt2 & 0x20) >> 1) | (timer_cnt2 & 0x1f));

    count = ((timer_cnt3 << 18) | (timer_byte2 << 12) | (timer_byte1 << 6) |
	     timer_byte0);

    return (count);
}


/* 12/18/00 jwf */
/* This test reads the timer la0-la3 registers on the fly while an up count is in progress. */
void counter_test (void)
{
    /* ff max, b0-b7, b0-b7 contain timer load data */	
    unsigned char TmrLa0Write=0xff;
    /* ff max, b8-b15, b0-b7 contain timer load data  */
    unsigned char TmrLa1Write=0xff;
    /* 3f max, b16-b21, b0-b5 contain timer load data  */
    unsigned char TmrLa2Write=0x3f;
    unsigned char TmrLa3Write=0x00; /* x - don't care */
    unsigned long int TmrLa0Read=0;	
    unsigned long int TmrLa1Read=0;
    unsigned long int TmrLa2Read=0;
    unsigned long int TmrLa3Read=0;
    unsigned long int temp3=0;
    unsigned long int temp4=0;
    unsigned long int CntInit=0;
    unsigned long int CurrentCount;
    unsigned long int LastCount = 0;
    unsigned long int LastLastCount = 0;
    char Error = FALSE;
    unsigned long int sample;
    unsigned long int index;
    const int MAX_N_PASSES = 10; /* N times the counter shall wrap around */
    /* N samples to cover the full range of count,
       0x3fffff/0x40 = 0xffff <--> 65535d, use 65536 to guarantee
       a counter wrap around occurs */
    const unsigned long int MAX_N_SAMPLES = 65536;
    /* allocate 4 bytes per sample for a 0x0 - 0x3fffff count range to
       hold contents of registers LA0-LA3 */
    unsigned long int MAX_N_SIZE = MAX_N_PASSES * MAX_N_SAMPLES * 4;
    unsigned char *data;

    // Arbitrarily pick a spot in memory.
    // RedBoot won't ever use more than 1MB.
    data = (unsigned char *) MEMBASE_DRAM + (1*1024*1024);

    if (data != NULL) {
	printf("Allocated %d bytes\n", MAX_N_SIZE);

	/* load control data to disable timer enable b0=0 and timer disable
	   interrupt b1=0, write to timer enable port */
	EXT_TIMER_INT_DISAB();
	EXT_TIMER_CNT_DISAB();

	/* write timer la0 port count data */
	*TIMER_LA0_REG_ADDR = TmrLa0Write;

	/* write timer la1 port count data */
	*TIMER_LA1_REG_ADDR = TmrLa1Write;

	/*  write timer la2 port count data */
	*TIMER_LA2_REG_ADDR = TmrLa2Write;

	/*  write timer la3 port count data */
	*TIMER_LA3_REG_ADDR = TmrLa3Write;

	CntInit = TmrLa0Write + (TmrLa1Write << 8 ) + (TmrLa2Write << 16 );

	printf("Timer load data = 0x%x\n", CntInit );

	printf("Reading Timer registers LA0-LA3 on the fly...\n");

	/* load control data to enable timer counter and write control data
	   to start the counter */
	EXT_TIMER_CNT_ENAB();

	/* sample the timer counter on the fly and store LA0-3 register
	   contents in an array */
	/* read LSB register first to latch 22 bits data into four la
	   registers */
	for (sample=0, index=0; sample < (MAX_N_PASSES * MAX_N_SAMPLES); sample++, index += 4) {
	    /* bits 0 1 2 3 4 6 contain count data b0-b5 */
	    data[index]   = *TIMER_LA0_REG_ADDR;
	    /* bits 0 1 2 3 4 6 contain count data b6-b11 */
	    data[index+1] = *TIMER_LA1_REG_ADDR;
	    /* bits 0 1 2 3 4 6 contain count data b12-b17 */
	    data[index+2] = *TIMER_LA2_REG_ADDR;
	    /* bits 0 1 2 3 contain count data b18-b21 */
	    data[index+3] = *TIMER_LA3_REG_ADDR;
	}

	printf("Checking for errors...\n" );

	/* Assemble and check recorded register data for errors */
	for (sample=0, index=0; sample < (MAX_N_PASSES * MAX_N_SAMPLES) ;sample++, index += 4) {
	    /* Assembles counter data that was read on the fly */
	    /* xbxbbbbb */
	    /* 01000000 = 0x40 */
	    /* 00011111 = 0x1F */
	    data[index] &= 0x7f;	/* mask all unused bits */
	    temp3=data[index];
	    temp4=data[index];
	    temp3 &= 0x40;		/* isolate bit 6 */
	    temp3 = temp3 >> 1;		/* shift bit 6 to bit 5 */
	    temp4 &= 0x1f;		/* isolate bits 0-4 */
	    TmrLa0Read = temp3 + temp4;

	    data[index+1] &= 0x7f;	/* mask all unused bits */
	    temp3=data[index+1];
	    temp4=data[index+1];
	    temp3 &= 0x40;		/* isolate bit 6 */
	    temp3 = temp3 >> 1;		/* shift bit 6 to bit 5 */
	    temp4 &= 0x1f;		/* isolate bits 0-4 */
	    TmrLa1Read = temp3 + temp4;

	    data[index+2] &= 0x7f;	/* mask all unused bits */
	    temp3=data[index+2];
	    temp4=data[index+2];
	    temp3 &= 0x40;		/* isolate bit 6 */
	    temp3 = temp3 >> 1;		/* shift bit 6 to bit 5 */
	    temp4 &= 0x1f;		/* isolate bits 0-4 */
	    TmrLa2Read = temp3 + temp4;

	    data[index+3] &= 0x0f;	/* mask all unused bits */
	    TmrLa3Read = data[index+3];

	    /* sum timer count data */
	    CurrentCount = TmrLa0Read + (TmrLa1Read << 6)
		+ (TmrLa2Read << 12) + (TmrLa3Read << 18);

	    if (sample == 0) {
		LastLastCount = 0;
		LastCount = CurrentCount;
	    }

	    if (sample == 1) {
		LastLastCount = LastCount;
		LastCount = CurrentCount;
	    }

	    /* check for data anomaly, is count value read 2 samples ago
	       greater than the count value read 1 sample ago */
	    if (sample > 1) {
		/* print error value (LastCount) positioned in between the
		   previous and current values */
		if (LastLastCount > LastCount && CurrentCount > LastLastCount) {
		    /* show error only, do not show a counter wrap around
		       reading, print error value (LastCount) positioned in
		       between the previous and current values */
		    printf("0x%x 0x%x 0x%x \n", LastLastCount, LastCount, CurrentCount );
		    Error = TRUE;	/* set flag to error condition */
		}
		LastLastCount = LastCount;
		LastCount = CurrentCount;
	    }
	}
	/* load control data to stop timer and reset timer interrupt */
	EXT_TIMER_CNT_DISAB();
    } else
	printf( "Cannot allocate memory.\n" );

    if (Error == TRUE)
	printf("Timer LA0-3 register read test FAILED.\n");
    else
	printf("Timer LA0-3 register read test PASSED.\n");
}


/* initialize timer for diagnostic use */
void init_external_timer(void)
{
#if 0
    /* disable timer in case it was running */
    EXT_TIMER_INT_DISAB();
    EXT_TIMER_CNT_DISAB();

    timer_ticks = 0;

    /* connect the timer ISR */
    isr_connect (TIMER_INT_ID, ext_timer_handler, 0);

    /* enable the external interrupt */
    if (enable_external_interrupt(TIMER_INT_ID) != OK)
	printf("ERROR enabling EXT TIMER interrupt!\n");
#else
    hal_clock_initialize(CYGNUM_HAL_RTC_PERIOD);
#endif

}


/* uninitialize timer after diagnostics */
void uninit_external_timer(void)
{
#if 0
    /* disable timer */
    EXT_TIMER_INT_DISAB();
    EXT_TIMER_CNT_DISAB();

    /* disable and disconnect timer interrupts */
    disable_external_interrupt(TIMER_INT_ID);
    isr_disconnect (TIMER_INT_ID);
#endif
}


/* 02/02/01 jwf */
/* delay_ms - delay specified number of milliseconds */
void delay_ms(int num_ms)
{
    HAL_DELAY_US(num_ms * 1000);
}


/* test the 32 bit timer inside the CPLD, U17 */
void timer_test (MENU_ARG arg)
{
    volatile int i;
    UINT32 count;
	
    /*****  Perform 10 second count at 100 ticks/sec ****/

    /* for the test we will setup the timer to generate a 10msec tick */
    count = EXT_TIMER_10MSEC_COUNT;

    /* write the initial count to the timer */
    write_timer_count (count);

    /* enable the interrupt at the timer */
    EXT_TIMER_INT_ENAB();

    /* enable the timer to count */
    EXT_TIMER_CNT_ENAB();

    printf ("Counting at %d Ticks Per Second.\n", TICKS_10MSEC);
    printf ("Numbers should appear on 1 second increments...\n");

    for (i = 0; i < 10; i++) {
	while (timer_ticks < TICKS_10MSEC)
	    ;
	printf ("%d ", i);
	timer_ticks = 0;
    }

    printf ("\nDone\n\n");

    /* disable timer */
    EXT_TIMER_INT_DISAB();
    EXT_TIMER_CNT_DISAB();

	
    /*****  Perform 10 second count at 200 ticks/sec ****/

    count = EXT_TIMER_5MSEC_COUNT;
    write_timer_count (count);

    timer_ticks = 0;

    /* enable the interrupt at the timer */
    EXT_TIMER_INT_ENAB();

    /* enable the timer to count */
    EXT_TIMER_CNT_ENAB();

    printf ("Counting at %d Ticks Per Second.\n", TICKS_5MSEC);
    printf ("Numbers should appear on 1 second increments...\n");

    for (i = 0; i < 10; i++) {
	while (timer_ticks < TICKS_5MSEC)
	    ;
	printf ("%d ", i);
	timer_ticks = 0;
    }

    printf ("\nDone\n\n");

    /* disable timer */
    EXT_TIMER_INT_DISAB();
    EXT_TIMER_CNT_DISAB();

    /* 12/18/00 jwf */
    uninit_external_timer();	/* disable interrupt */
    counter_test();
    init_external_timer();		/* enable interrupt */

    printf("\nExternal Timer Test Done\n");

    /* 12/18/00 jwf */
    printf("\n\nStrike <CR> to exit this test." );
    while (xgetchar() != 0x0d);

    return;

} /* end timer_test() */


