gpiod | native Go library for accessing GPIO lines

WinForms is only designed to run on Windows. It may work with Mono, but you would probably want to compile it on a Windows machine. It seems that Mono is, as of now, supporting up to .NET Framework 4.7 — so this is probably where the message comes from.

If you don't want to compile on Windows, try targeting 4.7 or use dotnet core and write a command line app to test your backend requirements.

Your first line for the USART3 initialization is wrong :-)

RCC->APB2ENR |= 1; // enable clock for AF

must be (without a clock the USART doesn't work)

RCC->APB1ENR |= (1<<18); // enable clock for USART

And as an additional hint, do not use all these magic numbers for the bits. This is much more readable (and the needed defines are already done in the CMSIS:

RCC->APB1ENR |= RCC_APB1ENR_USART3EN; // enable clock for USART

I would never use HAL library to set up the timers. It makes no sense for me. In the example below I will omit clock (in my case 168MHz) & GPIO settings. As you did not state what model of STM32F4 you use, this code was tested using STM32F446RET uC. Other STM32F4 have identical timers.

1. Setting the timer:

You have two mistakes:

First, you are reading the data register in the wait loop. You should have an empty loop that does nothing repeatedly until RXNE becomes 1, then read the data.

Second you don't do anything to trigger the clock. In master mode the clock starts when you write data for transmission. After driving the chip-select low, write something to DR:

It looks like the problem was introduced by the patch: regulator: stpmic1: Usb boost over-current protection workaround.

• The "boost" interrupt handler stpmic1_boost_irq_handler calls regulator_lock(usb_data->boost_rdev);
• The "boost" interrupt handler (stpmic1_boost_irq_handler) is set up by the stpmic1_boost_register function, but usb_data->boost_rdev is still null at this time.
• usb_data->boost_rdev is set to the return value of the stpmic1_boost_register function by thestpmic1_regulator_probe function.
• If the "boost" interrupt handler stpmic1_boost_irq_handler gets called before usb_data->boost_rdev has been set by the stpmic1_regulator_probe function, then the crash occurs.

A workaround would be to set usb_data->boost_rdev = rdev; in the stpmic1_boost_register function after it has set rdev but before it sets up the interrupt handler.

This should be reported to the author of the patch. See the "Signed-off-by:" line in the patch for the email address.

libgpiod has rather changed its API and the signature of that function. To fix this, you have to set (or unset, it depends on the installed libgpiod) CONFIG_UCFW_OLD_LIBGPIOD in SWUpdate configuration.

All the same, a GPIO number passed to gpio_to_desc() must have been properly acquired, and usage of the returned GPIO descriptor is only possible after the GPIO number has been released.

Shouldn't after be changed to before?

Probably neither of them. I guess that the sentence wants to express not to mix legacy gpio_XXX and modern gpiod_XXX APIs. E.g. to release gpio resources before working with gpiod ones.

You are right, that using the descriptor after gpio_free() is wrong.

In practice, the kernel violates the stated sentence itself because nearly every gpio operation uses gpio_to_desc(). E.g.

you forgot to set what AF mode to be used (there are possible 16 AF modes for every pin). At the moment AF registers are set to the 0 and it is wrong. You need to make it 7.

How can it be archived using the SPL library (depreciated and not supported anymore) I do not know.

Here is the register version

You have a number of subtle errors and then are checking the return of fread against an improper value. In your call to fread, there is no need to precede Buffer4Can with the & (address of) operator. Buffer4Can is an array, and will be converted to a pointer to the first element on access (see: C11 Standard - 6.3.2.1 Other Operands - Lvalues, arrays, and function designators(p3))

When you take the address of Buffer4Can you change the pointer type you provide to fread from uint8_t* (without the &) to uint8_t (*)[120000) (with the & the type becomes a pointer-to-array-of uint8_t[120000]). Now by happy coincidence being that Buffer4Can is an array, both the pointer-to uint8_t and *pointer-to-array-of uint8_t[120000] will both resolve to the same address (but are of vastly different types).

Since they resolve to the same address and since fread() takes a parameter of void* for its first parameter, the error goes silently unnoticed. (suffice it to say if you attempted fread (&Buffer4Can + 1, ... things would not work out well...)

The other issue pointed out by @Domenic is your comparison of the fread() return. The prototype for fread() is: