mpu_util.h File Reference

Detailed Description

Date

Jul 27, 2014

Author

Andrey Belomutskiy, (c) 2012-2020

andreika prome.nosp@m.theu.nosp@m.s.pcb.nosp@m.@gma.nosp@m.il.co.nosp@m.m

Definition in file mpu_util.h.

Data Structures
struct	hardware_pwm

Enumerations
enum	BOR_Result_t { BOR_Result_Ok = 0x00 , BOR_Result_Error }
enum	Reset_Cause_t {   Reset_Cause_Unknown = 0 , Reset_Cause_IWatchdog , Reset_Cause_WWatchdog , Reset_Cause_Soft_Reset ,   Reset_Cause_NRST_Pin , Reset_Cause_POR , Reset_Cause_Illegal_Mode , Reset_Cause_BOR ,   Reset_Cause_Firewall , Reset_Cause_Option_Byte }

Functions
void	baseMCUInit ()
void	jump_to_bootloader ()
void	jump_to_openblt ()
void	causeHardFault ()
bool	mcuCanFlashWhileRunning ()
bool	isStm32F42x ()
adc_channel_e	getAdcChannel (brain_pin_e pin)
brain_pin_e	getAdcChannelBrainPin (const char *msg, adc_channel_e hwChannel)
bool	adcIsMuxedInput (adc_channel_e hwChannel)
adc_channel_e	adcMuxedGetParent (adc_channel_e hwChannel)
int	getAdcInternalChannel (ADC_TypeDef *adc, adc_channel_e hwChannel)
adc_channel_e	getHwChannelForAdcInput (ADC_TypeDef *adc, size_t hwIndex)
ioportid_t	getAdcChannelPort (const char *msg, adc_channel_e hwChannel)
int	getAdcChannelPin (adc_channel_e hwChannel)
void	portInitAdc ()
float	getMcuTemperature ()
float	getMcuVrefVoltage ()
bool	readSlowAnalogInputs (adcsample_t *convertedSamples)
bool	isValidCanTxPin (brain_pin_e pin)
bool	isValidCanRxPin (brain_pin_e pin)
CANDriver *	detectCanDevice (brain_pin_e pinRx, brain_pin_e pinTx)
void	canHwInfo (CANDriver *cand)
bool	isValidSerialTxPin (brain_pin_e pin)
bool	isValidSerialRxPin (brain_pin_e pin)
void	initSpiModule (SPIDriver *driver, brain_pin_e sck, brain_pin_e miso, brain_pin_e mosi, int sckMode, int mosiMode, int misoMode)
void	initSpiCsNoOccupy (SPIConfig *spiConfig, brain_pin_e csPin)
void	initSpiCs (SPIConfig *spiConfig, brain_pin_e csPin)
void	turnOnSpi (spi_device_e device)
int	spiGetBaseClock (SPIDriver *spip)
int	spiCalcClockDiv (SPIDriver *spip, SPIConfig *spiConfig, unsigned int clk)
bool	getIcuParams (brain_pin_e hwPin, iomode_t *af_ptr, ICUDriver **icu_ptr, icuchannel_t *channel_ptr, uint32_t *clock_ptr)
BOR_Level_t	BOR_Get (void)
BOR_Result_t	BOR_Set (BOR_Level_t BORValue)
Reset_Cause_t	getMCUResetCause ()
const char *	getMCUResetCause (Reset_Cause_t cause)
int	at32GetMcuType (uint32_t id, const char **pn, const char **package, uint32_t *flashSize)
int	at32GetRamSizeKb (void)
void	DebugMonitorVector (void)
void	UsageFaultVector (void)
void	BusFaultVector (void)
void	HardFaultVector (void)

Variables
SPIConfig	mmc_hs_spicfg
SPIConfig	mmc_ls_spicfg

Enumeration Type Documentation

BOR_Result_t

enum BOR_Result_t

Enumerator
BOR_Result_Ok
BOR_Result_Error

Definition at line 95 of file mpu_util.h.

             {
    BOR_Result_Ok = 0x00,
    BOR_Result_Error
} BOR_Result_t;

Reset_Cause_t

enum Reset_Cause_t

Enumerator
Reset_Cause_Unknown
Reset_Cause_IWatchdog
Reset_Cause_WWatchdog
Reset_Cause_Soft_Reset
Reset_Cause_NRST_Pin
Reset_Cause_POR
Reset_Cause_Illegal_Mode
Reset_Cause_BOR
Reset_Cause_Firewall
Reset_Cause_Option_Byte

Definition at line 104 of file mpu_util.h.

             {
    Reset_Cause_Unknown = 0,
    Reset_Cause_IWatchdog,      // Independent hardware watchdog (we use it)
    Reset_Cause_WWatchdog,      // Window watchdog
    Reset_Cause_Soft_Reset,     // NVIC_SystemReset or by debugger
    Reset_Cause_NRST_Pin,       // Reset from NRST pin
    Reset_Cause_POR,            // POR/PDR reset
    Reset_Cause_Illegal_Mode,   // Reset after illegal Stop, Standby or Shutdown mode entry
    Reset_Cause_BOR,            // BOR reset
    Reset_Cause_Firewall,       // Firewall reset
    Reset_Cause_Option_Byte,    // Option byte load reset
} Reset_Cause_t;

Function Documentation

adcIsMuxedInput()

bool adcIsMuxedInput

(

adc_channel_e

hwChannel

)

Definition at line 150 of file cypress_common.cpp.

                                              {
    return false;
}

Referenced by adcMuxedGetParent().

Here is the call graph for this function:

Here is the caller graph for this function:

adcMuxedGetParent()

adc_channel_e adcMuxedGetParent

(

adc_channel_e

hwChannel

)

Definition at line 154 of file cypress_common.cpp.

{
    return hwChannel;
}

Referenced by getAdcChannelBrainPin().

Here is the call graph for this function:

Here is the caller graph for this function:

at32GetMcuType()

int at32GetMcuType	(	uint32_t	id,
		const char **	pn,
		const char **	package,
		uint32_t *	flashSize
	)

Definition at line 12 of file at32_common.cpp.

{
    const struct {
        uint32_t uid;
        const char *pn;
        uint32_t flashSize;
        const char *package;
    } at32f43x_types[] = {
        { 0x70084540, "AT32F435ZMT7", 4032, "LQFP144" },
        { 0x70083341, "AT32F435ZGT7", 1024, "LQFP144" },
        { 0x70084598, "AT32F435ZDT7",  448, "LQFP144" },
        { 0x70083242, "AT32F435ZCT7",  256, "LQFP144" },
        { 0x70084543, "AT32F435VMT7", 4032, "LQFP100" },
        { 0x70083344, "AT32F435VGT7", 1024, "LQFP100" },
        { 0x70084599, "AT32F435VDT7",  448, "LQFP100" },
        { 0x70083245, "AT32F435VCT7",  256, "LQFP100" },
        { 0x70084546, "AT32F435RMT7", 4032,  "LQFP64" },
        { 0x70083347, "AT32F435RGT7", 1024,  "LQFP64" },
        { 0x7008459A, "AT32F435RDT7",  448,  "LQFP64" },
        { 0x70083248, "AT32F435RCT7",  256,  "LQFP64" },
        { 0x70084549, "AT32F435CMT7", 4032,  "LQFP48" },
        { 0x7008334A, "AT32F435CGT7", 1024,  "LQFP48" },
        { 0x7008459B, "AT32F435CDT7",  448,  "LQFP48" },
        { 0x7008324B, "AT32F435CCT7",  256,  "LQFP48" },
        { 0x7008454C, "AT32F435CMU7", 4032,   "QFN48" },
        { 0x7008334D, "AT32F435CGU7", 1024,   "QFN48" },
        { 0x7008459C, "AT32F435CDU7",  448,   "QFN48" },
        { 0x7008324E, "AT32F435CCU7",  256,   "QFN48" },
        { 0x7008454F, "AT32F437ZMT7", 4032, "LQFP144" },
        { 0x70083350, "AT32F437ZGT7", 1024, "LQFP144" },
        { 0x7008459D, "AT32F437ZDT7",  448, "LQFP144" },
        { 0x70083251, "AT32F437ZCT7",  256, "LQFP144" },
        { 0x70084552, "AT32F437VMT7", 4032, "LQFP100" },
        { 0x70083353, "AT32F437VGT7", 1024, "LQFP100" },
        { 0x7008459E, "AT32F437VDT7",  448, "LQFP100" },
        { 0x70083254, "AT32F437VCT7",  256, "LQFP100" },
        { 0x70084555, "AT32F437RMT7", 4032,  "LQFP64" },
        { 0x70083356, "AT32F437RGT7", 1024,  "LQFP64" },
        { 0x7008459F, "AT32F437RDT7",  448,  "LQFP64" },
        { 0x70083257, "AT32F437RCT7",  256,  "LQFP64" },
    };
 
    for (size_t i = 0; i < efi::size(at32f43x_types); i++) {
        if (id == at32f43x_types[i].uid) {
            if (pn)
                *pn = at32f43x_types[i].pn;
            if (package)
                *package = at32f43x_types[i].package;
            if (flashSize)
                *flashSize = at32f43x_types[i].flashSize;
            return 0;
        }
    }
 
    /* unknown */
    return -1;
}

