stm32_spi.cpp File Reference

Functions
static int	getSpiAf (SPIDriver *driver)
void	turnOnSpi (spi_device_e device)
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)
int	spiGetBaseClock (SPIDriver *spip)
int	spiCalcClockDiv (SPIDriver *, SPIConfig *, unsigned int)

Variables
bool	isSpiInitialized [SPI_TOTAL_COUNT+1] = { true, false, false, false, false, false, false }
SPIConfig	mmc_hs_spicfg
SPIConfig	mmc_ls_spicfg

Function Documentation

getSpiAf()

static int getSpiAf ( SPIDriver *  driver )

static

Definition at line 15 of file stm32_spi.cpp.

                                       {
#if STM32_SPI_USE_SPI1
    if (driver == &SPID1) {
        return EFI_SPI1_AF;
    }
#endif
#if STM32_SPI_USE_SPI2
    if (driver == &SPID2) {
        return EFI_SPI2_AF;
    }
#endif
#if STM32_SPI_USE_SPI3
    if (driver == &SPID3) {
        return EFI_SPI3_AF;
    }
#endif
#if STM32_SPI_USE_SPI4
    if (driver == &SPID4) {
        return EFI_SPI4_AF;
    }
#endif
#if STM32_SPI_USE_SPI5
    if (driver == &SPID5) {
        return EFI_SPI5_AF;
    }
#endif
#if STM32_SPI_USE_SPI6
    if (driver == &SPID6) {
        return EFI_SPI6_AF;
    }
#endif
    criticalError("SPI AF not available");
    return -1;
}

Referenced by initSpiModule().

Here is the caller graph for this function:

initSpiCs()

void initSpiCs	(	SPIConfig *	spiConfig,
		brain_pin_e	csPin
	)

Definition at line 160 of file stm32_spi.cpp.

                                                        {
    /* TODO: why this is here? */
#ifdef _CHIBIOS_RT_CONF_VER_6_1_
    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);
}

Here is the call graph for this function:

initSpiCsNoOccupy()

void initSpiCsNoOccupy	(	SPIConfig *	spiConfig,
		brain_pin_e	csPin
	)

Definition at line 153 of file stm32_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

Definition at line 132 of file stm32_spi.cpp.

                                                 {
 
    /**
     * 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
     */
    efiSetPadMode("SPI CLK ", sck,  PAL_MODE_ALTERNATE(getSpiAf(driver)) | sckMode | PAL_STM32_OSPEED_HIGHEST);
 
    efiSetPadMode("SPI MOSI", mosi, PAL_MODE_ALTERNATE(getSpiAf(driver)) | 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(getSpiAf(driver)) | 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:

spiCalcClockDiv()

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

Definition at line 217 of file stm32_spi.cpp.

{
    // TODO: implement
    return -1;
}

spiGetBaseClock()

int spiGetBaseClock

(

SPIDriver *

spip

)

Definition at line 173 of file stm32_spi.cpp.

{
#if STM32_SPI_USE_SPI1
    if (spip == &SPID1) {
        // APB2
        return STM32_PCLK2;
    }
#endif
#if STM32_SPI_USE_SPI2
    if (spip == &SPID2) {
        // APB1
        return STM32_PCLK1;
    }
#endif
#if STM32_SPI_USE_SPI3
    if (spip == &SPID3) {
        // APB1
        return STM32_PCLK1;
    }
#endif
#if STM32_SPI_USE_SPI4
    if (spip == &SPID4) {
        // APB2
        return STM32_PCLK2;
    }
#endif
#if STM32_SPI_USE_SPI5
    if (spip == &SPID5) {
        // APB2
        return STM32_PCLK2;
    }
#endif
#if STM32_SPI_USE_SPI6
    if (spip == &SPID6) {
        // APB2
        return STM32_PCLK2;
    }
#endif
 
    return 0;
}

turnOnSpi()

void turnOnSpi

(

spi_device_e

device

)

Definition at line 50 of file stm32_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
        initSpiModule(&SPID4, getSckPin(device),
                getMisoPin(device),
                getMosiPin(device),
                engineConfiguration->spi4SckMode,
                engineConfiguration->spi4MosiMode,
                engineConfiguration->spi4MisoMode);
#else
        criticalError("SPI4 not available in this binary");
#endif /* STM32_SPI_USE_SPI4 */
    }
    if (device == SPI_DEVICE_5) {
#if STM32_SPI_USE_SPI5
        initSpiModule(&SPID5, getSckPin(device),
                getMisoPin(device),
                getMosiPin(device),
                engineConfiguration->spi5SckMode,
                engineConfiguration->spi5MosiMode,
                engineConfiguration->spi5MisoMode);
#else
        criticalError("SPI5 not available in this binary");
#endif /* STM32_SPI_USE_SPI5 */
    }
    if (device == SPI_DEVICE_6) {
#if STM32_SPI_USE_SPI6
        initSpiModule(&SPID6, getSckPin(device),
                getMisoPin(device),
                getMosiPin(device),
                engineConfiguration->spi6SckMode,
                engineConfiguration->spi6MosiMode,
                engineConfiguration->spi6MisoMode);
#else
        criticalError("SPI6 not available in this binary");
#endif /* STM32_SPI_USE_SPI6 */
    }
}

Referenced by initSpiModules().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

isSpiInitialized

bool isSpiInitialized[SPI_TOTAL_COUNT+1] = { true, false, false, false, false, false, false }

Definition at line 13 of file stm32_spi.cpp.

{ true, false, false, false, false, false, false };

Referenced by stopSpi(), and turnOnSpi().

mmc_hs_spicfg

SPIConfig mmc_hs_spicfg

Initial value:

= {
    .circular = false,
#ifdef _CHIBIOS_RT_CONF_VER_6_1_
    .end_cb = NULL,
#else
        .slave = false,
        .data_cb = NULL,
        .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cfg1 = 7 
        | 0 ,
    .cfg2 = 0
}

Definition at line 267 of file stm32_spi.cpp.

                          {
    .circular = false,
#ifdef _CHIBIOS_RT_CONF_VER_6_1_
    .end_cb = NULL,
#else
        .slave = false,
        .data_cb = NULL,
        .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cfg1 = 7 // 8 bits per byte
        | 0 /* MBR = 0, divider = 2 */,
    .cfg2 = 0
};

mmc_ls_spicfg

SPIConfig mmc_ls_spicfg

Initial value:

= {
    .circular = false,
#ifdef _CHIBIOS_RT_CONF_VER_6_1_
    .end_cb = NULL,
#else
        .slave = false,
        .data_cb = NULL,
        .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cfg1 = 7 
        | SPI_CFG1_MBR_0 ,
    .cfg2 = 0
}

Definition at line 284 of file stm32_spi.cpp.

                          {
    .circular = false,
#ifdef _CHIBIOS_RT_CONF_VER_6_1_
    .end_cb = NULL,
#else
        .slave = false,
        .data_cb = NULL,
        .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cfg1 = 7 // 8 bits per byte
        | SPI_CFG1_MBR_0 /* MBR = 001, divider = 4 */,
    .cfg2 = 0
};

Go to the source code of this file.