/***********************************************************
    Module Name: CamInterface.c
    Module Date: 04/12/2004
    Module Auth: John Orlando 
    Copyright (c) 2004 John Orlando  All Rights Reserved 

    Description: This file is responsible for providing an
    interface to the OV6620 camera hardware.  This includes
    an interface to CamInterface.S for certain low-level,
    optimized camera access routines.
    ***********************************************************/

/*	Includes */
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <avr/sleep.h>
#include <avr/eeprom.h>
#include <stdlib.h>
#include <string.h>
#include "CommonDefs.h"
#include "CamInterface.h"
#include "Utility.h"
#include "UIMgr.h"
#include "Executive.h"
#include "UartInterface.h"

/*  Local Variables */

/* 	Local Structures and Typedefs */

/*  Definitions */

#define FAST_ACQUIRE 1
#define CAM_G_BUS          	PINB
#define CAM_G_BUS_DIR      	DDRB
#define CAM_RB_BUS            PINC
#define CAM_RB_BUS_DIR 		DDRC

#define CAM_CONTROL_PORT      PORTD
#define CAM_CONTROL_PORT_DIR  DDRD
#define CAM_RESET_LINE        BIT7
#define CAM_PIXEL_CLK_COUNT   BIT5
#define CAM_HREF              BIT4
#define CAM_PIXEL_CLK_INT     BIT3
#define CAM_VSYNC             BIT2

/*  Global Variables */
/* NOTE: This file MUST appear first in the Makefile for these variables to
    be placed properly in RAM */

/* The colorMap[] table provides the membership lookup table to convert
    RGB or YUV pixel values into actual colors.  The membership table contains
    16 elements for each color channel, concatenated together.  The Red (or Y)
    value is located in the first 16 bytes, the G (or U) value is located in
    the second 16 bytes, and the B (or V) value is located in the last 16 bytes:

    ----------------------------------------------------------------------------------
    |red0|red1|red2|...|red15|green0|green1|green2|...|green15|blue0|blue1|...|blue15|
    mem:|0x00 0x01 0x02     0x15   0x16   0x17   0x18       0x31   0x32  0x33       0x47 |
    ---------------------------------------------------------------------------------
    Thus, the red lookup is accessed at colorMap+0, the green lookup is accessed
    at colorMap+16, and the blue lookup is accessed at colorMap+32.  */
unsigned char colorMap[NUM_ELEMENTS_IN_COLOR_MAP] __attribute__ ((section (".noinit")));

/*  Extern Variables */
/* These two buffers hold the current and previous lines
    of pixel data.  They are sized to the worst case scenario,
    where the color changes between every pixel (unrealistic).
    The format of each buffer is for all the even bytes to hold
    the run-length, and the odd bytes to hold the color data. */

/* In addition, if we are in frameDump mode, we use these buffers
    to store the acquired line data...we are actually grabbing ALL of the
    pixels in a line (176) instead of the 88 we get normally during tracking.
    But since we have enough to hold 88-RLE blocks, we already have the 176
    allocated for this... */
unsigned char currentLineBuffer[LENGTH_OF_LINE_BUFFER];
unsigned char previousLineBuffer[LENGTH_OF_LINE_BUFFER];

/*  Extern Functions */
/* These functions are located in assembly files, and thus
    must be externed here so they can be referenced in the source below. */
extern void CamIntAsm_waitForNewTrackingFrame(unsigned char *pBuffer, unsigned char *pMemLookup);
extern void CamIntAsm_waitForNewDumpFrame(unsigned char *pCurrBuffer, unsigned char *pPrevBuffer);
extern void CamIntAsm_acquireTrackingLine(unsigned char *pBuffer, unsigned char *pMemLookup);
extern void CamIntAsm_acquireDumpLine(unsigned char *pCurrBuffer, unsigned char *pPrevBuffer);

/***********************************************************
    Function Name: CamInt_init
    Function Description: This function is responsible
    for initializing the camera interface.  This includes
    setting up the i/o ports that are used to read the
    camera busses, as well as resetting the camera.
    Inputs:  none
    Outputs: none
    ***********************************************************/
void CamInt_init(void)
{
    /* set up the mega8 ports that will be interfacing
        with the camera */
    CAM_CONTROL_PORT_DIR |= (1<<CAM_RESET_LINE); /* cam reset is output */
    CAM_CONTROL_PORT_DIR |= 0x80;                /* set just the MSB as an output */
    CAM_CONTROL_PORT_DIR &= 0xFB;                /* make sure bit2 is clear (input) */
    CAM_CONTROL_PORT &= 0x7F;                    /* set reset line low */
    CAM_G_BUS_DIR &= 0xF0;                       /* 4-bit G bus all inputs */
    CAM_G_BUS_DIR |= 0xF0;                       /* disable the pull-up on PB4 and PB5 */
    CAM_RB_BUS_DIR &= 0xF0;                      /* 4-bit RB bus all inputs */

    /* set up Timer1 to count and be clocked from an external pulse source
        (PCLK) on rising edges...also, we don't want
        to enable this counting until after we go into the "acquire line" mode...
        i.e., we'll have to enable the interrupt itself in TIMSK */
    TCCR1B = (1<<CS12)|(1<<CS11)|(1<<CS10);

    /* we'll turn on the interrupt after we assign the initial TCNT value */

    /* set up External Interrupt1 to interrupt us on rising edges (HREF)...
        this is needed to indicate when the first pixel of each line is about to start, so
        we can synch up with it...this interrupt will be disabled once HREF goes high */

    MCUCR |= (1<<ISC11) | (1<<ISC10);  /* rising edge interrupt */
                                       /* the interrupt will be enabled when we are ready to detect the rising edge of
                                           HREF...its now primed and ready to go */

    /* set up External Interrupt0 to interrupt us on rising edges (VSYNC) */
    MCUCR |= (1<<ISC01) | (1<<ISC00);	/* rising edge interrupt */
    GICR  |= (1<<INT0);                 /* interrupt request enabled */

    /* set up TimerO to count and be clocked from an external pulse source
        (HREF) on falling edges...eventually, we need to enable the interrupt
        for this!  FIX THIS */
    TCCR0 = (1<<CS02)|(1<<CS01)|(0<<CS00);

    /* setting up the PCLK counter with Timer1 will be done right after
        we start receiving pixels in each line...we sacrifice the first pixel
        in each line, but we'll account for it...*/

    /* set up the mega8 so that its sleep mode puts it in an IDLE sleep
        mode, where it can wake up as fast as possible */
    set_sleep_mode(SLEEP_MODE_IDLE);
    /* umm....we need to actually enable the sleep mode...*/
    MCUCR |= 0x80;

    /* initialize the memLookup table */
    memset(colorMap,0x00,NUM_ELEMENTS_IN_COLOR_MAP);

    /* read the color map out of EEPROM */
    eeprom_read_block(colorMap, (unsigned char*)0x01,NUM_ELEMENTS_IN_COLOR_MAP);

    CamInt_resetCam();
}

/***********************************************************
    Function Name: CamInt_resetCam
    Function Description: This function is responsible
    for resetting the camera.  This is accomplished by
    toggling the reset line on the OV6620 for ~100 mS.
    Inputs:  none
    Outputs: none
    ***********************************************************/
void CamInt_resetCam(void)
{
    CAM_CONTROL_PORT |= (1<<CAM_RESET_LINE); /* cam reset line high */
    Utility_delay(500);
    CAM_CONTROL_PORT &= (0<<CAM_RESET_LINE); /* cam reset line low */
    Utility_delay(100);
}