Referenced by sayHello().

Here is the call graph for this function:

Here is the caller graph for this function:

at32GetRamSizeKb()

int at32GetRamSizeKb

(

void

)

Definition at line 70 of file at32_common.cpp.

{
    uint8_t EOPB0 = *(__IO uint16_t *) (0x1FFFC010);
    /* TODO: check inverted value */
 
    switch ((*(__IO uint16_t *) (FLASHSIZE_BASE))) {
    case 256:
        EOPB0 &= 0x03;
        if (EOPB0 == 3)
            EOPB0 = 2;
        return 512 - (64 * EOPB0);
    case 448:
        EOPB0 &= 0x07;
        if (EOPB0 > 5)
            EOPB0 = 5;
        return 512 - (64 * EOPB0);
    case 1024:
    case 4032:
        EOPB0 &= 0x07;
        if (EOPB0 > 6)
            EOPB0 = 6;
        return 512 - (64 * EOPB0);
    default:
        return 0;
    }
    return 0;
}

Referenced by sayHello().

Here is the caller graph for this function:

baseMCUInit()

void baseMCUInit

(

)

Definition at line 146 of file at32_common.cpp.

                   {
    // looks like this holds a random value on start? Let's set a nice clean zero
    DWT->CYCCNT = 0;
 
    BOR_Set(BOR_Level_1); // one step above default value
}

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

BOR_Get()

BOR_Level_t BOR_Get

(

void

)

Definition at line 126 of file at32_common.cpp.

                          {
    /* TODO: Artery */
    /* Fake */
    return BOR_Level_None;
}

Referenced by BOR_Set().

Here is the call graph for this function:

Here is the caller graph for this function:

BOR_Set()

BOR_Result_t BOR_Set

(

BOR_Level_t

BORValue

)

Definition at line 132 of file at32_common.cpp.

                                           {
    /* NOP */
    return BOR_Result_Ok;
}

Referenced by baseMCUInit(), and setBor().

Here is the call graph for this function:

Here is the caller graph for this function:

BusFaultVector()

void BusFaultVector

(

void

)

Definition at line 56 of file mpu_util.cpp.

                          {
    chDbgPanic3("BusFaultVector", __FILE__, __LINE__);
    while (TRUE) {
    }
}

Here is the call graph for this function:

canHwInfo()

void canHwInfo

(

CANDriver *

cand

)

Definition at line 129 of file at32_can.cpp.

{
   /* TODO: */
   (void)cand;
}

Referenced by canInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

causeHardFault()

void causeHardFault

(

)

Definition at line 16 of file arm_common.cpp.

                      {
#if EFI_PROD_CODE
    // Set the function pointer to an invalid address
    void (*invalidFunction)() = (void(*)())0xDEADBEEF;
    // Calling the invalid function will trigger a hard fault
    invalidFunction();
#endif  /* EFI_PROD_CODE */
}

Referenced by errorHandlerInit().

Here is the caller graph for this function:

DebugMonitorVector()

void DebugMonitorVector

(

void

)

Definition at line 44 of file mpu_util.cpp.

                              {
    chDbgPanic3("DebugMonitorVector", __FILE__, __LINE__);
    while (TRUE)
        ;
}

Here is the call graph for this function:

detectCanDevice()

CANDriver * detectCanDevice	(	brain_pin_e	pinRx,
		brain_pin_e	pinTx
	)

Definition at line 93 of file at32_can.cpp.

                                                                 {
    if (pinRx == Gpio::Unassigned || pinTx == Gpio::Unassigned) {
        return nullptr;
    }
#if STM32_CAN_USE_CAN1 || STM32_CAN_USE_FDCAN1
   if (isValidCan1RxPin(pinRx) && isValidCan1TxPin(pinTx))
      return &CAND1;
#endif
#if STM32_CAN_USE_CAN2 || STM32_CAN_USE_FDCAN2
   if (isValidCan2RxPin(pinRx) && isValidCan2TxPin(pinTx))
      return &CAND2;
#endif
   criticalError("invalid CAN pins tx %s and rx %s", hwPortname(pinTx), hwPortname(pinRx));
   return nullptr;
}

Referenced by canInfo(), and initCan().

Here is the call graph for this function:

Here is the caller graph for this function:

getAdcChannel()

adc_channel_e getAdcChannel

(

brain_pin_e

pin

)

