/**
* Close USART serial debug communication port
*/
void dbg_usart_cleanup(void)
{
usart_disable_tx(DBG_USART_BASE);
usart_disable_rx(DBG_USART_BASE);
usart_reset(DBG_USART_BASE);
pmc_disable_periph_clk(DBG_USART_ID);
}
// (re)initialize UART0 as a monitor output to 250000,n,8,1
static void TXBegin(void) {
// Disable UART interrupt in NVIC
NVIC_DisableIRQ( UART_IRQn );
// We NEED memory barriers to ensure Interrupts are actually disabled!
// ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
__DSB();
__ISB();
// Disable clock
pmc_disable_periph_clk( ID_UART );
// Configure PMC
pmc_enable_periph_clk( ID_UART );
// Disable PDC channel
UART->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
// Reset and disable receiver and transmitter
UART->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;
// Configure mode: 8bit, No parity, 1 bit stop
UART->UART_MR = UART_MR_CHMODE_NORMAL | US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_NO;
// Configure baudrate (asynchronous, no oversampling) to BAUDRATE bauds
UART->UART_BRGR = (SystemCoreClock / (BAUDRATE << 4));
// Enable receiver and transmitter
UART->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
}
static void Wire1_Deinit(void) {
NVIC_DisableIRQ(WIRE1_ISR_ID);
NVIC_ClearPendingIRQ(WIRE1_ISR_ID);
pmc_disable_periph_clk(WIRE1_INTERFACE_ID);
// no need to undo PIO_Configure,
// as Peripheral A was enable by default before,
// and pullups were not enabled
}
extern void pinMode( uint32_t ulPin, uint32_t ulMode )
{
if ( g_APinDescription[ulPin].ulPinType == PIO_NOT_A_PIN )
{
return ;
}
/* Added by Y.Ishioka */
if( ulPin == 13 ) {
led_init() ;
led_set( 1 ) ;
return ;
}
switch ( ulMode )
{
case INPUT:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ;
PIO_Configure(
g_APinDescription[ulPin].pPort,
PIO_INPUT,
g_APinDescription[ulPin].ulPin,
0 ) ;
break ;
case INPUT_PULLUP:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ;
PIO_Configure(
g_APinDescription[ulPin].pPort,
PIO_INPUT,
g_APinDescription[ulPin].ulPin,
PIO_PULLUP ) ;
break ;
case OUTPUT:
PIO_Configure(
g_APinDescription[ulPin].pPort,
PIO_OUTPUT_1,
g_APinDescription[ulPin].ulPin,
g_APinDescription[ulPin].ulPinConfiguration ) ;
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if ( g_APinDescription[ulPin].pPort->PIO_OSR == 0xffffffff )
{
pmc_disable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ;
}
break ;
default:
break ;
}
}
void UARTClass::end( void )
{
// Clear any received data
_rx_buffer->_iHead = _rx_buffer->_iTail;
// Wait for any outstanding data to be sent
flush();
// Disable UART interrupt in NVIC
NVIC_DisableIRQ( _dwIrq );
pmc_disable_periph_clk( _dwId );
}
void uhd_disable(bool b_id_stop)
{
UNUSED(b_id_stop);
irqflags_t flags;
flags = cpu_irq_save();
ohci_deinit();
cpu_irq_restore(flags);
/* Do not authorize asynchronous USB interrupts. */
// pmc_clr_fast_startup_input(PMC_FSMR_USBAL);
sysclk_disable_usb();
pmc_disable_periph_clk(ID_UHP);
uhd_sleep_mode(UHD_STATE_OFF);
}
/**
* Initializes a MCI driver instance and the underlying peripheral.
* \param pMci Pointer to a MCI driver instance.
* \param pMciHw Pointer to a MCI peripheral.
* \param mciId MCI peripheral identifier.
*/
void MCI_Init( Mcid *pMci, Hsmci *pMciHw, uint8_t mciId, uint32_t dwMCk )
{
unsigned long clkDiv;
/* Initialize the MCI driver structure */
pMci->pMciHw = pMciHw;
pMci->mciId = mciId;
pMci->semaphore = 1;
pMci->pCommand = NULL;
/* Enable the MCI peripheral */
pmc_enable_periph_clk( mciId );
/* Reset the MCI */
pMciHw->HSMCI_CR = HSMCI_CR_SWRST;
/* Disable the MCI */
pMciHw->HSMCI_CR = HSMCI_CR_MCIDIS | HSMCI_CR_PWSDIS;
/* Disable all the interrupts */
pMciHw->HSMCI_IDR = 0xFFFFFFFF;
/* Set the Data Timeout Register */
pMciHw->HSMCI_DTOR = HSMCI_DTOR_DTOCYC_Msk | HSMCI_DTOR_DTOMUL_Msk ;
/* CSTOR ? */
pMciHw->HSMCI_CSTOR = HSMCI_CSTOR_CSTOCYC_Msk | HSMCI_CSTOR_CSTOMUL_Msk ;
/* Set the Mode Register: 400KHz for MCK = 48MHz (CLKDIV = 58) */
clkDiv = (dwMCk / (MCI_INITIAL_SPEED * 2)) - 1;
pMciHw->HSMCI_MR = ((uint8_t)clkDiv | (HSMCI_MR_PWSDIV( 0x07 )) ) ;
/* Set the SDCard Register 1-bit, slot A */
pMciHw->HSMCI_SDCR = HSMCI_SDCR_SDCSEL_SLOTA | HSMCI_SDCR_SDCBUS_1 ;
/* Enable the MCI and the Power Saving */
pMciHw->HSMCI_CR = HSMCI_CR_MCIEN;
/* Configure MCI */
pMciHw->HSMCI_CFG = HSMCI_CFG_FIFOMODE
| ((1 << 4) & HSMCI_CFG_FERRCTRL);
/* Disable the MCI peripheral clock. */
pmc_disable_periph_clk(mciId);
}
/**
* \brief Test sleep Mode.
*/
static void test_sleep_mode(void)
{
/* Configure button for waking up sleep mode */
configure_button();
/* Select clock for sleep mode */
user_change_clock(STRING_SLEEP);
/* Disable UART */
pmc_disable_periph_clk(CONSOLE_UART_ID);
/* Enter into sleep Mode */
pmc_enable_sleepmode(0);
/* Set default clock and re-configure UART */
set_default_working_clock();
reconfigure_console(g_ul_current_mck, CONF_UART_BAUDRATE);
puts("Exit from sleep Mode.\r");
}
void udd_disable(void)
{
irqflags_t flags;
#ifdef UHD_ENABLE
# if OTG_ID_IO
if (Is_otg_id_host()) {
// Freeze clock to switch mode
otg_freeze_clock();
udd_detach();
otg_disable();
return; // Host mode running, ignore UDD disable
}
# else
if (Is_otg_host_mode_forced()) {
return; // Host mode running, ignore UDD disable
}
# endif
#endif
flags = cpu_irq_save();
otg_unfreeze_clock();
udd_detach();
#ifndef UDD_NO_SLEEP_MGR
if (udd_b_sleep_initialized) {
udd_b_sleep_initialized = false;
sleepmgr_unlock_mode(UHDP_SLEEP_MODE_USB_SUSPEND);
}
#endif
#ifndef UHD_ENABLE
otg_disable();
sysclk_disable_usb();
pmc_disable_periph_clk(ID_UOTGHS);
#endif
cpu_irq_restore(flags);
}
extern "C" void pinModeDuet(Pin pin, enum PinMode ulMode, uint32_t debounceCutoff)
{
if (pin > MaxPinNumber)
{
return;
}
const PinDescription& pinDesc = g_APinDescription[pin];
if (pinDesc.ulPinType == PIO_NOT_A_PIN)
{
return;
}
switch (ulMode)
{
case INPUT:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pullup
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? 0 : PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
case INPUT_PULLUP:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? PIO_PULLUP : PIO_PULLUP | PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
#if SAM4E
case INPUT_PULLDOWN:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0);
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 1);
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? 0 : PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
#endif
case OUTPUT_LOW:
pio_configure(
pinDesc.pPort,
PIO_OUTPUT_0,
pinDesc.ulPin,
pinDesc.ulPinConfiguration);
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if (pinDesc.pPort->PIO_OSR == 0xffffffff)
{
pmc_disable_periph_clk(pinDesc.ulPeripheralId);
}
break;
case OUTPUT_HIGH:
pio_configure(
pinDesc.pPort,
PIO_OUTPUT_1,
pinDesc.ulPin,
pinDesc.ulPinConfiguration);
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if (pinDesc.pPort->PIO_OSR == 0xffffffff)
{
pmc_disable_periph_clk(pinDesc.ulPeripheralId);
}
break;
case OUTPUT_PWM_LOW:
if ((pinDesc.ulPinAttribute & (PIN_ATTR_PWM | PIN_ATTR_TIMER)) != 0)
{
AnalogOut(pin, 0.0, 0); // set it to zero frequency to force re-initialisation on next AnalogOut call
}
break;
case OUTPUT_PWM_HIGH:
if ((pinDesc.ulPinAttribute & (PIN_ATTR_PWM | PIN_ATTR_TIMER)) != 0)
{
AnalogOut(pin, 1.0, 0); // set it to zero frequency to force re-initialisation on next AnalogOut call
}
break;
case AIN:
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pullup
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
// Ideally we should record which pins are being used as analog inputs, then we can disable the clock
// on any PIO that is being used solely for outputs and ADC inputs. But for now we don't do that.
break;
case SPECIAL:
ConfigurePin(pinDesc);
break;
default:
break;
}
}
extern void pinMode( uint32_t ulPin, uint32_t ulMode )
{
if ( g_APinDescription[ulPin].ulPinType == PIO_NOT_A_PIN )
{
return ;
}
if ((g_pinStatus[ulPin] & 0xF) == PIN_STATUS_ANALOG)
{
adc_disable_channel( ADC, g_APinDescription[ulPin].ulADCChannelNumber);
}
if ((g_pinStatus[ulPin] & 0xF) < PIN_STATUS_DIGITAL_OUTPUT && g_pinStatus[ulPin] != 0)
{
// return if already configured in the right way
if (((g_pinStatus[ulPin] & 0xF) == PIN_STATUS_DIGITAL_INPUT && ulMode == INPUT) ||
((g_pinStatus[ulPin] & 0xF) == PIN_STATUS_DIGITAL_INPUT_PULLUP && ulMode == INPUT_PULLUP) ||
((g_pinStatus[ulPin] & 0xF) == PIN_STATUS_DIGITAL_OUTPUT && ulMode == OUTPUT))
return;
}
switch ( ulMode )
{
case INPUT:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ;
PIO_Configure(
g_APinDescription[ulPin].pPort,
PIO_INPUT,
g_APinDescription[ulPin].ulPin,
0 ) ;
g_pinStatus[ulPin] = (g_pinStatus[ulPin] & 0xF0) | PIN_STATUS_DIGITAL_INPUT;
break ;
case INPUT_PULLUP:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ;
PIO_Configure(
g_APinDescription[ulPin].pPort,
PIO_INPUT,
g_APinDescription[ulPin].ulPin,
PIO_PULLUP ) ;
g_pinStatus[ulPin] = (g_pinStatus[ulPin] & 0xF0) | PIN_STATUS_DIGITAL_INPUT_PULLUP;
break ;
case OUTPUT:
PIO_Configure(
g_APinDescription[ulPin].pPort,
(g_pinStatus[ulPin] & 0xF0) >> 4 ? PIO_OUTPUT_1 : PIO_OUTPUT_0,
g_APinDescription[ulPin].ulPin,
g_APinDescription[ulPin].ulPinConfiguration ) ;
g_pinStatus[ulPin] = (g_pinStatus[ulPin] & 0xF0) | PIN_STATUS_DIGITAL_OUTPUT;
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if ( g_APinDescription[ulPin].pPort->PIO_OSR == 0xffffffff )
{
pmc_disable_periph_clk( g_APinDescription[ulPin].ulPeripheralId ) ;
}
break ;
default:
break ;
}
}
/**
* \brief Disable ADC Module.
*
*/
void adc_disable(void)
{
/* Disable peripheral clock. */
pmc_disable_periph_clk(ID_ADC);
sleepmgr_unlock_mode(SLEEPMGR_SLEEP_WFI);
}
