/home/mrazik/Documents/web/old/hdo/at91lib/peripherals/adc/adc.c

/* ----------------------------------------------------------------------------
 *         ATMEL Microcontroller Software Support
 * ----------------------------------------------------------------------------
 * Copyright (c) 2008, 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:
 *
 * - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the disclaimer below.
 *
 * Atmel's name may not be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * 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.
 * ----------------------------------------------------------------------------
 */

//------------------------------------------------------------------------------
//         Headers
//------------------------------------------------------------------------------

#include <board.h>
#include <adc/adc.h>
#include <utility/trace.h>
#include <utility/assert.h>

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
static void ADC_CfgModeReg (AT91S_ADC *pAdc, unsigned int mode) {
  ASSERT ( (mode&0xF08000C0) == 0, "ADC Bad configuration ADC MR");

  // Clear the register
  pAdc->ADC_MR = 0;
  // Write to the MR register
  pAdc->ADC_MR = mode;
}

//------------------------------------------------------------------------------
//         Global Functions
//------------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_Initialize (AT91S_ADC *pAdc,
                     unsigned char idAdc,
                     unsigned char trgEn,
                     unsigned char trgSel,
                     unsigned char sleepMode,
                     unsigned char resolution,
                     unsigned int mckClock,
                     unsigned int adcClock,
                     unsigned int startupTime,
                     unsigned int sampleAndHoldTime) {
  unsigned int prescal;
  unsigned int startup;
  unsigned int shtim;

  ASSERT (startupTime <= ADC_STARTUP_TIME_MAX, "ADC Bad startupTime\n\r");
  ASSERT (sampleAndHoldTime >= ADC_TRACK_HOLD_TIME_MIN, "ADC Bad sampleAndHoldTime\n\r");
  prescal = (mckClock / (2 * adcClock)) - 1;
  startup = ( (adcClock / 1000000) * startupTime / 8) - 1;
  shtim = ( ( (adcClock / 1000000) * sampleAndHoldTime) / 1000) - 1;

  ASSERT ( (prescal < 0x3F), "ADC Bad PRESCAL\n\r");
  ASSERT (startup < 0x7F, "ADC Bad STARTUP\n\r");
  ASSERT (shtim < 0xF, "ADC Bad SampleAndHoldTime\n\r");

  TRACE_DEBUG ("adcClock:%d MasterClock:%d\n\r", (mckClock / ( (prescal + 1) *2)), mckClock);
  TRACE_DEBUG ("prescal:0x%X startup:0x%X shtim:0x%X\n\r", prescal, startup, shtim);

  if (adcClock != (mckClock / ( (prescal + 1) *2))) {
    TRACE_WARNING ("User and calculated adcClocks are different : user=%d calc=%d\n\r",
                   adcClock, (mckClock / ( (prescal + 1) *2)));
  }

  // Enable peripheral clock
  AT91C_BASE_PMC->PMC_PCER = 1 << idAdc;

  // Reset the controller
  ADC_SoftReset (pAdc);

  // Write to the MR register
  ADC_CfgModeReg (pAdc,
                  (trgEn & AT91C_ADC_TRGEN)
                  | (trgSel & AT91C_ADC_TRGSEL)
                  | (resolution & AT91C_ADC_LOWRES)
                  | (sleepMode & AT91C_ADC_SLEEP)
                  | ( (prescal << 8) & AT91C_ADC_PRESCAL)
                  | ( (startup << 16) & AT91C_ADC_STARTUP)
                  | ( (shtim << 24) & AT91C_ADC_SHTIM));
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_GetModeReg (AT91S_ADC *pAdc) {
  return pAdc->ADC_MR;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_EnableChannel (AT91S_ADC *pAdc, unsigned int channel) {
  ASSERT (channel < 8, "ADC Channel not exist");

  // Write to the CHER register
  pAdc->ADC_CHER = (1 << channel);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_DisableChannel (AT91S_ADC *pAdc, unsigned int channel) {
  ASSERT (channel < 8, "ADC Channel not exist");

  // Write to the CHDR register
  pAdc->ADC_CHDR = (1 << channel);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_GetChannelStatus (AT91S_ADC *pAdc) {
  return pAdc->ADC_CHSR;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_StartConversion (AT91S_ADC *pAdc) {
  pAdc->ADC_CR = AT91C_ADC_START;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_SoftReset (AT91S_ADC *pAdc) {
  pAdc->ADC_CR = AT91C_ADC_SWRST;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_GetLastConvertedData (AT91S_ADC *pAdc) {
  return pAdc->ADC_LCDR;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_GetConvertedData (AT91S_ADC *pAdc, unsigned int channel) {
  unsigned int data = 0;

  ASSERT (channel < 8, "ADC channel not exist");

  switch (channel) {
    case 0:
      data = pAdc->ADC_CDR0;
      break;
    case 1:
      data = pAdc->ADC_CDR1;
      break;
    case 2:
      data = pAdc->ADC_CDR2;
      break;
    case 3:
      data = pAdc->ADC_CDR3;
      break;
    case 4:
      data = pAdc->ADC_CDR4;
      break;
    case 5:
      data = pAdc->ADC_CDR5;
      break;
    case 6:
      data = pAdc->ADC_CDR6;
      break;
    case 7:
      data = pAdc->ADC_CDR7;
      break;
  }
  return data;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_EnableIt (AT91S_ADC *pAdc, unsigned int flag) {
  ASSERT ( (flag&0xFFF00000) == 0, "ADC bad interrupt IER");

  // Write to the IER register
  if (flag > 0xFFFF) {
    // General interrupt
    pAdc->ADC_IER = flag;
  } else if (flag > 0xFF) {
    // Overun interrupt
    pAdc->ADC_IER = 1 << flag << 8;
  } else {
    // Channel interrupt
    pAdc->ADC_IER = 1 << flag;
  }
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_EnableDataReadyIt (AT91S_ADC *pAdc) {
  pAdc->ADC_IER = AT91C_ADC_DRDY;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ADC_DisableIt (AT91S_ADC *pAdc, unsigned int flag) {
  ASSERT ( (flag&0xFFF00000) == 0, "ADC bad interrupt IDR");

  // Write to the IDR register
  if (flag > 0xFFFF) {
    // general interrupt
    pAdc->ADC_IDR = flag;
  } else if (flag > 0xFF) {
    // Overun interrupt
    pAdc->ADC_IDR = 1 << flag << 8;
  } else {
    // Channel interrupt
    pAdc->ADC_IDR = 1 << flag;
  }
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_GetStatus (AT91S_ADC *pAdc) {
  return pAdc->ADC_SR;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_GetInterruptMaskStatus (AT91S_ADC *pAdc) {
  return pAdc->ADC_IMR;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_IsInterruptMasked (AT91S_ADC *pAdc, unsigned int flag) {
  return (ADC_GetInterruptMaskStatus (pAdc) & flag);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned int ADC_IsStatusSet (AT91S_ADC *pAdc, unsigned int flag) {
  return (ADC_GetStatus (pAdc) & flag);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned char ADC_IsChannelInterruptStatusSet (unsigned int adc_sr,
    unsigned int channel) {
  unsigned char status;

  if ( (adc_sr & (1 << channel)) == (1 << channel)) {
    status = 1;
  } else {
    status = 0;
  }
  return status;
}