Definition at line 103 of file cypress_common.cpp.

                                             {
    switch (pin) {
    case Gpio::B0:
        return EFI_ADC_0;
    case Gpio::B1:
        return EFI_ADC_1;
    case Gpio::B2:
        return EFI_ADC_2;
    case Gpio::B3:
        return EFI_ADC_3;
    case Gpio::B4:
        return EFI_ADC_4;
    case Gpio::B5:
        return EFI_ADC_5;
    case Gpio::B8:
        return EFI_ADC_8;
    case Gpio::B9:
        return EFI_ADC_9;
    case Gpio::B12:
        return EFI_ADC_12;
    case Gpio::B13:
        return EFI_ADC_13;
    case Gpio::B14:
        return EFI_ADC_14;
    case Gpio::B15:
        return EFI_ADC_15;
    case Gpio::C10:
        return EFI_ADC_24;
    case Gpio::C9:
        return EFI_ADC_25;
    case Gpio::C8:
        return EFI_ADC_26;
    case Gpio::C7:
        return EFI_ADC_27;
    case Gpio::C5:
        return EFI_ADC_28;
    case Gpio::C4:
        return EFI_ADC_29;
    case Gpio::C3:
        return EFI_ADC_30;
    case Gpio::C2:
        return EFI_ADC_31;
    default:
        return EFI_ADC_ERROR;
    }
}

Referenced by getAdcChannelForTrigger(), and setAnalogInputPin().

Here is the caller graph for this function:

getAdcChannelBrainPin()

brain_pin_e getAdcChannelBrainPin	(	const char *	msg,
		adc_channel_e	hwChannel
	)

Definition at line 30 of file cypress_common.cpp.

                                                                            {
    // todo: replace this with an array :)
    switch (hwChannel) {
    case EFI_ADC_0:
        return Gpio::B0;
    case EFI_ADC_1:
        return Gpio::B1;
    case EFI_ADC_2:
        return Gpio::B2;
    case EFI_ADC_3:
        return Gpio::B3;
    case EFI_ADC_4:
        return Gpio::B4;
    case EFI_ADC_5:
        return Gpio::B5;
    case EFI_ADC_6:
        return Gpio::Invalid;
    case EFI_ADC_7:
        return Gpio::Invalid;
    case EFI_ADC_8:
        return Gpio::B8;
    case EFI_ADC_9:
        return Gpio::B9;
    case EFI_ADC_10:
        return Gpio::Invalid;
    case EFI_ADC_11:
        return Gpio::Invalid;
    case EFI_ADC_12:
        return Gpio::B12;
    case EFI_ADC_13:
        return Gpio::B13;
    case EFI_ADC_14:
        return Gpio::B14;
    case EFI_ADC_15:
        return Gpio::B15;
    case EFI_ADC_16:
        return Gpio::Invalid;
    case EFI_ADC_17:
        return Gpio::Invalid;
    case EFI_ADC_18:
        return Gpio::Invalid;
    case EFI_ADC_19:
        return Gpio::Invalid;
    case EFI_ADC_20:
        return Gpio::Invalid;
    case EFI_ADC_21:
        return Gpio::Invalid;
    case EFI_ADC_22:
        return Gpio::Invalid;
    case EFI_ADC_23:
        return Gpio::Invalid;
    case EFI_ADC_24:
        return Gpio::C10;
    case EFI_ADC_25:
        return Gpio::C9;
    case EFI_ADC_26:
        return Gpio::C8;
    case EFI_ADC_27:
        return Gpio::C7;
    case EFI_ADC_28:
        return Gpio::C5;
    case EFI_ADC_29:
        return Gpio::C4;
    case EFI_ADC_30:
        return Gpio::C3;
    case EFI_ADC_31:
        return Gpio::C2;
    default:
        firmwareError(ObdCode::CUSTOM_ERR_ADC_UNKNOWN_CHANNEL, "Unknown hw channel %d [%s]", hwChannel, msg);
        return Gpio::Invalid;
    }
}

Referenced by deInitIfValid(), getAdcChannelPin(), getAdcChannelPort(), and initIfValid().

Here is the call graph for this function:

Here is the caller graph for this function:

getAdcChannelPin()

int getAdcChannelPin

(

adc_channel_e

hwChannel

)

Definition at line 178 of file cypress_common.cpp.

                                              {
    return getHwPin("get_pin", getAdcChannelBrainPin("get_pin", hwChannel));
}

Referenced by adcPrintChannelReport(), and getPinNameByAdcChannel().

Here is the call graph for this function:

Here is the caller graph for this function:

getAdcChannelPort()

ioportid_t getAdcChannelPort	(	const char *	msg,
		adc_channel_e	hwChannel
	)

Definition at line 173 of file cypress_common.cpp.

                                                                       {
    return getHwPort(msg, getAdcChannelBrainPin(msg, hwChannel));
}

