devices.c

#include <NUC1261.h>
#include "devices.h"


void ConfigurePins( void )
{
	SYS->GPA_MFPL =
			SYS_GPA_MFPL_PA0MFP_GPIO
		|	SYS_GPA_MFPL_PA1MFP_PWM1_CH4
		|	SYS_GPA_MFPL_PA2MFP_PWM1_CH3
		|	SYS_GPA_MFPL_PA3MFP_PWM1_CH2
		;

	SYS->GPB_MFPL =
			SYS_GPB_MFPL_PB0MFP_ADC0_CH0
		|	SYS_GPB_MFPL_PB1MFP_GPIO
		|	SYS_GPB_MFPL_PB2MFP_GPIO
		|	SYS_GPB_MFPL_PB3MFP_ADC0_CH3
		|	SYS_GPB_MFPL_PB4MFP_ADC0_CH4
		|	SYS_GPB_MFPL_PB5MFP_ADC0_CH13
		|	SYS_GPB_MFPL_PB6MFP_ADC0_CH14
		|	SYS_GPB_MFPL_PB7MFP_ADC0_CH15
		;

	GPIO_DISABLE_DIGITAL_PATH(
		PB,
			GPIO_PIN_PIN0_Msk
		|	GPIO_PIN_PIN3_Msk
		|	GPIO_PIN_PIN4_Msk
		|	GPIO_PIN_PIN5_Msk
		|	GPIO_PIN_PIN6_Msk
		|	GPIO_PIN_PIN7_Msk
	);

	SYS->GPC_MFPL =
			SYS_GPC_MFPL_PC0MFP_SPI0_CLK
		|	SYS_GPC_MFPL_PC1MFP_GPIO
		|	SYS_GPC_MFPL_PC2MFP_GPIO
		|	SYS_GPC_MFPL_PC3MFP_SPI0_MOSI
		|	SYS_GPC_MFPL_PC4MFP_GPIO
		;

	SYS->GPD_MFPL =
			SYS_GPD_MFPL_PD0MFP_GPIO
		|	SYS_GPD_MFPL_PD1MFP_GPIO
		|	SYS_GPD_MFPL_PD2MFP_GPIO
		|	SYS_GPD_MFPL_PD3MFP_GPIO
		|	SYS_GPD_MFPL_PD7MFP_PWM0_CH5
		;

	SYS->GPE_MFPL =
			SYS_GPE_MFPL_PE0MFP_GPIO
		|	SYS_GPE_MFPL_PE6MFP_GPIO
		|	SYS_GPE_MFPL_PE7MFP_GPIO
		;

	SYS->GPE_MFPH =
			SYS_GPE_MFPH_PE10MFP_GPIO
		|	SYS_GPE_MFPH_PE11MFP_GPIO
		|	SYS_GPE_MFPH_PE12MFP_GPIO
		|	SYS_GPE_MFPH_PE13MFP_GPIO
		;

	SYS->GPF_MFPL =
			SYS_GPF_MFPL_PF0MFP_GPIO
		|	SYS_GPF_MFPL_PF1MFP_GPIO
		|	SYS_GPF_MFPL_PF2MFP_GPIO
		|	SYS_GPF_MFPL_PF3MFP_GPIO
		|	SYS_GPF_MFPL_PF4MFP_GPIO
		|	SYS_GPF_MFPL_PF7MFP_GPIO
		;
}

