twi.c

Go to the documentation of this file.

/*This file has been prepared for Doxygen automatic documentation generation.*/
/* ************************************************************************

Copyright (c) 2006, Atmel Corporation All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the
following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.

3. The name of ATMEL may not be used to endorse or promote products
derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY ATMEL ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE EXPRESSLY AND SPECIFICALLY
DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

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

#include "twi.h"


/*
 * twi_set_speed: -  Set the twi bus speed in cojunction with the clock frequency
 *
 * speed:       The desired twi bus speed
 * cpu_hz:      The current running cpu_clock frequency
 * returns:     none
 */
int twi_set_speed(unsigned int speed, unsigned long cpu_hz)
{
        volatile avr32_twi_t *twi = &AVR32_TWI;
        unsigned int cldiv;
        unsigned int ckdiv = 0;

        cldiv = cpu_hz / (speed * 2) - 4;

        while (cldiv > 255)
        {
                ckdiv++;
                cldiv /= 2;
        }

        twi->cwgr = ( cldiv | (cldiv << 8) | (ckdiv << 16) );

        return TWI_SUCCESS;

}

int twi_init(struct twi_options_t * opt)
{

        volatile avr32_twi_t *twi = &AVR32_TWI;

        /* Reset, enable master transfer and disable slave transfer */
        twi->cr = // (1<<AVR32_TWI_CR_SWRST_OFFSET) |
                        (1<<AVR32_TWI_CR_MSEN_OFFSET);
        twi->iadr = opt->twi_addr;

        return twi_set_speed(opt->speed, opt->cpu_hz);

}

int twi_probe(char chip_addr)
{
        volatile avr32_twi_t *twi = &AVR32_TWI;
        int timeout = TWI_TIMEOUT;

        twi->mmr = (chip_addr << 16) | (1<<AVR32_TWI_MMR_MREAD_OFFSET);
        twi->iadr = 0;
        twi->cr = (1<<AVR32_TWI_CR_START_OFFSET) | (1<<AVR32_TWI_CR_STOP_OFFSET);

        do {
                if ((twi->sr) & (1<<AVR32_TWI_SR_RXRDY_OFFSET))
                {
                        return TWI_SUCCESS;
                }
        } while (!(twi->sr & (1<<AVR32_TWI_SR_TXCOMP_OFFSET)) && --timeout);

        return TWI_NO_CHIP_FOUND;
}

int twi_read(struct twi_package_t * package)
{
        volatile avr32_twi_t *twi = &AVR32_TWI;
        unsigned int i = 0;
        unsigned int timeout = TWI_TIMEOUT;

        if (package->length == 0)
        {
                return TWI_INVALID_ARGUMENT;
        }

        /* clear buffer for data */
        for (i = 0; i< package->length; i++)
                package->buffer[i] = '_';
        i=0;

        twi->mmr = (package->chip << AVR32_TWI_MMR_DADR_OFFSET) |
                        ((package->addr_length &3) << 8) |
                        (1<<AVR32_TWI_MMR_MREAD_OFFSET);
        twi->iadr = package->addr;

        /* send start condition */
        twi->cr = (1<<AVR32_TWI_CR_START_OFFSET);


        /* get data */
        while (i < package->length){
          if (twi->sr & (1<<AVR32_TWI_SR_RXRDY_OFFSET)){
            package->buffer[i++] = twi->rhr; /*put the byte in the receive holding register */  
            //print(usart, "got one byte\n");
          }

          /* Wait for ACK */
          while (!(twi->sr & (1<<AVR32_TWI_SR_RXRDY_OFFSET)) && (--timeout));

          /* Check for timeout */
          if(timeout==0){
            return TWI_RECEIVE_NACK;    
          }

          timeout=TWI_TIMEOUT; /* reset timer */
        } /* end while loop */

        /* send stop condition */
        twi->cr |= (1<<AVR32_TWI_CR_STOP_OFFSET);

        /* add terminating char */
        package->buffer[i++] = '\0';

        if (twi->sr & (1<<AVR32_TWI_SR_NACK_OFFSET))
                return TWI_RECEIVE_NACK;

        if (i < package->length)
                return TWI_INVALID_ARGUMENT;
        return i;
}


int twi_write(struct twi_package_t * package)
{
        volatile avr32_twi_t *twi = &AVR32_TWI;
        int i = 0;
        int timeout = TWI_TIMEOUT;

        /* No data to send */
        if (package->length == 0)
        {
                return TWI_INVALID_ARGUMENT;
        }

        twi->cr |= (0<<AVR32_TWI_CR_MSDIS_OFFSET);

        /* set slave address and 3 internal address byte length */
        twi->mmr = (0<<AVR32_TWI_MMR_MREAD_OFFSET) | \
                        (package->chip << AVR32_TWI_MMR_DADR_OFFSET) | \
                        ((package->addr_length & 3) << 8);
        /* set internal address for remote chip */
        twi->iadr = package->addr;

        /* set start condition */
        twi->cr |= (1<<AVR32_TWI_CR_START_OFFSET);

        /* send data*/
        while (i < package->length){

                if (twi->sr & (1<<AVR32_TWI_SR_TXRDY_OFFSET))
                        twi->thr = package->buffer[i++]; /*put the byte in the transmit holding register */

                /* Wait for ACK */
                while (!(twi->sr & (1<<AVR32_TWI_SR_TXCOMP_OFFSET)) && timeout--);

                if(timeout==0)
                        return TWI_RECEIVE_NACK;

                timeout=TWI_TIMEOUT; /* reset timer */

        }


        /* set stop condition */
        twi->cr |= (1<<AVR32_TWI_CR_STOP_OFFSET);

        /* NACK */
        if (twi->sr & (1<<AVR32_TWI_SR_NACK_OFFSET))
                return TWI_SEND_NACK;

        /* not all bytes were sent */
        if (i < package->length)
        {
                /* TIMEOUT */
                return TWI_INVALID_ARGUMENT;
        }

        /* Everything went ok */

        return i;
}

---