Referenced by adcPrintChannelReport(), and getPinNameByAdcChannel().

Here is the call graph for this function:

Here is the caller graph for this function:

getAdcInternalChannel()

int getAdcInternalChannel	(	ADC_TypeDef *	adc,
		adc_channel_e	hwChannel
	)

Definition at line 159 of file cypress_common.cpp.

                                                                     {
    (void)adc;
 
    return (hwChannel - EFI_ADC_0);
}

getHwChannelForAdcInput()

adc_channel_e getHwChannelForAdcInput	(	ADC_TypeDef *	adc,
		size_t	hwIndex
	)

Definition at line 165 of file cypress_common.cpp.

{
    (void)adc;
 
    return (EFI_ADC_0 + hwIndex);
}

getIcuParams()

bool getIcuParams	(	brain_pin_e	hwPin,
		iomode_t *	af_ptr,
		ICUDriver **	icu_ptr,
		icuchannel_t *	channel_ptr,
		uint32_t *	clock_ptr
	)

ChibiOS limitation is that only channels #1 and #2 could be used for input capture Could this be unified with getConfigForPin() method?

Definition at line 122 of file stm32_icu.cpp.

                                                                                                                             {
    switch (hwPin) {
        case Gpio::A0:
            RETURN_ICU5(ICU_CHANNEL_1);
            return false;
        case Gpio::A1:
            RETURN_ICU2(ICU_CHANNEL_2);
            RETURN_ICU5(ICU_CHANNEL_2);
            return false;
        case Gpio::A2:
            RETURN_ICU9(ICU_CHANNEL_1);
            return false;
        case Gpio::A3:
            RETURN_ICU9(ICU_CHANNEL_2);
            return false;
        case Gpio::A5:
            RETURN_ICU2(ICU_CHANNEL_1);
            return false;
        case Gpio::A6:
            RETURN_ICU3(ICU_CHANNEL_1);
            RETURN_ICU13(ICU_CHANNEL_1);
            return false;
        case Gpio::A7:
            RETURN_ICU3(ICU_CHANNEL_2);
            RETURN_ICU14(ICU_CHANNEL_1);
            return false;
        case Gpio::A8:
            RETURN_ICU1(ICU_CHANNEL_1);
            return false;
        case Gpio::A9:
            RETURN_ICU1(ICU_CHANNEL_2);
            return false;
        case Gpio::A15:
            RETURN_ICU2(ICU_CHANNEL_1);
            return false;
        case Gpio::B3:
            RETURN_ICU2(ICU_CHANNEL_2);
            return false;
        case Gpio::B4:
            RETURN_ICU3(ICU_CHANNEL_1);
            return false;
        case Gpio::B5:
            RETURN_ICU3(ICU_CHANNEL_2);
            return false;
        case Gpio::B6:
            RETURN_ICU4(ICU_CHANNEL_1);
            return false;
        case Gpio::B7:
            RETURN_ICU4(ICU_CHANNEL_2);
            return false;
        case Gpio::B8:
            RETURN_ICU10(ICU_CHANNEL_1);
            return false;
        case Gpio::B9:
            RETURN_ICU11(ICU_CHANNEL_1);
            return false;
        case Gpio::B14:
            RETURN_ICU12(ICU_CHANNEL_1);
            return false;
        case Gpio::B15:
            RETURN_ICU12(ICU_CHANNEL_2);
            return false;
        case Gpio::C6:
            RETURN_ICU3(ICU_CHANNEL_1);
            RETURN_ICU8(ICU_CHANNEL_1);
            return false;
        case Gpio::C7:
            RETURN_ICU3(ICU_CHANNEL_2);
            RETURN_ICU8(ICU_CHANNEL_2);
            return false;
        case Gpio::D12:
            RETURN_ICU4(ICU_CHANNEL_1);
            return false;
        case Gpio::D13:
            RETURN_ICU4(ICU_CHANNEL_2);
            return false;
        case Gpio::E5:
            RETURN_ICU9(ICU_CHANNEL_1);
            return false;
        case Gpio::E6:
            RETURN_ICU9(ICU_CHANNEL_2);
            return false;
        case Gpio::E9:
            RETURN_ICU1(ICU_CHANNEL_1);
            return false;
        case Gpio::E11:
            RETURN_ICU1(ICU_CHANNEL_2);
            return false;
        case Gpio::E14:
            RETURN_ICU1(ICU_CHANNEL_4);
            return false;
        case Gpio::F6:
            RETURN_ICU10(ICU_CHANNEL_1);
            return false;
        case Gpio::F7:
            RETURN_ICU11(ICU_CHANNEL_1);
            return false;
        case Gpio::F8:
            RETURN_ICU13(ICU_CHANNEL_1);
            return false;
        case Gpio::F9:
            RETURN_ICU14(ICU_CHANNEL_1);
            return false;
        case Gpio::H6:
            RETURN_ICU12(ICU_CHANNEL_1);
            return false;
        case Gpio::H9:
            RETURN_ICU12(ICU_CHANNEL_2);
            return false;
        case Gpio::H10:
            RETURN_ICU5(ICU_CHANNEL_1);
            return false;
        case Gpio::H11:
            RETURN_ICU5(ICU_CHANNEL_2);
            return false;
        case Gpio::I5:
            RETURN_ICU8(ICU_CHANNEL_1);
            return false;
        case Gpio::I6:
            RETURN_ICU8(ICU_CHANNEL_2);
            return false;
 
        default:
            return false;
    }
 
    return false;
}

