/***********************************************************
    Module Name: I2CInterface.c
    Module Date: 4/10/2004
    Module Auth: John Orlando 
    Copyright (c) 2004 John Orlando  All Rights Reserved 

    Description: This module is responsible for providing a
    low-level interface to the I2C hardware resident on the
    mega8 processor (also known as the Two-Wire Interface,
    or TWI).  The interface is needed to configure the
    needed registers in the OV6620 camera.  This interface
    is interrupt-driven based on the events that should
    occur upon successful writing of an I2C register.

    ***********************************************************/

/*	Includes */
#include <avr/io.h>
#include <avr/twi.h>
#include <avr/signal.h>
#include <avr/interrupt.h>
#include "CamConfig.h"
#include "CommonDefs.h"

/*  Local Variables */

/* These variables are used as storage space for the current
    I2C command being sent over the interface.  They need to
    be volatile since they are dealt with an the TWI ISR */
volatile static unsigned char twi_address;
volatile static unsigned char *twi_data;
volatile static unsigned char twi_ddr;
volatile static unsigned char twi_bytes;
volatile static unsigned char status;
volatile static unsigned char retry_cnt;

/* 	Local Structures and Typedefs */

/*  Extern Variables */

/*  Definitions */
/* Bit definitions for the tw_status register */
#define MAX_TWI_RETRIES 2
#define BUSY            7

/***********************************************************
    Function Name: I2CInt_init
    Function Description: This function is responsible
    for setting up the registers needed for the TWI
    interface

    Inputs:  none
    Outputs: none
    ***********************************************************/
void I2CInt_init(void)
{
    TWSR = 0;

    /* init the speed of the I2C interface, running at
        100 Kbps */
    TWBR = (FOSC / I2C_SPEED - 16)/2;
}

/***********************************************************
    Function Name: I2CInt_writeData
    Function Description: This function is responsible for
    initiating the process of writing a sequence of bytes
    an I2C slave address.  This function will try to write
    the data three times before giving up.
    Inputs: address: the address of the I2C slave device
    data: a pointer to the data to be written
    to the slave...for camera interfacing,
    the data follows a <register #><data>
    format
    bytes: the number of bytes to write
    Outputs: none
    ***********************************************************/
void I2CInt_writeData(unsigned char address, unsigned char *data, unsigned char bytes)
{
    while(status & (1<<BUSY));		/* Bus is busy wait (or exit with error code) */
    while(TWCR & (1<<TWSTO));

    /* copy the needed data and state info to our local I2C command structure */
    twi_address = address;
    twi_data = data;
    twi_bytes = bytes;
    twi_ddr = TW_WRITE;

    retry_cnt = 0;

    /* Generate start condition, the remainder of the transfer is interrupt driven and
        will be performed in the background */
    TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)|(1<<TWIE);

    status |= (1<<BUSY);
}

/***********************************************************
    Function Name: I2CInt_readData
    Function Description: This funcion is responsible for
    reading the specified number of bytes from a slave
    device.
    Inputs:  address: the slave address to read from
    data: a pointer to where the data will be stored
    bytes: the number of bytes to read
    Outputs: none
    ***********************************************************/
void I2CInt_readData(unsigned char address, unsigned char *data, unsigned char bytes)
{
    /* Bus is busy wait (or exit with error code) */
    while(status & (1<<BUSY));

    twi_address = address;
    twi_data = data;
    twi_bytes = bytes;
    twi_ddr = TW_READ;

    retry_cnt = 0;

    /* Generate start condition, the remainder of the transfer is interrupt driven and
        will be performed in the background */
    TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)|(1<<TWIE);

    status |= (1<<BUSY);
}

/***********************************************************
    Function Name: I2CInt_isI2cBusy
    Function Description: This funcion is responsible for
    indicating if the I2C bus is currently busy to external
    modules.
    device.
    Inputs:  none
    Outputs: bool_t - indicating if bus is busy
    ***********************************************************/
bool_t I2CInt_isI2cBusy(void)
{
    bool_t retVal = FALSE;
    if ( (status & (1<<BUSY)) != 0)
    {
        retVal = TRUE;
    }

    return(retVal);
}

/***********************************************************
    Function Name: <interrupt handler for I2C>
    Function Description: This function is responsible for
    implementing the control logic needed to perform a
    read or write operation with an I2C slave.
    Inputs:  none
    Outputs: none
    ***********************************************************/
SIGNAL(SIG_2WIRE_SERIAL)
{
    unsigned char TWI_status = TWSR & TW_STATUS_MASK;   /* grab just the status bits */

    /* the entire I2C handler is state-based...determine
        what needs to be done based on TWI_status */
    switch(TWI_status)
    {
    case TW_START:									/* Start condition */
    case TW_REP_START:                                                  /* Repeated start condition */
        if(retry_cnt > MAX_TWI_RETRIES)
        {
            /* generate stop condition if we've reached our retry limit */
            TWCR |= (1<<TWINT)|(1<<TWSTO);
            status &= ~(1<<BUSY);
            return;
        }
        /* indicate read or write */
        TWDR = (twi_address<<1) + twi_ddr;
        /* TWSTA must be cleared...also clears TWINT */
        TWCR &= ~(1<<TWSTA);
        break;

    case TW_MT_SLA_ACK:							/* Slave acknowledged address, */
        retry_cnt = 0;
        /* tx the data, and increment the data pointer */
        TWDR = *twi_data;
        twi_data++;

        /* clear the int to continue */
        TWCR |= (1<<TWINT);
        break;

    case TW_MT_SLA_NACK:							/* Slave didn't acknowledge address, */
    case TW_MR_SLA_NACK:
        retry_cnt++;

        /* retry...*/
        TWCR |= (1<<TWINT)|(1<<TWSTA)|(1<<TWSTO);
        break;

    case TW_MT_DATA_ACK:							/* Slave Acknowledged data, */
        if(--twi_bytes > 0)
        {
            /* more data to send, so send it */
            TWDR = *twi_data;
            twi_data++;
            TWCR |= (1<<TWINT);
        }
        else
        {
            /* generate the stop condition if needed */
            TWCR |= (1<<TWSTO)|(1<<TWINT);
            status &= ~(1<<BUSY);
        }
        break;

    case TW_MT_DATA_NACK:							/* Slave didn't acknowledge data
                                                                  send the stop condition */
        TWCR |= (1<<TWINT)|(1<<TWSTO);
        status &= ~(1<<BUSY);
        break;

    case TW_MR_SLA_ACK:                             /* Slave acknowledged address */
        if(--twi_bytes > 0)
        {
            /* if there is more than one byte to read, acknowledge */
            TWCR |= (1<<TWEA)|(1<<TWINT);
        }
        else
        {
            /* no acknowledge */
            TWCR |= (1<<TWINT);
        }
        break;

    case TW_MR_DATA_ACK: 							/* Master acknowledged data */

        /* grab the received data */
        *twi_data = TWDR;
        twi_data++;
        if(--twi_bytes > 0)
        {
            /* get the next data byte and ack */
            TWCR |= (1<<TWEA)|(1<<TWINT);
        }
        else
        {
            /* clear out the enable acknowledge bit */
            TWCR &= ~(1<<TWEA);
        }
        break;

    case TW_MR_DATA_NACK:						/* Master didn't acknowledge data -> end of read process
                                                               read data, and generate the stop condition */
        *twi_data = TWDR;
        TWCR |= (1<<TWSTO)|(1<<TWINT);
        status &= ~(1<<BUSY);
        break;
    }
}