Support for ADC oversampling with stm32h7

[nguyen-v]

Currently adc oversampling seems to only be supported with f0 and g0 families. It would be nice to extend it to the h7 family. The tricky thing is, for the ADC3, which is present on some h7, configuration is slightly different. Here is an untested draft, as I don't have access to an h7 with 3 ADCs

%% if target.family in ["h7"]
enum class OversampleScope : uint32_t
{
    Regular  = ADC_CFGR2_ROVSE,
    Injected = ADC_CFGR2_JOVSE,
    Both     = ADC_CFGR2_ROVSE | ADC_CFGR2_JOVSE,
};

enum class OversampleRatio : uint16_t
{
    x1    = 1,
    x2    = 2,
    x4    = 4,
    x8    = 8,
    x16   = 16,
    x32   = 32,
    x64   = 64,
    x128  = 128,
    x256  = 256,
    x512  = 512,
    x1024 = 1024,
};

enum class OversampleShift : uint8_t
{
    Div1 = 0, Div2 = 1, Div4 = 2, Div8 = 3,
    Div16 = 4, Div32 = 5, Div64 = 6, Div128 = 7, Div256 = 8,
};

static inline void
enableOversampling(OversampleRatio ratio,
                   OversampleShift shift = OversampleShift::Div1,
                   OversampleScope scope = OversampleScope::Regular);

static inline void
disableOversampling(OversampleScope scope = OversampleScope::Both);
%% endif

%% if target.family in ["h7"]

void
modm::platform::Adc{{ id }}::enableOversampling(OversampleRatio ratio,
                                                OversampleShift shift,
                                                OversampleScope scope)
{
	ADC_TypeDef* adc = ADC{{ id }};
	const uint32_t n = static_cast<uint32_t>(ratio);

	// x1 == disable oversampling (works for ADC1/2 and ADC3)
	if (n == 1u) {
		disableOversampling(scope);
		return;
	}

	uint32_t cfg2 = adc->CFGR2;

	// OVSS is a shift count (0..15)
	cfg2 = (cfg2 & ~ADC_CFGR2_OVSS)
	     | (static_cast<uint32_t>(shift) << ADC_CFGR2_OVSS_Pos);

%% if id == 3
	// ADC3: OVSR is 3-bit, supports only 2..256 (powers of two)
	uint32_t code;
	switch (n)
	{
		case 2:   code = 0; break;
		case 4:   code = 1; break;
		case 8:   code = 2; break;
		case 16:  code = 3; break;
		case 32:  code = 4; break;
		case 64:  code = 5; break;
		case 128: code = 6; break;
		case 256: code = 7; break;
		default:
			// Not representable on ADC3 (512/1024/non-powers-of-two)
			return;
	}

	cfg2 = (cfg2 & ~ADC3_CFGR2_OVSR) | (code << ADC3_CFGR2_OVSR_Pos);

%% else
	// ADC1/ADC2: wide OVSR, (N-1) encoding (up to 1024)
	if (n > 1024u) return;
	cfg2 = (cfg2 & ~ADC_CFGR2_OVSR) | ((n - 1u) << ADC_CFGR2_OVSR_Pos);
%% endif

	// Enable oversampling for requested scope(s)
	cfg2 |= static_cast<uint32_t>(scope);

	adc->CFGR2 = cfg2;
}

void
modm::platform::Adc{{ id }}::disableOversampling(OversampleScope scope)
{
	ADC{{ id }}->CFGR2 &= ~static_cast<uint32_t>(scope);
}

%% endif

[nguyen-v]

Actually I'm a bit confused, it seems like the template used is modm/src/modm/platform/adc/stm32f3/adc_impl.hpp.in which doesn't contain any function related to oversampling. What are the other adc_impl.hpp.in files in the stm32 and stm32f0 folders? Are these legacy?

[salkinium]

What are the other adc_impl.hpp.in files in the stm32 and stm32f0 folders? Are these legacy?

No, the ADC peripherals differ in functionality and register layout between different STM32 families.
The correct modm:platform:adc module is chosen by device.has_driver("adc:stm32-{family}") in the prepare step of lbuild.

The stm32f3 implementation seems to have been the most similar one to the STM32H7, so that's why whoever implemented this chose to reuse this driver. So you'd have to adapt the stm32f3 driver for the h7.