Referenced by startSent(), and stopSent().

Here is the caller graph for this function:

getMCUResetCause() [1/2]

Reset_Cause_t getMCUResetCause

(

)

Definition at line 189 of file at32_common.cpp.

                                 {
    return Reset_Cause_Unknown;
}

Referenced by checkIfResetLoop(), errorHandlerInit(), and errorHandlerWriteReportFile().

Here is the caller graph for this function:

getMCUResetCause() [2/2]

const char * getMCUResetCause

(

Reset_Cause_t

cause

)

Definition at line 193 of file at32_common.cpp.

                                            {
    return "Unknown";
}

getMcuTemperature()

float getMcuTemperature

(

)

Definition at line 264 of file mpu_util.cpp.

                          {
    // TODO: implement me!
    return 0;
}

Referenced by adcOnchipSlowUpdate().

Here is the caller graph for this function:

getMcuVrefVoltage()

float getMcuVrefVoltage

(

)

Definition at line 269 of file mpu_util.cpp.

                          {
    // TODO: implement me!
    return engineConfiguration->adcVcc;
}

Referenced by adcOnchipSlowUpdate().

Here is the caller graph for this function:

HardFaultVector()

void HardFaultVector

(

void

)

Definition at line 62 of file mpu_util.cpp.

                           {
    while (TRUE) {
    }
}

initSpiCs()

void initSpiCs	(	SPIConfig *	spiConfig,
		brain_pin_e	csPin
	)

Definition at line 241 of file at32_spi.cpp.

                                                        {
    /* TODO: why this is here? */
#if !defined(HAL_LLD_SELECT_SPI_V2)
    spiConfig->end_cb = nullptr;
#else
    spiConfig->data_cb = nullptr;
    spiConfig->error_cb = nullptr;
#endif
 
    initSpiCsNoOccupy(spiConfig, csPin);
    efiSetPadMode("chip select", csPin, PAL_STM32_MODE_OUTPUT);
}

Referenced by initPotentiometer().

Here is the call graph for this function:

Here is the caller graph for this function:

initSpiCsNoOccupy()

void initSpiCsNoOccupy	(	SPIConfig *	spiConfig,
		brain_pin_e	csPin
	)

Definition at line 234 of file at32_spi.cpp.

                                                                {
    ioportid_t port = getHwPort("spi", csPin);
    ioportmask_t pin = getHwPin("spi", csPin);
    spiConfig->ssport = port;
    spiConfig->sspad = pin;
}

Referenced by initSpiCs().

Here is the call graph for this function:

Here is the caller graph for this function:

initSpiModule()

void initSpiModule	(	SPIDriver *	driver,
		brain_pin_e	sck,
		brain_pin_e	miso,
		brain_pin_e	mosi,
		int	sckMode,
		int	mosiMode,
		int	misoMode
	)

See https://github.com/rusefi/rusefi/pull/664/

Info on the silicon defect can be found in this document, section 2.5.2: https://www.st.com/content/ccc/resource/technical/document/errata_sheet/0a/98/58/84/86/b6/47/a2/DM00037591.pdf/files/DM00037591.pdf/jcr:content/translations/en.DM00037591.pdf

See https://github.com/rusefi/rusefi/pull/664/

Info on the silicon defect can be found in this document, section 2.5.2: https://www.st.com/content/ccc/resource/technical/document/errata_sheet/0a/98/58/84/86/b6/47/a2/DM00037591.pdf/files/DM00037591.pdf/jcr:content/translations/en.DM00037591.pdf

See https://github.com/rusefi/rusefi/pull/664/

Info on the silicon defect can be found in this document, section 2.5.2: https://www.st.com/content/ccc/resource/technical/document/errata_sheet/0a/98/58/84/86/b6/47/a2/DM00037591.pdf/files/DM00037591.pdf/jcr:content/translations/en.DM00037591.pdf