void ConfigureGPIO( void )
{
	GPIO_SetMode( PA,
		GPIO_PIN_PIN0_Msk,
		GPIO_MODE_OUTPUT );

	GPIO_SET_OUT_DATA( PA, 0 );

	PA0  = 0;

	GPIO_SetMode( PB,
		GPIO_PIN_PIN1_Msk|GPIO_PIN_PIN2_Msk,
		GPIO_MODE_OUTPUT );

	GPIO_SET_OUT_DATA( PB, 0 );

	PB1  = 0;
	PB2  = 0;

	GPIO_SetMode( PC,
		GPIO_PIN_PIN1_Msk|GPIO_PIN_PIN2_Msk|GPIO_PIN_PIN4_Msk,
		GPIO_MODE_OUTPUT );

	GPIO_SET_OUT_DATA( PC, 0 );

	PC1  = 0;
	PC2  = 0;
	PC4  = 0;

	GPIO_SetMode( PD,
		GPIO_PIN_PIN0_Msk,
		GPIO_MODE_QUASI );

	GPIO_SetMode( PD,
		GPIO_PIN_PIN1_Msk|GPIO_PIN_PIN2_Msk|GPIO_PIN_PIN3_Msk,
		GPIO_MODE_OUTPUT );

	GPIO_SET_OUT_DATA( PD, 0 );

	PD0  = 1;

	PD1  = 0;
	PD2  = 0;
	PD3  = 0;

	GPIO_SetMode( PE,
		GPIO_PIN_PIN0_Msk,
		GPIO_MODE_INPUT );

	GPIO_SetMode( PE,
		GPIO_PIN_PIN6_Msk|GPIO_PIN_PIN7_Msk|GPIO_PIN_PIN11_Msk|GPIO_PIN_PIN12_Msk,
		GPIO_MODE_OUTPUT );

	GPIO_SetMode( PE,
		GPIO_PIN_PIN10_Msk|GPIO_PIN_PIN13_Msk,
		GPIO_MODE_QUASI );

	GPIO_SET_OUT_DATA( PE, 0 );

	PE6  = 0;
	PE7  = 0;
	PE11 = 0;
	PE12 = 0;

	PE10 = 1;
	PE13 = 1;

	GPIO_SetMode( PF, 
		GPIO_PIN_PIN0_Msk|GPIO_PIN_PIN1_Msk|GPIO_PIN_PIN2_Msk|GPIO_PIN_PIN3_Msk|GPIO_PIN_PIN4_Msk|GPIO_PIN_PIN7_Msk,
		GPIO_MODE_OUTPUT );

	GPIO_SetMode( PF, 
		GPIO_PIN_PIN5_Msk|GPIO_PIN_PIN6_Msk,
		GPIO_MODE_INPUT );

	GPIO_SET_OUT_DATA( PF, 0 );

	PF0  = 0;
	PF1  = 0;
	PF2  = 0;
	PF3  = 0;
	PF7  = 0;

	PF4  = 0;
}


void DisableHDIV()
{
	CLK_DisableModuleClock( HDIV_MODULE );
}


void ConfigureSPI0( void )
{
	CLK_EnableModuleClock( SPI0_MODULE );
	CLK_SetModuleClock( SPI0_MODULE, CLK_CLKSEL2_SPI0SEL_PLL, 0 );

	NVIC_DisableIRQ( SPI0_IRQn );

	SPI_Open( SPI0, SPI_MASTER, SPI_MODE_0, 8, 29000000 /* PLL÷5 = 28753920 */ );
	SPI_DisableAutoSS( SPI0 );
}


void DisableSPI0()
{
	SPI_Close( SPI0 );
	SPI_DISABLE( SPI0 );
	CLK_DisableModuleClock( SPI0_MODULE );
	NVIC_DisableIRQ( SPI0_IRQn );
	PC0 = 0;
	PC3 = 0;
}


void ConfigurePWM0( void )
{
	CLK_EnableModuleClock( PWM0_MODULE );
	CLK_SetModuleClock( PWM0_MODULE, CLK_CLKSEL1_PWM0SEL_PLL , 0 );

	NVIC_DisableIRQ( PWM0_IRQn );

	PWM0->CTL1 = PWM0->CTL1
		& ~( PWM_BCH_CNTTYPE_Msk )
		|  ( PWM_UP_COUNTER << PWM_BCH_CNTTYPE_Pos )
	;

	PWM_SET_OUTPUT_LEVEL( PWM0,
		PWM_CH_BCH_MASK,
		PWM_OUTPUT_HIGH, PWM_OUTPUT_LOW, PWM_OUTPUT_NOTHING, PWM_OUTPUT_NOTHING
	);

	PWM_SET_PRESCALER( PWM0, PWM_CH_BCH, 2 );
	PWM_SET_CNR( PWM0, PWM_CH_BCH, 199 );
	PWM_SET_CMR( PWM0, PWM_CH_BCH, 0 );
}


