/* ---------------------------------------------------------------------------- * 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 "pwmc2.h" #include #include #include //------------------------------------------------------------------------------ // Local functions //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ /// Finds a prescaler/divisor couple to generate the desired frequency from /// MCK. /// Returns the value to enter in PWMC_MR or 0 if the configuration cannot be /// met. /// \param frequency Desired frequency in Hz. /// \param mck Master clock frequency in Hz. //------------------------------------------------------------------------------ static unsigned short FindClockConfiguration( unsigned int frequency, unsigned int mck) { unsigned int divisors[11] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}; unsigned char divisor = 0; unsigned int prescaler; SANITY_CHECK(frequency < mck); // Find prescaler and divisor values prescaler = (mck / divisors[divisor]) / frequency; while ((prescaler > 255) && (divisor < 11)) { divisor++; prescaler = (mck / divisors[divisor]) / frequency; } // Return result if (divisor < 11) { TRACE_DEBUG("Found divisor=%u and prescaler=%u for freq=%uHz\n\r", divisors[divisor], prescaler, frequency); return prescaler | (divisor << 8); } else { return 0; } } //------------------------------------------------------------------------------ // Global functions //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ /// Configures PWM a channel with the given parameters, basic configure function. /// The PWM controller must have been clocked in the PMC prior to calling this /// function. /// Beware: this function disables the channel. It waits until disable is effective. /// \param channel Channel number. /// \param prescaler Channel prescaler. /// \param alignment Channel alignment. /// \param polarity Channel polarity. //------------------------------------------------------------------------------ void PWMC_ConfigureChannel( unsigned char channel, unsigned int prescaler, unsigned int alignment, unsigned int polarity) { SANITY_CHECK(prescaler < AT91C_PWMC_CPRE_MCKB); SANITY_CHECK((alignment & ~AT91C_PWMC_CALG) == 0); SANITY_CHECK((polarity & ~AT91C_PWMC_CPOL) == 0); // Disable channel (effective at the end of the current period) if ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) != 0) { AT91C_BASE_PWMC->PWMC_DIS = 1 << channel; while ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) != 0); } // Configure channel AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CMR = prescaler | alignment | polarity; } //------------------------------------------------------------------------------ /// Configures PWM a channel with the given parameters, extend configure function. /// The PWM controller must have been clocked in the PMC prior to calling this /// function. /// Beware: this function disables the channel. It waits until disable is effective. /// \param channel Channel number. /// \param prescaler Channel prescaler. /// \param alignment Channel alignment. /// \param polarity Channel polarity. /// \param countEventSelect Channel counter event selection. /// \param DTEnable Channel dead time generator enable. /// \param DTHInverte Channel Dead-Time PWMHx output Inverted. /// \param DTLInverte Channel Dead-Time PWMHx output Inverted. //------------------------------------------------------------------------------ void PWMC_ConfigureChannelExt( unsigned char channel, unsigned int prescaler, unsigned int alignment, unsigned int polarity, unsigned int countEventSelect, unsigned int DTEnable, unsigned int DTHInverte, unsigned int DTLInverte) { SANITY_CHECK(prescaler < AT91C_PWMC_CPRE_MCKB); SANITY_CHECK((alignment & ~AT91C_PWMC_CALG) == 0); SANITY_CHECK((polarity & ~AT91C_PWMC_CPOL) == 0); SANITY_CHECK((countEventSelect & ~AT91C_PWMC_CES) == 0); SANITY_CHECK((DTEnable & ~AT91C_PWMC_DTE) == 0); SANITY_CHECK((DTHInverte & ~AT91C_PWMC_DTHI) == 0); SANITY_CHECK((DTLInverte & ~AT91C_PWMC_DTLI) == 0); // Disable channel (effective at the end of the current period) if ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) != 0) { AT91C_BASE_PWMC->PWMC_DIS = 1 << channel; while ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) != 0); } // Configure channel AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CMR = prescaler | alignment | polarity | countEventSelect | DTEnable | DTHInverte | DTLInverte; } //------------------------------------------------------------------------------ /// Configures PWM clocks A & B to run at the given frequencies. This function /// finds the best MCK divisor and prescaler values automatically. /// \param clka Desired clock A frequency (0 if not used). /// \param clkb Desired clock B frequency (0 if not used). /// \param mck Master clock frequency. //------------------------------------------------------------------------------ void PWMC_ConfigureClocks(unsigned int clka, unsigned int clkb, unsigned int mck) { unsigned int mode = 0; unsigned int result; // Clock A if (clka != 0) { result = FindClockConfiguration(clka, mck); ASSERT(result != 0, "-F- Could not generate the desired PWM frequency (%uHz)\n\r", clka); mode |= result; } // Clock B if (clkb != 0) { result = FindClockConfiguration(clkb, mck); ASSERT(result != 0, "-F- Could not generate the desired PWM frequency (%uHz)\n\r", clkb); mode |= (result << 16); } // Configure clocks TRACE_DEBUG("Setting PWMC_MR = 0x%08X\n\r", mode); AT91C_BASE_PWMC->PWMC_MR = mode; } //------------------------------------------------------------------------------ /// Sets the period value used by a PWM channel. This function writes directly /// to the CPRD register if the channel is disabled; otherwise, it uses the /// update register CUPD. /// \param channel Channel number. /// \param period Period value. //------------------------------------------------------------------------------ void PWMC_SetPeriod(unsigned char channel, unsigned short period) { // If channel is disabled, write to CPRD if ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) == 0) { AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CPRDR = period; } // Otherwise use update register else { AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CPRDUPDR = period; } } //------------------------------------------------------------------------------ /// Sets the duty cycle used by a PWM channel. This function writes directly to /// the CDTY register if the channel is disabled; otherwise it uses the /// update register CUPD. /// Note that the duty cycle must always be inferior or equal to the channel /// period. /// \param channel Channel number. /// \param duty Duty cycle value. //------------------------------------------------------------------------------ void PWMC_SetDutyCycle(unsigned char channel, unsigned short duty) { SANITY_CHECK(duty <= AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CPRDR); // SAM7S errata #if defined(at91sam7s16) || defined(at91sam7s161) || defined(at91sam7s32) \ || defined(at91sam7s321) || defined(at91sam7s64) || defined(at91sam7s128) \ || defined(at91sam7s256) || defined(at91sam7s512) ASSERT(duty > 0, "-F- Duty cycle value 0 is not permitted on SAM7S chips.\n\r"); ASSERT((duty > 1) || (AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CMR & AT91C_PWMC_CALG), "-F- Duty cycle value 1 is not permitted in left-aligned mode on SAM7S chips.\n\r"); #endif // If channel is disabled, write to CDTY if ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) == 0) { AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CDTYR = duty; } // Otherwise use update register else { AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CDTYUPDR = duty; } } //------------------------------------------------------------------------------ /// Sets the dead time used by a PWM channel. This function writes directly to /// the DTR register if the channel is disabled; otherwise it uses the /// update register DTUPDR. /// Note that the dead time must always be inferior or equal to the channel /// period. /// \param channel Channel number. /// \param timeH Dead time value for PWMHx output. /// \param timeL Dead time value for PWMLx output. //------------------------------------------------------------------------------ void PWMC_SetDeadTime(unsigned char channel, unsigned short timeH, unsigned short timeL) { SANITY_CHECK(timeH <= AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CPRDR); SANITY_CHECK(timeL <= AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_CPRDR); // If channel is disabled, write to DTR if ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) == 0) { AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_DTR = timeH | (timeL << 16); } // Otherwise use update register else { AT91C_BASE_PWMC->PWMC_CH[channel].PWMC_DTUPDR = timeH | (timeL << 16); } } //------------------------------------------------------------------------------ /// Configures Syncronous channel with the given parameters. /// Beware: At this time, the channels should be disabled. /// \param channels Bitwise OR of Syncronous channels. /// \param updateMode Syncronous channel update mode. /// \param requestMode PDC transfer request mode. /// \param requestComparisonSelect PDC transfer request comparison selection. //------------------------------------------------------------------------------ void PWMC_ConfigureSyncChannel( unsigned int channels, unsigned int updateMode, unsigned int requestMode, unsigned int requestComparisonSelect) { AT91C_BASE_PWMC->PWMC_SYNC = channels | updateMode | requestMode | requestComparisonSelect; } //------------------------------------------------------------------------------ /// Sets the update period of the synchronous channels. /// This function writes directly to /// the SCUP register if the channel #0 is disabled; otherwise it uses the /// update register SCUPUPD. /// \param period update period. //------------------------------------------------------------------------------ void PWMC_SetSyncChannelUpdatePeriod(unsigned char period) { // If channel is disabled, write to SCUP if ((AT91C_BASE_PWMC->PWMC_SR & (1 << 0)) == 0) { AT91C_BASE_PWMC->PWMC_SCUP = period; } // Otherwise use update register else { AT91C_BASE_PWMC->PWMC_SCUPUPD = period; } } //------------------------------------------------------------------------------ /// Sets synchronous channels update unlock. /// Note: If the UPDM field is set to 0, writing the UPDULOCK bit to 1 /// triggers the update of the period value, the duty-cycle and /// the dead-time values of synchronous channels at the beginning /// of the next PWM period. If the field UPDM is set to 1 or 2, /// writing the UPDULOCK bit to 1 triggers only the update of /// the period value and of the dead-time values of synchronous channels. /// This bit is automatically reset when the update is done. //------------------------------------------------------------------------------ void PWMC_SetSyncChannelUpdateUnlock(void) { AT91C_BASE_PWMC->PWMC_UPCR = AT91C_PWMC_UPDULOCK; } //------------------------------------------------------------------------------ /// Enables the given PWM channel. This does NOT enable the corresponding pin; /// this must be done in the user code. /// \param channel Channel number. //------------------------------------------------------------------------------ void PWMC_EnableChannel(unsigned char channel) { AT91C_BASE_PWMC->PWMC_ENA = 1 << channel; } //------------------------------------------------------------------------------ /// Disables the given PWM channel. /// Beware, channel will be effectively disabled at the end of the current period. /// Application can check channel is disabled using the following wait loop: /// while ((AT91C_BASE_PWMC->PWMC_SR & (1 << channel)) != 0); /// \param channel Channel number. //------------------------------------------------------------------------------ void PWMC_DisableChannel(unsigned char channel) { AT91C_BASE_PWMC->PWMC_DIS = 1 << channel; } //------------------------------------------------------------------------------ /// Enables the period interrupt for the given PWM channel. /// \param channel Channel number. //------------------------------------------------------------------------------ void PWMC_EnableChannelIt(unsigned char channel) { AT91C_BASE_PWMC->PWMC_IER1 = 1 << channel; } //------------------------------------------------------------------------------ /// Disables the period interrupt for the given PWM channel. /// \param channel Channel number. //------------------------------------------------------------------------------ void PWMC_DisableChannelIt(unsigned char channel) { AT91C_BASE_PWMC->PWMC_IDR1 = 1 << channel; } //----------------------------------------------------------------------------- /// Enables the selected interrupts sources on a PWMC peripheral. /// \param sources1 Bitwise OR of selected interrupt sources of PWMC_IER1. /// \param sources2 Bitwise OR of selected interrupt sources of PWMC_IER2. //----------------------------------------------------------------------------- void PWMC_EnableIt(unsigned int sources1, unsigned int sources2) { AT91C_BASE_PWMC->PWMC_IER1 = sources1; AT91C_BASE_PWMC->PWMC_IER2 = sources2; } //----------------------------------------------------------------------------- /// Disables the selected interrupts sources on a PWMC peripheral. /// \param sources1 Bitwise OR of selected interrupt sources of PWMC_IDR1. /// \param sources2 Bitwise OR of selected interrupt sources of PWMC_IDR2. //----------------------------------------------------------------------------- void PWMC_DisableIt(unsigned int sources1, unsigned int sources2) { AT91C_BASE_PWMC->PWMC_IDR1 = sources1; AT91C_BASE_PWMC->PWMC_IDR2 = sources2; } //------------------------------------------------------------------------------ /// Sends the contents of buffer through a PWMC peripheral, using the PDC to /// take care of the transfer. /// Note: Duty cycle of syncronous channels can update by PDC /// when the field UPDM (Update Mode) in the PWM_SCM register is set to 2. /// \param pwmc Pointer to an AT91S_PWMC instance. /// \param buffer Data buffer to send. /// \param length Length of the data buffer. //------------------------------------------------------------------------------ unsigned char PWMC_WriteBuffer(AT91S_PWMC *pwmc, void *buffer, unsigned int length) { // Check if first bank is free if (pwmc->PWMC_TCR == 0) { pwmc->PWMC_TPR = (unsigned int) buffer; pwmc->PWMC_TCR = length; pwmc->PWMC_PTCR = AT91C_PDC_TXTEN; return 1; } // Check if second bank is free else if (pwmc->PWMC_TNCR == 0) { pwmc->PWMC_TNPR = (unsigned int) buffer; pwmc->PWMC_TNCR = length; return 1; } // No free banks return 0; } //----------------------------------------------------------------------------- /// Set PWM output override value /// \param value Bitwise OR of output override value. //----------------------------------------------------------------------------- void PWMC_SetOverrideValue(unsigned int value) { AT91C_BASE_PWMC->PWMC_OOV = value; } //----------------------------------------------------------------------------- /// Enalbe override output. /// \param value Bitwise OR of output selection. /// \param sync 0: enable the output asyncronously, 1: enable it syncronously //----------------------------------------------------------------------------- void PWMC_EnableOverrideOutput(unsigned int value, unsigned int sync) { if (sync) { AT91C_BASE_PWMC->PWMC_OSSUPD = value; } else { AT91C_BASE_PWMC->PWMC_OSS = value; } } //----------------------------------------------------------------------------- /// Disalbe override output. /// \param value Bitwise OR of output selection. /// \param sync 0: enable the output asyncronously, 1: enable it syncronously //----------------------------------------------------------------------------- void PWMC_DisableOverrideOutput(unsigned int value, unsigned int sync) { if (sync) { AT91C_BASE_PWMC->PWMC_OSCUPD = value; } else { AT91C_BASE_PWMC->PWMC_OSC = value; } } //----------------------------------------------------------------------------- /// Set PWM fault mode. /// \param mode Bitwise OR of fault mode. //----------------------------------------------------------------------------- void PWMC_SetFaultMode(unsigned int mode) { AT91C_BASE_PWMC->PWMC_FMR = mode; } //----------------------------------------------------------------------------- /// PWM fault clear. /// \param fault Bitwise OR of fault to clear. //----------------------------------------------------------------------------- void PWMC_FaultClear(unsigned int fault) { AT91C_BASE_PWMC->PWMC_FCR = fault; } //----------------------------------------------------------------------------- /// Set PWM fault protection value. /// \param value Bitwise OR of fault protection value. //----------------------------------------------------------------------------- void PWMC_SetFaultProtectionValue(unsigned int value) { AT91C_BASE_PWMC->PWMC_FPV = value; } //----------------------------------------------------------------------------- /// Enable PWM fault protection. /// \param value Bitwise OR of FPEx[y]. //----------------------------------------------------------------------------- void PWMC_EnableFaultProtection(unsigned int value) { AT91C_BASE_PWMC->PWMC_FPER1 = value; } //----------------------------------------------------------------------------- /// Configure comparison unit. /// \param x comparison x index /// \param value comparison x value. /// \param mode comparison x mode //----------------------------------------------------------------------------- void PWMC_ConfigureComparisonUnit(unsigned int x, unsigned int value, unsigned int mode) { // If channel is disabled, write to CMPxM & CMPxV if ((AT91C_BASE_PWMC->PWMC_SR & (1 << 0)) == 0) { if (x == 0) { AT91C_BASE_PWMC->PWMC_CMP0M = mode; AT91C_BASE_PWMC->PWMC_CMP0V = value; } else if (x == 1) { AT91C_BASE_PWMC->PWMC_CMP1M = mode; AT91C_BASE_PWMC->PWMC_CMP1V = value; } else if (x == 2) { AT91C_BASE_PWMC->PWMC_CMP2M = mode; AT91C_BASE_PWMC->PWMC_CMP2V = value; } else if (x == 3) { AT91C_BASE_PWMC->PWMC_CMP3M = mode; AT91C_BASE_PWMC->PWMC_CMP3V = value; } else if (x == 4) { AT91C_BASE_PWMC->PWMC_CMP4M = mode; AT91C_BASE_PWMC->PWMC_CMP4V = value; } else if (x == 5) { AT91C_BASE_PWMC->PWMC_CMP5M = mode; AT91C_BASE_PWMC->PWMC_CMP5V = value; } else if (x == 6) { AT91C_BASE_PWMC->PWMC_CMP6M = mode; AT91C_BASE_PWMC->PWMC_CMP6V = value; } else if (x == 7) { AT91C_BASE_PWMC->PWMC_CMP7M = mode; AT91C_BASE_PWMC->PWMC_CMP7V = value; } } // Otherwise use update register else { if (x == 0) { AT91C_BASE_PWMC->PWMC_CMP0MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP0VUPD = value; } else if (x == 1) { AT91C_BASE_PWMC->PWMC_CMP1MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP1VUPD = value; } else if (x == 2) { AT91C_BASE_PWMC->PWMC_CMP2MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP2VUPD = value; } else if (x == 3) { AT91C_BASE_PWMC->PWMC_CMP3MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP3VUPD = value; } else if (x == 4) { AT91C_BASE_PWMC->PWMC_CMP4MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP4VUPD = value; } else if (x == 5) { AT91C_BASE_PWMC->PWMC_CMP5MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP5VUPD = value; } else if (x == 6) { AT91C_BASE_PWMC->PWMC_CMP6MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP6VUPD = value; } else if (x == 7) { AT91C_BASE_PWMC->PWMC_CMP7MUPD = mode; AT91C_BASE_PWMC->PWMC_CMP7VUPD = value; } } } //----------------------------------------------------------------------------- /// Configure event line mode. /// \param x Line x /// \param mode Bitwise OR of line mode selection //----------------------------------------------------------------------------- void PWMC_ConfigureEventLineMode(unsigned int x, unsigned int mode) { if (x == 0) { AT91C_BASE_PWMC->PWMC_EL0MR = mode; } else if (x == 1) { AT91C_BASE_PWMC->PWMC_EL1MR = mode; } else if (x == 2) { AT91C_BASE_PWMC->PWMC_EL2MR = mode; } else if (x == 3) { AT91C_BASE_PWMC->PWMC_EL3MR = mode; } else if (x == 4) { AT91C_BASE_PWMC->PWMC_EL4MR = mode; } else if (x == 5) { AT91C_BASE_PWMC->PWMC_EL5MR = mode; } else if (x == 6) { AT91C_BASE_PWMC->PWMC_EL6MR = mode; } else if (x == 7) { AT91C_BASE_PWMC->PWMC_EL7MR = mode; } }