Definition at line 206 of file at32_spi.cpp.

                      {
 
    int sckAf = getSpiSckAf(driver, sck);
    int mosiAf = getSpiMosiAf(driver, mosi);
    int misoAf = getSpiMisoAf(driver, miso);
 
    if ((sckAf < 0) || (mosiAf < 0) || (misoAf < 0)) {
        criticalError("Incorrect SPI pin configuration");
    }
 
    efiSetPadMode("SPI CLK ", sck,
        PAL_MODE_ALTERNATE(sckAf) | sckMode | PAL_STM32_OSPEED_HIGHEST);
 
    efiSetPadMode("SPI MOSI", mosi,
        PAL_MODE_ALTERNATE(mosiAf) | mosiMode | PAL_STM32_OSPEED_HIGHEST);
 
    // Activate the internal pullup on MISO: SD cards indicate "busy" by holding MOSI low,
    // so in case there is no SD card installed, the line could float low and indicate that
    // the (non existent) card is busy.  We pull the line high to indicate "not busy" in case
    // of a missing card.
    efiSetPadMode("SPI MISO ", miso,
        PAL_MODE_ALTERNATE(misoAf) | misoMode | PAL_STM32_OSPEED_HIGHEST | PAL_STM32_PUPDR_PULLUP);
}

Referenced by turnOnSpi().

Here is the call graph for this function:

Here is the caller graph for this function:

isStm32F42x()

bool isStm32F42x

(

)

Definition at line 156 of file at32_common.cpp.

                       {
    return false;
}

Referenced by luaHeapInit(), and sayHello().

Here is the caller graph for this function:

isValidCanRxPin()

bool isValidCanRxPin

(

brain_pin_e

pin

)

Definition at line 89 of file at32_can.cpp.

                                      {
   return isValidCan1RxPin(pin) || isValidCan2RxPin(pin);
}

Referenced by startCanPins().

Here is the call graph for this function:

Here is the caller graph for this function:

isValidCanTxPin()

bool isValidCanTxPin

(

brain_pin_e

pin

)

Definition at line 85 of file at32_can.cpp.

                                      {
   return isValidCan1TxPin(pin) || isValidCan2TxPin(pin);
}

Referenced by startCanPins().

Here is the call graph for this function:

Here is the caller graph for this function:

isValidSerialRxPin()

bool isValidSerialRxPin

(

brain_pin_e

pin

)

Definition at line 25 of file stm32_serial.cpp.

                                         {
   return isValidUART6RxPin(pin);
}

Here is the call graph for this function:

isValidSerialTxPin()

bool isValidSerialTxPin

(

brain_pin_e

pin

)

Definition at line 21 of file stm32_serial.cpp.

                                         {
   return isValidUART6TxPin(pin);
}

Here is the call graph for this function:

jump_to_bootloader()

void jump_to_bootloader

(

)

Definition at line 106 of file at32_common.cpp.

                          {
    // leave DFU breadcrumb which assembly startup code would check, see [rusefi][DFU] section in assembly code
 
    *((unsigned long *)0x2001FFF0) = 0xDEADBEEF; // End of RAM
 
    reset_and_jump();
}

Referenced by executeTSCommand(), and runRusEfi().

Here is the call graph for this function:

Here is the caller graph for this function:

jump_to_openblt()

void jump_to_openblt

(

)

Definition at line 115 of file at32_common.cpp.

                       {
#if EFI_USE_OPENBLT
    /* safe to call on already inited shares area */
    SharedParamsInit();
    /* Store sing to stay in OpenBLT */
    SharedParamsWriteByIndex(0, 0x01);
 
    reset_and_jump();
#endif
}

Referenced by executeTSCommand(), processCanRxMessage(), and runRusEfi().

Here is the call graph for this function:

Here is the caller graph for this function:

mcuCanFlashWhileRunning()

bool mcuCanFlashWhileRunning

(

)

Definition at line 10 of file mpu_util.cpp.

                               {
    /* TODO: check for actual flash configuration? */
    /* currently we support only AT32F43X with dual-bank flash, so allow flashing to second bank */
    /* TODO: Seems AT32 is still freezes even write is happen to second bank, while executing code from first */
    return true;
}

Referenced by storageAllowWriteID().

Here is the call graph for this function:

Here is the caller graph for this function:

portInitAdc()

void portInitAdc

(

)

Definition at line 256 of file mpu_util.cpp.

                   {
    // Init slow ADC
    adcStart(&ADCD1, NULL);
 
    // Init fast ADC (MAP sensor)
    adcStart(&ADCD2, NULL);
}