void ConfigurePWM1( void )
{
	CLK_EnableModuleClock( PWM1_MODULE );
	CLK_SetModuleClock( PWM1_MODULE, CLK_CLKSEL1_PWM1SEL_PLL , 0 );

	NVIC_DisableIRQ( PWM1_IRQn );

	PWM1->CTL1 = PWM1->CTL1
		& ~( PWM_LCD_CNTTYPE_Msk | PWM_BOOST_CNTTYPE_Msk | PWM_BUCK_CNTTYPE_Msk )
		| (( PWM_UP_COUNTER << PWM_LCD_CNTTYPE_Pos ) |
		   ( PWM_UP_COUNTER << PWM_BOOST_CNTTYPE_Pos ) |
		   ( PWM_UP_COUNTER << PWM_BUCK_CNTTYPE_Pos ))
	;

	PWM_SET_OUTPUT_LEVEL( PWM1,
		PWM_CH_LCD_MASK | PWM_CH_BOOST_MASK | PWM_CH_BUCK_MASK,
		PWM_OUTPUT_HIGH, PWM_OUTPUT_LOW, PWM_OUTPUT_NOTHING, PWM_OUTPUT_NOTHING
	);

	PWM_SET_PRESCALER( PWM1, PWM_CH_BOOST, 5 );
	PWM_SET_CNR( PWM1, PWM_CH_BOOST, 199 );
	PWM_SET_CMR( PWM1, PWM_CH_BOOST, 0 );

	PWM_SET_PRESCALER( PWM1, PWM_CH_BUCK, 5 );
	PWM_SET_CNR( PWM1, PWM_CH_BUCK, 199 );
	PWM_SET_CMR( PWM1, PWM_CH_BUCK, 200 );

	// Original firmware sets the LCD prescaler to 2,
	// but since the LCD and the boost PWM share the same prescaler,
	// this resets the boost prescaler to 2 also instead of 5.
	// This is a hardware design flaw.
	// The best we can do is keeping the prescaler at 5 for the LCD,
	// wich works fine.

//	PWM_SET_PRESCALER( PWM1, PWM_CH_LCD, 2 );
	PWM_SET_CNR( PWM1, PWM_CH_LCD, 99 );
	PWM_SET_CMR( PWM1, PWM_CH_LCD, 0 );
}


void DisablePWM0()
{
	PWM_DisableOutput( PWM0, PWM_CH_BCH_MASK );
	PWM_ForceStop( PWM0, PWM_CH_BCH_MASK );
	CLK_DisableModuleClock( PWM0_MODULE );
	NVIC_DisableIRQ( PWM0_IRQn );
}


void DisablePWM1()
{
	PWM_DisableOutput( PWM1, PWM_CH_LCD_MASK | PWM_CH_BOOST_MASK | PWM_CH_BUCK_MASK );
	PWM_ForceStop( PWM1, PWM_CH_LCD_MASK | PWM_CH_BOOST_MASK | PWM_CH_BUCK_MASK );
	CLK_DisableModuleClock( PWM1_MODULE );
	NVIC_DisableIRQ( PWM1_IRQn );
}


void ConfigureADC()
{
	CLK_EnableModuleClock( ADC_MODULE );
	CLK_SetModuleClock( ADC_MODULE, CLK_CLKSEL1_ADCSEL_HIRC, CLK_CLKDIV0_ADC( 7 ) );

	NVIC_DisableIRQ( ADC_IRQn );

	ADC_POWER_ON( ADC );
}


void DisableADC()
{
	ADC_Close( ADC );
	ADC_POWER_DOWN( ADC );
	CLK_DisableModuleClock( ADC_MODULE );
	NVIC_DisableIRQ( ADC_IRQn );
}


uint32_t ADCSample( uint32_t ch, int count )
{
	uint32_t sample;

	ADC_Open( ADC, ADC_ADCR_DIFFEN_SINGLE_END, ADC_ADCR_ADMD_SINGLE, 0x1 << ch );

	sample = 0;
	for ( int i = 0 ; i < count ; ++i )
	{
		ADC_START_CONV( ADC );
		while ( !ADC_IS_DATA_VALID( ADC, ch ) )
			;
		sample += ADC_GET_CONVERSION_DATA( ADC, ch );
	}

	sample = sample / count;
	return sample;
}