Referenced by initAdcInputs().

Here is the call graph for this function:

Here is the caller graph for this function:

readSlowAnalogInputs()

bool readSlowAnalogInputs

(

adcsample_t *

convertedSamples

)

Definition at line 274 of file mpu_util.cpp.

                                                         {
    // TODO: implement me!
    return true;
}

Referenced by adcOnchipSlowUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

spiCalcClockDiv()

int spiCalcClockDiv	(	SPIDriver *	spip,
		SPIConfig *	spiConfig,
		unsigned int	clk
	)

Definition at line 260 of file at32_spi.cpp.

{
    // TODO: implement
    return -1;
}

Referenced by initializeMmcBlockDevice().

Here is the caller graph for this function:

spiGetBaseClock()

int spiGetBaseClock

(

SPIDriver *

spip

)

Definition at line 254 of file at32_spi.cpp.

{
    // TODO: implement
    return 0;
}

Referenced by sdStatistics().

Here is the caller graph for this function:

turnOnSpi()

void turnOnSpi

(

spi_device_e

device

)

Definition at line 151 of file at32_spi.cpp.

                                    {
    if (isSpiInitialized[device])
        return; // already initialized
    isSpiInitialized[device] = true;
    if (device == SPI_DEVICE_1) {
// todo: introduce a nice structure with all fields for same SPI
#if STM32_SPI_USE_SPI1
//      scheduleMsg(&logging, "Turning on SPI1 pins");
        initSpiModule(&SPID1, getSckPin(device),
                getMisoPin(device),
                getMosiPin(device),
                engineConfiguration->spi1SckMode,
                engineConfiguration->spi1MosiMode,
                engineConfiguration->spi1MisoMode);
#else
        criticalError("SPI1 not available in this binary");
#endif /* STM32_SPI_USE_SPI1 */
    }
    if (device == SPI_DEVICE_2) {
#if STM32_SPI_USE_SPI2
        //scheduleMsg(&logging, "Turning on SPI2 pins");
        initSpiModule(&SPID2, getSckPin(device),
                getMisoPin(device),
                getMosiPin(device),
                engineConfiguration->spi2SckMode,
                engineConfiguration->spi2MosiMode,
                engineConfiguration->spi2MisoMode);
#else
        criticalError("SPI2 not available in this binary");
#endif /* STM32_SPI_USE_SPI2 */
    }
    if (device == SPI_DEVICE_3) {
#if STM32_SPI_USE_SPI3
        //scheduleMsg(&logging, "Turning on SPI3 pins");
        initSpiModule(&SPID3, getSckPin(device),
                getMisoPin(device),
                getMosiPin(device),
                engineConfiguration->spi3SckMode,
                engineConfiguration->spi3MosiMode,
                engineConfiguration->spi3MisoMode);
#else
        criticalError("SPI3 not available in this binary");
#endif /* STM32_SPI_USE_SPI3 */
    }
    if (device == SPI_DEVICE_4) {
#if STM32_SPI_USE_SPI4
        //scheduleMsg(&logging, "Turning on SPI4 pins");
        /* there are no configuration fields for SPI4 in engineConfiguration, rely on board init code
         * it should set proper functions for SPI4 pins */
#else
        criticalError("SPI4 not available in this binary");
#endif /* STM32_SPI_USE_SPI4 */
    }
}

Here is the call graph for this function:

UsageFaultVector()

void UsageFaultVector

(

void

)

Definition at line 50 of file mpu_util.cpp.

                            {
    chDbgPanic3("UsageFaultVector", __FILE__, __LINE__);
    while (TRUE)
        ;
}

Here is the call graph for this function:

Variable Documentation

mmc_hs_spicfg

SPIConfig mmc_hs_spicfg

extern

Definition at line 273 of file at32_spi.cpp.

                          {
    .circular = false,
#if !defined(HAL_LLD_SELECT_SPI_V2)
    .end_cb = NULL,
#else
        .slave = false,
        .data_cb = NULL,
        .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cr1 = SPI_BaudRatePrescaler_2,
    .cr2 = 0
};

Referenced by initializeMmcBlockDevice(), and sdStatistics().

mmc_ls_spicfg

SPIConfig mmc_ls_spicfg

extern

Definition at line 288 of file at32_spi.cpp.

                          {
    .circular = false,
#if !defined(HAL_LLD_SELECT_SPI_V2)
    .end_cb = NULL,
#else
        .slave = false,
        .data_cb = NULL,
        .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cr1 = SPI_BaudRatePrescaler_8,
    .cr2 = 0
};

Referenced by initializeMmcBlockDevice(), and sdStatistics().

Go to the source code of this file.