void stm32_boardinitialize(void) { /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) || defined(CONFIG_STM32_SPI3) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* Initialize USB is 1) USBDEV is selected, 2) the USB controller is not * disabled, and 3) the weak function stm32_usbdev_initialize() has been brought * into the build. */ #if defined(CONFIG_STM32_OTGFS) && defined(CONFIG_USBDEV) if (stm32_usbdev_initialize) { stm32_usbdev_initialize(); } #endif /* Configure on-board LEDs (unconditionally). */ stm32_ledinit(); }
void stm32_boardinitialize(void) { /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) || defined(CONFIG_STM32_SPI3) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* Initialize USB if the 1) USB device controller is in the configuration and 2) * disabled, and 3) the weak function stm32_usbinitialize() has been brought * into the build. Presumeably either CONFIG_USBDEV is also selected. */ #ifdef CONFIG_STM32_USB if (stm32_usbinitialize) { stm32_usbinitialize(); } #endif /* Configure on-board LEDs if LED support has been selected. */ #ifdef CONFIG_ARCH_LEDS up_ledinit(); #endif }
__END_DECLS /**************************************************************************** * Protected Functions ****************************************************************************/ /**************************************************************************** * Public Functions ****************************************************************************/ /************************************************************************************ * Name: stm32_boardinitialize * * Description: * All STM32 architectures must provide the following entry point. This entry point * is called early in the intitialization -- after all memory has been configured * and mapped but before any devices have been initialized. * ************************************************************************************/ __EXPORT void stm32_boardinitialize(void) { /* configure always-on ADC pins */ stm32_configgpio(GPIO_ADC1_IN10); stm32_configgpio(GPIO_ADC1_IN11); /* configure SPI interfaces */ stm32_spiinitialize(); /* configure LEDs (empty call to NuttX' ) */ board_autoled_initialize(); }
void stm32_boardinitialize(void) { /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* Initialize USB is 1) USBDEV is selected, 2) the USB controller is not * disabled, and 3) the weak function stm32_usbinitialize() has been brought * into the build. */ #if defined(CONFIG_USBDEV) && defined(CONFIG_STM32_USB) if (stm32_usbinitialize) { stm32_usbinitialize(); } #endif /* Configure on-board LEDs if LED support has been selected. */ #ifdef CONFIG_ARCH_LEDS up_ledinit(); #endif }
__END_DECLS /**************************************************************************** * Protected Functions ****************************************************************************/ /**************************************************************************** * Public Functions ****************************************************************************/ /************************************************************************************ * Name: stm32_boardinitialize * * Description: * All STM32 architectures must provide the following entry point. This entry point * is called early in the intitialization -- after all memory has been configured * and mapped but before any devices have been initialized. * ************************************************************************************/ __EXPORT void stm32_boardinitialize(void) { /* configure LEDs */ board_autoled_initialize(); /* turn sensors on */ stm32_configgpio(GPIO_VDD_5V_SENSORS_EN); /* configure SPI interfaces */ stm32_spiinitialize(); }
__EXPORT void board_spi_reset(int ms) { /* disable SPI bus 1 DRDY */ stm32_configgpio(GPIO_DRDY_OFF_PORTD_PIN15); stm32_configgpio(GPIO_DRDY_OFF_PORTC_PIN14); stm32_configgpio(GPIO_DRDY_OFF_PORTE_PIN12); stm32_gpiowrite(GPIO_DRDY_OFF_PORTD_PIN15, 0); stm32_gpiowrite(GPIO_DRDY_OFF_PORTC_PIN14, 0); stm32_gpiowrite(GPIO_DRDY_OFF_PORTE_PIN12, 0); /* disable SPI bus 1 CS */ stm32_configgpio(GPIO_SPI1_CS_OFF_PORTC_PIN2); stm32_configgpio(GPIO_SPI1_CS_OFF_PORTC_PIN15); stm32_configgpio(GPIO_SPI1_CS_OFF_PORTE_PIN15); stm32_gpiowrite(GPIO_SPI1_CS_OFF_PORTC_PIN2, 0); stm32_gpiowrite(GPIO_SPI1_CS_OFF_PORTC_PIN15, 0); stm32_gpiowrite(GPIO_SPI1_CS_OFF_PORTE_PIN15, 0); /* disable SPI bus 1*/ stm32_configgpio(GPIO_SPI1_SCK_OFF); stm32_configgpio(GPIO_SPI1_MISO_OFF); stm32_configgpio(GPIO_SPI1_MOSI_OFF); stm32_gpiowrite(GPIO_SPI1_SCK_OFF, 0); stm32_gpiowrite(GPIO_SPI1_MISO_OFF, 0); stm32_gpiowrite(GPIO_SPI1_MOSI_OFF, 0); /* N.B we do not have control over the SPI 2 buss powered devices * so the the ms5611 is not resetable. */ /* set the sensor rail off (default) */ stm32_configgpio(GPIO_VDD_3V3_SENSORS_EN); /* wait for the sensor rail to reach GND */ usleep(ms * 1000); warnx("reset done, %d ms", ms); /* re-enable power */ /* switch the sensor rail back on */ stm32_gpiowrite(GPIO_VDD_3V3_SENSORS_EN, 1); /* wait a bit before starting SPI, different times didn't influence results */ usleep(100); stm32_spiinitialize(PX4_SPI_BUS_SENSORS); stm32_configgpio(GPIO_SPI1_SCK); stm32_configgpio(GPIO_SPI1_MISO); stm32_configgpio(GPIO_SPI1_MOSI); }
__END_DECLS /**************************************************************************** * Protected Functions ****************************************************************************/ /**************************************************************************** * Public Functions ****************************************************************************/ /************************************************************************************ * Name: stm32_boardinitialize * * Description: * All STM32 architectures must provide the following entry point. This entry point * is called early in the intitialization -- after all memory has been configured * and mapped but before any devices have been initialized. * ************************************************************************************/ __EXPORT void stm32_boardinitialize(void) { /* enable sys logs */ //syslog_enable(true); /* configure SPI interfaces */ stm32_spiinitialize(); }
__EXPORT void stm32_boardinitialize(void) { /* configure SPI interfaces */ stm32_spiinitialize(); /* configure LEDs */ up_ledinit(); }
void stm32_boardinitialize(void) { /* Configure SPI interfaces */ stm32_spiinitialize(); /* Configure LEDs */ board_led_initialize(); }
__END_DECLS /**************************************************************************** * Protected Functions ****************************************************************************/ /**************************************************************************** * Public Functions ****************************************************************************/ /************************************************************************************ * Name: stm32_boardinitialize * * Description: * All STM32 architectures must provide the following entry point. This entry point * is called early in the intitialization -- after all memory has been configured * and mapped but before any devices have been initialized. * ************************************************************************************/ __EXPORT void stm32_boardinitialize(void) { /* Hold power state */ board_pwr_init(0); /* TEMP ctrl Off (active high, init is clear) */ stm32_configgpio(GPIO_TEMP_CONT); /* Select 0 */ stm32_configgpio(GPIO_S0); stm32_configgpio(GPIO_S1); stm32_configgpio(GPIO_S2); /* Radio Off (active low, init is set) */ stm32_configgpio(GPIO_PCON_RADIO); /* configure always-on ADC pins */ stm32_configgpio(GPIO_ADC1_IN10); /* configure SPI interfaces */ stm32_spiinitialize(); /* configure LEDs (empty call to NuttX' ledinit) */ up_ledinit(); }
__EXPORT void stm32_boardinitialize(void) { stm32_configgpio(GPIO_FORCE_BOOTLOADER); _bootloader_force_pin_callback(0, NULL); /* configure SPI interfaces */ stm32_spiinitialize(); /* configure LEDs */ up_ledinit(); }
void stm32_boardinitialize(void) { /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) || defined(CONFIG_STM32_SPI3) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* Configure on-board LEDs (unconditionally). */ stm32_ledinit(); }
__EXPORT void stm32_boardinitialize(void) { /* configure LEDs */ board_autoled_initialize(); /* configure ADC pins */ //todo:Revisit! ADC3 etc stm32_configgpio(GPIO_ADC1_IN2); /* BATT_VOLTAGE_SENS */ stm32_configgpio(GPIO_ADC1_IN3); /* BATT_CURRENT_SENS */ stm32_configgpio(GPIO_ADC1_IN4); /* VDD_5V_SENS */ stm32_configgpio(GPIO_ADC1_IN11); /* RSSI analog in */ /* configure power supply control/sense pins */ stm32_configgpio(GPIO_VDD_3V3_PERIPH_EN); stm32_configgpio(GPIO_VDD_BRICK_VALID); stm32_configgpio(GPIO_SBUS_INV); stm32_configgpio(GPIO_8266_GPIO0); // stm32_configgpio(GPIO_SPEKTRUM_PWR_EN); stm32_configgpio(GPIO_8266_PD); stm32_configgpio(GPIO_8266_RST); stm32_configgpio(GPIO_BTN_SAFETY); #ifdef GPIO_RC_OUT stm32_configgpio(GPIO_RC_OUT); /* Serial RC output pin */ stm32_gpiowrite(GPIO_RC_OUT, 1); /* set it high to pull RC input up */ #endif /* configure the GPIO pins to outputs and keep them low */ stm32_configgpio(GPIO_GPIO0_OUTPUT); stm32_configgpio(GPIO_GPIO1_OUTPUT); stm32_configgpio(GPIO_GPIO2_OUTPUT); stm32_configgpio(GPIO_GPIO3_OUTPUT); stm32_configgpio(GPIO_GPIO4_OUTPUT); stm32_configgpio(GPIO_GPIO5_OUTPUT); /* configure SPI interfaces */ stm32_spiinitialize(); stm32_usbinitialize(); }
void stm32_boardinitialize(void) { /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) || defined(CONFIG_STM32_SPI3) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* Configure on-board LEDs if LED support has been selected. */ #ifdef CONFIG_ARCH_LEDS board_led_initialize(); #endif }
__EXPORT void stm32_boardinitialize(void) { /* configure ADC pins */ stm32_configgpio(GPIO_ADC1_IN10); /* used by battery sense */ stm32_configgpio(GPIO_ADC1_IN11); /* J1 breakout */ stm32_configgpio(GPIO_ADC1_IN12); /* J1 breakout */ stm32_configgpio(GPIO_ADC1_IN13); /* J1 breakout */ /* configure the power mux sense input */ stm32_configgpio(GPIO_POWER_MUX_SENSE); /* configure spektrum power controller gpio */ stm32_configgpio(GPIO_SPEKTRUM_PWR_EN); /* configure SPI interfaces */ stm32_spiinitialize(); /* configure LEDs */ board_autoled_initialize(); }
__EXPORT void stm32_boardinitialize(void) { /* configure LEDs */ board_autoled_initialize(); /* configure ADC pins */ px4_arch_configgpio(GPIO_ADC1_IN2); /* BATT_VOLTAGE_SENS */ px4_arch_configgpio(GPIO_ADC1_IN3); /* BATT_CURRENT_SENS */ px4_arch_configgpio(GPIO_ADC1_IN4); /* VDD_5V_SENS */ px4_arch_configgpio(GPIO_ADC1_IN13); /* FMU_AUX_ADC_1 */ px4_arch_configgpio(GPIO_ADC1_IN14); /* FMU_AUX_ADC_2 */ px4_arch_configgpio(GPIO_ADC1_IN15); /* PRESSURE_SENS */ /* configure power supply control/sense pins */ px4_arch_configgpio(GPIO_VDD_5V_PERIPH_EN); px4_arch_configgpio(GPIO_VDD_3V3_SENSORS_EN); px4_arch_configgpio(GPIO_VDD_BRICK_VALID); px4_arch_configgpio(GPIO_VDD_5V_PERIPH_OC); /* configure the GPIO pins to outputs and keep them low */ px4_arch_configgpio(GPIO_GPIO0_OUTPUT); px4_arch_configgpio(GPIO_GPIO1_OUTPUT); px4_arch_configgpio(GPIO_GPIO2_OUTPUT); px4_arch_configgpio(GPIO_GPIO3_OUTPUT); px4_arch_configgpio(GPIO_GPIO4_OUTPUT); px4_arch_configgpio(GPIO_GPIO5_OUTPUT); /* configure SPI interfaces */ stm32_spiinitialize(); /* configure USB interface */ stm32_usbinitialize(); }
void stm32_boardinitialize(void) { /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) || defined(CONFIG_STM32_SPI3) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* If the FSMC is enabled, then enable SRAM access */ #ifdef CONFIG_STM32_FSMC stm32_selectsram(); #endif /* Initialize USB if the 1) OTG FS controller is in the configuration and 2) * disabled, and 3) the weak function stm32_usbinitialize() has been brought * the weak function stm32_usbinitialize() has been brought into the build. * Presumeably either CONFIG_USBDEV or CONFIG_USBHOST is also selected. */ #ifdef CONFIG_STM32_OTGFS if (stm32_usbinitialize) { stm32_usbinitialize(); } #endif /* Configure on-board LEDs if LED support has been selected. */ #ifdef CONFIG_ARCH_LEDS stm32_autoled_initialize(); #endif }
__EXPORT void stm32_boardinitialize(void) { board_on_reset(-1); /* Reset PWM first thing */ /* configure LEDs */ board_autoled_initialize(); /* configure pins */ const uint32_t gpio[] = PX4_GPIO_INIT_LIST; board_gpio_init(gpio, arraySize(gpio)); /* configure SPI interfaces */ stm32_spiinitialize(); /* configure USB interfaces */ stm32_usbinitialize(); }
void stm32_boardinitialize(void) { /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) || defined(CONFIG_STM32_SPI3) ||\ defined(CONFIG_STM32_SPI4) || defined(CONFIG_STM32_SPI5) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* Initialize USB if the 1) OTG HS controller is in the configuration and 2) * disabled, and 3) the weak function stm32_usbinitialize() has been brought * into the build. Presumeably either CONFIG_USBDEV or CONFIG_USBHOST is also * selected. */ #ifdef CONFIG_STM32_OTGHS if (stm32_usbinitialize) { stm32_usbinitialize(); } #endif /* Configure on-board LEDs if LED support has been selected. */ #ifdef CONFIG_ARCH_LEDS board_led_initialize(); #endif #ifdef CONFIG_STM32_FSMC stm32_enablefsmc(); #endif }
__EXPORT void stm32_boardinitialize(void) { /* configure LEDs */ board_autoled_initialize(); /* configure ADC pins */ stm32_configgpio(GPIO_ADC1_IN2); /* BATT_VOLTAGE_SENS */ stm32_configgpio(GPIO_ADC1_IN3); /* BATT_CURRENT_SENS */ stm32_configgpio(GPIO_ADC1_IN4); /* VDD_5V_SENS */ stm32_configgpio(GPIO_ADC1_IN11); /* RSSI analog in */ /* configure power supply control/sense pins */ stm32_configgpio(GPIO_PERIPH_3V3_EN); stm32_configgpio(GPIO_VDD_BRICK_VALID); stm32_configgpio(GPIO_SBUS_INV); stm32_configgpio(GPIO_8266_GPIO0); stm32_configgpio(GPIO_SPEKTRUM_PWR_EN); stm32_configgpio(GPIO_8266_PD); stm32_configgpio(GPIO_8266_RST); stm32_configgpio(GPIO_BTN_SAFETY); /* configure the GPIO pins to outputs and keep them low */ stm32_configgpio(GPIO_GPIO0_OUTPUT); stm32_configgpio(GPIO_GPIO1_OUTPUT); stm32_configgpio(GPIO_GPIO2_OUTPUT); stm32_configgpio(GPIO_GPIO3_OUTPUT); stm32_configgpio(GPIO_GPIO4_OUTPUT); stm32_configgpio(GPIO_GPIO5_OUTPUT); /* configure SPI interfaces */ stm32_spiinitialize(); }
__END_DECLS /**************************************************************************** * Protected Functions ****************************************************************************/ #if defined(CONFIG_FAT_DMAMEMORY) /**************************************************************************** * Public Functions ****************************************************************************/ #else # define dma_alloc_init() #endif /************************************************************************************ * Name: stm32_boardinitialize * * Description: * All STM32 architectures must provide the following entry point. This entry point * is called early in the intitialization -- after all memory has been configured * and mapped but before any devices have been initialized. * ************************************************************************************/ __EXPORT void stm32_boardinitialize(void) { /* configure SPI interfaces */ stm32_spiinitialize(); }
__EXPORT int board_app_initialize(uintptr_t arg) { #if defined(CONFIG_HAVE_CXX) && defined(CONFIG_HAVE_CXXINITIALIZE) /* run C++ ctors before we go any further */ up_cxxinitialize(); # if defined(CONFIG_EXAMPLES_NSH_CXXINITIALIZE) # error CONFIG_EXAMPLES_NSH_CXXINITIALIZE Must not be defined! Use CONFIG_HAVE_CXX and CONFIG_HAVE_CXXINITIALIZE. # endif #else # error platform is dependent on c++ both CONFIG_HAVE_CXX and CONFIG_HAVE_CXXINITIALIZE must be defined. #endif #if defined(BOARD_HAS_SIMPLE_HW_VERSIONING) if (OK == determin_hw_version(&hw_version, & hw_revision)) { switch (hw_version) { default: case 0x8: break; case 0xE: hw_type[1]++; hw_type[2] = '0'; break; case 0xA: hw_type[2] = 'M'; break; } PX4_INFO("Ver 0x%1X : Rev %x %s", hw_version, hw_revision, hw_type); } #endif // BOARD_HAS_SIMPLE_HW_VERSIONING /* Bring up the Sensor power */ stm32_gpiowrite(GPIO_VDD_3V3_SENSORS_EN, 1); /* Ensure the power is on 1 ms before we drive the GPIO pins */ usleep(1000); /* Now it is ok to drive the pins high so configure SPI GPIO */ stm32_spiinitialize(); /* configure the high-resolution time/callout interface */ hrt_init(); param_init(); /* configure the DMA allocator */ if (board_dma_alloc_init() < 0) { message("DMA alloc FAILED"); } /* configure CPU load estimation */ #ifdef CONFIG_SCHED_INSTRUMENTATION cpuload_initialize_once(); #endif /* set up the serial DMA polling */ static struct hrt_call serial_dma_call; struct timespec ts; /* * Poll at 1ms intervals for received bytes that have not triggered * a DMA event. */ ts.tv_sec = 0; ts.tv_nsec = 1000000; hrt_call_every(&serial_dma_call, ts_to_abstime(&ts), ts_to_abstime(&ts), (hrt_callout)stm32_serial_dma_poll, NULL); #if defined(CONFIG_STM32_BBSRAM) if (hardfault_check_status) { /* NB. the use of the console requires the hrt running * to poll the DMA */ /* Using Battery Backed Up SRAM */ int filesizes[CONFIG_STM32_BBSRAM_FILES + 1] = BSRAM_FILE_SIZES; stm32_bbsraminitialize(BBSRAM_PATH, filesizes); #if defined(CONFIG_STM32_SAVE_CRASHDUMP) /* Panic Logging in Battery Backed Up Files */ /* * In an ideal world, if a fault happens in flight the * system save it to BBSRAM will then reboot. Upon * rebooting, the system will log the fault to disk, recover * the flight state and continue to fly. But if there is * a fault on the bench or in the air that prohibit the recovery * or committing the log to disk, the things are too broken to * fly. So the question is: * * Did we have a hard fault and not make it far enough * through the boot sequence to commit the fault data to * the SD card? */ /* Do we have an uncommitted hard fault in BBSRAM? * - this will be reset after a successful commit to SD */ int hadCrash = hardfault_check_status("boot"); if (hadCrash == OK) { message("[boot] There is a hard fault logged. Hold down the SPACE BAR," \ " while booting to halt the system!\n"); /* Yes. So add one to the boot count - this will be reset after a successful * commit to SD */ int reboots = hardfault_increment_reboot("boot", false); /* Also end the misery for a user that holds for a key down on the console */ int bytesWaiting; ioctl(fileno(stdin), FIONREAD, (unsigned long)((uintptr_t) &bytesWaiting)); if (reboots > 2 || bytesWaiting != 0) { /* Since we can not commit the fault dump to disk. Display it * to the console. */ hardfault_write("boot", fileno(stdout), HARDFAULT_DISPLAY_FORMAT, false); message("[boot] There were %d reboots with Hard fault that were not committed to disk - System halted %s\n", reboots, (bytesWaiting == 0 ? "" : " Due to Key Press\n")); /* For those of you with a debugger set a break point on up_assert and * then set dbgContinue = 1 and go. */ /* Clear any key press that got us here */ static volatile bool dbgContinue = false; int c = '>'; while (!dbgContinue) { switch (c) { case EOF: case '\n': case '\r': case ' ': continue; default: putchar(c); putchar('\n'); switch (c) { case 'D': case 'd': hardfault_write("boot", fileno(stdout), HARDFAULT_DISPLAY_FORMAT, false); break; case 'C': case 'c': hardfault_rearm("boot"); hardfault_increment_reboot("boot", true); break; case 'B': case 'b': dbgContinue = true; break; default: break; } // Inner Switch message("\nEnter B - Continue booting\n" \ "Enter C - Clear the fault log\n" \ "Enter D - Dump fault log\n\n?>"); fflush(stdout); if (!dbgContinue) { c = getchar(); } break; } // outer switch } // for } // inner if } // outer if } // hardfault_check_status #endif // CONFIG_STM32_SAVE_CRASHDUMP #endif // CONFIG_STM32_BBSRAM /* initial LED state */ drv_led_start(); led_off(LED_AMBER); /* Configure SPI-based devices */ spi1 = stm32_spibus_initialize(PX4_SPI_BUS_SENSORS); if (!spi1) { message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_SENSORS); board_autoled_on(LED_AMBER); return -ENODEV; } /* Default SPI1 to 1MHz and de-assert the known chip selects. */ SPI_SETFREQUENCY(spi1, 10000000); SPI_SETBITS(spi1, 8); SPI_SETMODE(spi1, SPIDEV_MODE3); up_udelay(20); /* Get the SPI port for the FRAM */ spi2 = stm32_spibus_initialize(PX4_SPI_BUS_RAMTRON); if (!spi2) { message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_RAMTRON); board_autoled_on(LED_AMBER); return -ENODEV; } /* Default SPI2 to 37.5 MHz (40 MHz rounded to nearest valid divider, F4 max) * and de-assert the known chip selects. */ // XXX start with 10.4 MHz in FRAM usage and go up to 37.5 once validated SPI_SETFREQUENCY(spi2, 12 * 1000 * 1000); SPI_SETBITS(spi2, 8); SPI_SETMODE(spi2, SPIDEV_MODE3); spi4 = stm32_spibus_initialize(PX4_SPI_BUS_EXT); if (!spi4) { message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_EXT); board_autoled_on(LED_AMBER); return -ENODEV; } /* Default SPI4 to 1MHz and de-assert the known chip selects. */ SPI_SETFREQUENCY(spi4, 10000000); SPI_SETBITS(spi4, 8); SPI_SETMODE(spi4, SPIDEV_MODE3); #ifdef CONFIG_MMCSD /* First, get an instance of the SDIO interface */ sdio = sdio_initialize(CONFIG_NSH_MMCSDSLOTNO); if (!sdio) { message("[boot] Failed to initialize SDIO slot %d\n", CONFIG_NSH_MMCSDSLOTNO); return -ENODEV; } /* Now bind the SDIO interface to the MMC/SD driver */ int ret = mmcsd_slotinitialize(CONFIG_NSH_MMCSDMINOR, sdio); if (ret != OK) { message("[boot] Failed to bind SDIO to the MMC/SD driver: %d\n", ret); return ret; } /* Then let's guess and say that there is a card in the slot. There is no card detect GPIO. */ sdio_mediachange(sdio, true); #endif return OK; }
__END_DECLS /**************************************************************************** * Protected Functions ****************************************************************************/ /**************************************************************************** * Public Functions ****************************************************************************/ /************************************************************************************ * Name: stm32_boardinitialize * * Description: * All STM32 architectures must provide the following entry point. This entry point * is called early in the intitialization -- after all memory has been configured * and mapped but before any devices have been initialized. * ************************************************************************************/ __EXPORT void stm32_boardinitialize(void) { /* configure LEDs */ board_autoled_initialize(); /* configure ADC pins */ px4_arch_configgpio(GPIO_ADC1_IN4); /* VDD_5V_SENS */ px4_arch_configgpio(GPIO_ADC1_IN10); /* BATT_CURRENT_SENS */ px4_arch_configgpio(GPIO_ADC1_IN12); /* BATT_VOLTAGE_SENS */ px4_arch_configgpio(GPIO_ADC1_IN11); /* RSSI analog in */ px4_arch_configgpio(GPIO_ADC1_IN13); /* FMU_AUX_ADC_1 */ px4_arch_configgpio(GPIO_ADC1_IN14); /* FMU_AUX_ADC_2 */ px4_arch_configgpio(GPIO_ADC1_IN15); /* PRESSURE_SENS */ /* configure power supply control/sense pins */ px4_arch_configgpio(GPIO_SBUS_INV); px4_arch_configgpio(GPIO_FRSKY_INV); /* configure the GPIO pins to outputs and keep them low */ px4_arch_configgpio(GPIO_GPIO0_OUTPUT); px4_arch_configgpio(GPIO_GPIO1_OUTPUT); px4_arch_configgpio(GPIO_GPIO2_OUTPUT); px4_arch_configgpio(GPIO_GPIO3_OUTPUT); px4_arch_configgpio(GPIO_GPIO4_OUTPUT); px4_arch_configgpio(GPIO_GPIO5_OUTPUT); px4_arch_configgpio(GPIO_GPIO6_OUTPUT); px4_arch_configgpio(GPIO_GPIO7_OUTPUT); /* configure SPI interfaces */ stm32_spiinitialize(); stm32_configgpio(GPIO_I2C2_SCL); stm32_configgpio(GPIO_I2C2_SDA); stm32_configgpio(GPIO_I2C1_SCL); stm32_configgpio(GPIO_I2C1_SDA); }
__EXPORT int board_app_initialize(uintptr_t arg) { /* Ensure the power is on 1 ms before we drive the GPIO pins */ usleep(1000); if (OK == determin_hw_version(&hw_version, & hw_revision)) { switch (hw_version) { case HW_VER_FMUV2_STATE: break; case HW_VER_FMUV3_STATE: hw_type[1]++; hw_type[2] = '0'; /* Has CAN2 transceiver Remove pull up */ stm32_configgpio(GPIO_CAN2_RX); break; case HW_VER_FMUV2MINI_STATE: /* Detection for a Pixhack3 */ stm32_configgpio(HW_VER_PA8); up_udelay(10); bool isph3 = stm32_gpioread(HW_VER_PA8); stm32_configgpio(HW_VER_PA8_INIT); if (isph3) { /* Pixhack3 looks like a FMuV3 Cube */ hw_version = HW_VER_FMUV3_STATE; hw_type[1]++; hw_type[2] = '0'; message("\nPixhack V3 detected, forcing to fmu-v3"); } else { /* It is a mini */ hw_type[2] = 'M'; } break; default: /* questionable px4_fmu-v2 hardware, try forcing regular FMUv2 (not much else we can do) */ message("\nbad version detected, forcing to fmu-v2"); hw_version = HW_VER_FMUV2_STATE; break; } message("\nFMUv2 ver 0x%1X : Rev %x %s\n", hw_version, hw_revision, hw_type); } /* configure SPI interfaces */ stm32_spiinitialize(); px4_platform_init(); /* configure the DMA allocator */ if (board_dma_alloc_init() < 0) { message("DMA alloc FAILED"); } /* set up the serial DMA polling */ static struct hrt_call serial_dma_call; struct timespec ts; /* * Poll at 1ms intervals for received bytes that have not triggered * a DMA event. */ ts.tv_sec = 0; ts.tv_nsec = 1000000; hrt_call_every(&serial_dma_call, ts_to_abstime(&ts), ts_to_abstime(&ts), (hrt_callout)stm32_serial_dma_poll, NULL); /* initial LED state */ drv_led_start(); led_off(LED_AMBER); if (board_hardfault_init(2, true) != 0) { led_on(LED_AMBER); } /* Configure SPI-based devices */ spi1 = stm32_spibus_initialize(PX4_SPI_BUS_SENSORS); if (!spi1) { message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_SENSORS); led_on(LED_AMBER); return -ENODEV; } /* Default SPI1 to 1MHz and de-assert the known chip selects. */ SPI_SETFREQUENCY(spi1, 10000000); SPI_SETBITS(spi1, 8); SPI_SETMODE(spi1, SPIDEV_MODE3); up_udelay(20); /* Get the SPI port for the FRAM */ spi2 = stm32_spibus_initialize(PX4_SPI_BUS_RAMTRON); if (!spi2) { message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_RAMTRON); led_on(LED_AMBER); return -ENODEV; } /* Default SPI2 to 37.5 MHz (40 MHz rounded to nearest valid divider, F4 max) * and de-assert the known chip selects. */ // XXX start with 10.4 MHz in FRAM usage and go up to 37.5 once validated SPI_SETFREQUENCY(spi2, 12 * 1000 * 1000); SPI_SETBITS(spi2, 8); SPI_SETMODE(spi2, SPIDEV_MODE3); spi4 = stm32_spibus_initialize(PX4_SPI_BUS_EXT); if (!spi4) { message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_EXT); led_on(LED_AMBER); return -ENODEV; } /* Default SPI4 to 1MHz and de-assert the known chip selects. */ SPI_SETFREQUENCY(spi4, 10000000); SPI_SETBITS(spi4, 8); SPI_SETMODE(spi4, SPIDEV_MODE3); #ifdef CONFIG_MMCSD /* First, get an instance of the SDIO interface */ sdio = sdio_initialize(CONFIG_NSH_MMCSDSLOTNO); if (!sdio) { led_on(LED_AMBER); message("[boot] Failed to initialize SDIO slot %d\n", CONFIG_NSH_MMCSDSLOTNO); return -ENODEV; } /* Now bind the SDIO interface to the MMC/SD driver */ int ret = mmcsd_slotinitialize(CONFIG_NSH_MMCSDMINOR, sdio); if (ret != OK) { led_on(LED_AMBER); message("[boot] Failed to bind SDIO to the MMC/SD driver: %d\n", ret); return ret; } /* Then let's guess and say that there is a card in the slot. There is no card detect GPIO. */ sdio_mediachange(sdio, true); #endif return OK; }
void stm32_boardinitialize(void) { #ifdef BOARD_HAS_BOOTLOADER /* Check if IWDG is enabled by bootloader. This is the case when * CONFIG_BOOTLOADER_NOWD_BKREG has lowest bit cleared. */ if ((getreg32(CONFIG_BOOTLOADER_NOWD_BKREG) & 1) == 0) { int i; /* Bootloader has enabled IWDG. This happens after POR-reset (since * backup-registers have been reset to zero) and after firmware update. * * Disabling IWDG is used as early boot firmware check (new firmware * started). We now enable NOWD flag and do reset loop with ADDR value * set to application firmware. * * If firmware does not manage to do early boot and gets stuck, IWDG will * reset device and bootloader will either attempt to flash backup * firmware or will reset loop by IWDG until 'current boot try count' * reaches threshold and bootloader boots device to DFU-mode. */ for (i = 0; i < 4; i++) up_lowputc('>'); /* Enable BKREG writing. */ stm32_pwr_enablebkp(true); /* Make bootloader disable IWDG. */ putreg32(1, CONFIG_BOOTLOADER_NOWD_BKREG); /* Setup bootloader to jump directly to firmware. */ putreg32(BOARD_FIRMWARE_BASE_ADDR, CONFIG_BOOTLOADER_ADDR_BKREG); /* Disable BKREG writing. */ stm32_pwr_enablebkp(false); /* Do system reset. */ board_systemreset(); } #endif /* BOARD_HAS_BOOTLOADER */ #if defined(CONFIG_ASSERT_COUNT_BKREG) /* Check value of assert counter (note: does not enable/disable BKREG access * with argument==0). */ if (up_add_assert_count(0) >= CONFIG_ASSERT_COUNT_TO_DFU_MODE) { const char *str = "\nToo many ASSERT resets; something wrong with software. Forcing DFU mode!\n"; while (*str) up_lowputc(*str++); up_mdelay(500); up_reset_to_system_bootloader(); } #endif /* Setup GPIOs based on HW version. */ up_configure_dynamic_gpios(); /* Configure MCU so that debugging is possible in idle modes. */ #ifdef CONFIG_STM32_KEEP_CORE_CLOCK_ENABLED_IN_IDLE_MODES uint32_t cr = getreg32(STM32_DBGMCU_CR); cr |= DBGMCU_CR_STANDBY | DBGMCU_CR_STOP | DBGMCU_CR_SLEEP; putreg32(cr, STM32_DBGMCU_CR); #endif #ifdef CONFIG_BOARD_MCO_SYSCLK /* Output SYSCLK to MCO pin for clock measurements. */ stm32_configgpio(GPIO_MCO); stm32_mcodivconfig(RCC_CFGR_MCOSEL_SYSCLK, RCC_CFGR_MCOPRE_DIV4); #endif /* Configure on-board LEDs if LED support has been selected. */ #ifdef CONFIG_ARCH_LEDS board_led_initialize(); #endif /* Configure chip-select pins. */ board_initialize_chipselects(); /* Configure SDcard pins (needs to be after chip-select init, to pull SDcard * CS down). */ gpio_initialize_sdcard_pins(); /* Configure power control pins. */ board_initialize_pwrctl_pins(); /* Initialize modem gpios. */ up_modem_initialize_gpios(); /* Initialize unused gpio pads. */ gpio_initialize_unused_pads(); /* Enable BKREG writing. */ stm32_pwr_enablebkp(true); /* Reset 'current boot try count' for bootloader. */ putreg32(0, CONFIG_BOOTLOADER_CBTC_BKREG); /* Make bootloader disable IWDG. */ putreg32(1, CONFIG_BOOTLOADER_NOWD_BKREG); /* Check if we need to enter standby/power-off mode. */ up_boot_standby_mode(); /* Disable BKREG writing. */ stm32_pwr_enablebkp(false); /* Force enable capsense and 9-axis for duration * of I2C initialization. After bus initialization * is done, this is undone and drivers will take care * of requesting power for themselves. */ board_pwrctl_get(PWRCTL_SWITCH_CAPSENSE_SENSOR); board_pwrctl_get(PWRCTL_SWITCH_9AXIS_INERTIAL_SENSOR); /* Flash mass-erase can leave option-bytes is bad shape, restore defaults if * needed. */ up_check_and_restore_valid_optionbytes(); /* Configure SPI chip selects if 1) SPI is not disabled, and 2) the weak function * stm32_spiinitialize() has been brought into the link. */ #if defined(CONFIG_STM32_SPI1) || defined(CONFIG_STM32_SPI2) || defined(CONFIG_STM32_SPI3) if (stm32_spiinitialize) { stm32_spiinitialize(); } #endif /* Give early information about reset reason. */ print_reset_reason(); }
__EXPORT void board_spi_reset(int ms) { // TODO: DRDY ///* disable SPI bus 1 DRDY */ //stm32_configgpio(GPIO_DRDY_OFF_PORTD_PIN15); //stm32_configgpio(GPIO_DRDY_OFF_PORTC_PIN14); //stm32_configgpio(GPIO_DRDY_OFF_PORTE_PIN12); //stm32_gpiowrite(GPIO_DRDY_OFF_PORTD_PIN15, 0); //stm32_gpiowrite(GPIO_DRDY_OFF_PORTC_PIN14, 0); //stm32_gpiowrite(GPIO_DRDY_OFF_PORTE_PIN12, 0); /* disable SPI bus 1 CS */ stm32_configgpio(GPIO_SPI1_CS_MEMS_OFF); stm32_gpiowrite(GPIO_SPI1_CS_MEMS_OFF, 0); /* disable SPI bus 2 CS */ stm32_configgpio(GPIO_SPI2_CS_SDCARD_OFF); stm32_gpiowrite(GPIO_SPI2_CS_SDCARD_OFF, 0); /* disable SPI bus 3 CS */ stm32_configgpio(GPIO_SPI3_CS_BARO_OFF); stm32_gpiowrite(GPIO_SPI3_CS_BARO_OFF, 0); stm32_configgpio(GPIO_SPI3_CS_OSD_OFF); stm32_gpiowrite(GPIO_SPI3_CS_OSD_OFF, 0); /* disable SPI bus 1*/ stm32_configgpio(GPIO_SPI1_SCK_OFF); stm32_configgpio(GPIO_SPI1_MISO_OFF); stm32_configgpio(GPIO_SPI1_MOSI_OFF); stm32_gpiowrite(GPIO_SPI1_SCK_OFF, 0); stm32_gpiowrite(GPIO_SPI1_MISO_OFF, 0); stm32_gpiowrite(GPIO_SPI1_MOSI_OFF, 0); /* disable SPI bus 2*/ stm32_configgpio(GPIO_SPI2_SCK_OFF); stm32_configgpio(GPIO_SPI2_MISO_OFF); stm32_configgpio(GPIO_SPI2_MOSI_OFF); stm32_gpiowrite(GPIO_SPI2_SCK_OFF, 0); stm32_gpiowrite(GPIO_SPI2_MISO_OFF, 0); stm32_gpiowrite(GPIO_SPI2_MOSI_OFF, 0); /* disable SPI bus 3*/ stm32_configgpio(GPIO_SPI3_SCK_OFF); stm32_configgpio(GPIO_SPI3_MISO_OFF); stm32_configgpio(GPIO_SPI3_MOSI_OFF); stm32_gpiowrite(GPIO_SPI3_SCK_OFF, 0); stm32_gpiowrite(GPIO_SPI3_MISO_OFF, 0); stm32_gpiowrite(GPIO_SPI3_MOSI_OFF, 0); /* wait a bit before starting SPI, different times didn't influence results */ usleep(100); stm32_spiinitialize(); stm32_configgpio(GPIO_SPI1_SCK); stm32_configgpio(GPIO_SPI1_MISO); stm32_configgpio(GPIO_SPI1_MOSI); // TODO: why do we not enable SPI2 here? stm32_configgpio(GPIO_SPI3_SCK); stm32_configgpio(GPIO_SPI3_MISO); stm32_configgpio(GPIO_SPI3_MOSI); }
void board_initialize(void) { dbg("%d MHz\n", STM32_SYSCLK_FREQUENCY / 1000000); #if defined(CONFIG_GPIO_CHIP_STM32) stm32_gpio_init(); #endif #ifdef CONFIG_STM32_LPTIM1 stm32_lptim1_on(); #endif #ifdef CONFIG_STM32_SPI stm32_spiinitialize(); #endif #ifdef CONFIG_MODS_DIET mods_init(); #endif #ifndef CONFIG_BOARD_INITTHREAD # error "Must enable INITTHREAD" #endif #ifdef CONFIG_DEVICE_CORE device_table_register(&muc_device_table); #ifdef CONFIG_FUSB302 fusb302_register(GPIO_MODS_FUSB302_INT_N, GPIO_MODS_VBUS_PWR_EN); #endif #ifdef CONFIG_FUSB302_USB_EXT extern struct device_driver fusb302_usb_ext_driver; device_register_driver(&fusb302_usb_ext_driver); #endif #ifdef CONFIG_FUSB302_EXT_POWER extern struct device_driver fusb302_ext_power_driver; device_register_driver(&fusb302_ext_power_driver); #endif #ifdef CONFIG_MODS_RAW extern struct device_driver mods_raw_driver; device_register_driver(&mods_raw_driver); #endif #ifdef CONFIG_MODS_RAW_BLINKY extern struct device_driver mods_raw_blinky_driver; device_register_driver(&mods_raw_blinky_driver); #endif #ifdef CONFIG_MODS_RAW_TERMAPP extern struct device_driver mods_raw_termapp_driver; device_register_driver(&mods_raw_termapp_driver); #endif #ifdef CONFIG_MODS_RAW_TEMPERATURE extern struct device_driver mods_raw_temperature_driver; device_register_driver(&mods_raw_temperature_driver); #endif #ifdef CONFIG_GREYBUS_MODS_PTP_DEVICE extern struct device_driver mods_ptp_driver; device_register_driver(&mods_ptp_driver); #endif #ifdef CONFIG_CHARGER_DEVICE_BQ24292 extern struct device_driver bq24292_charger_driver; device_register_driver(&bq24292_charger_driver); #endif #ifdef CONFIG_CHARGER_DEVICE_BQ25896 extern struct device_driver bq25896_charger_driver; device_register_driver(&bq25896_charger_driver); #endif #ifdef CONFIG_GREYBUS_MODS_PTP_CHG_DEVICE_SWITCH extern struct device_driver switch_ptp_chg_driver; device_register_driver(&switch_ptp_chg_driver); #endif #ifdef CONFIG_MAX17050_DEVICE extern struct device_driver batt_driver; device_register_driver(&batt_driver); #endif #ifdef CONFIG_BATTERY_TEMP_DEVICE_MAX17050 extern struct device_driver max17050_battery_temp_driver; device_register_driver(&max17050_battery_temp_driver); #endif #ifdef CONFIG_BATTERY_LEVEL_DEVICE_MAX17050 extern struct device_driver max17050_battery_level_driver; device_register_driver(&max17050_battery_level_driver); #endif #ifdef CONFIG_BATTERY_VOLTAGE_DEVICE_MAX17050 extern struct device_driver max17050_battery_voltage_driver; device_register_driver(&max17050_battery_voltage_driver); #endif #ifdef CONFIG_MHB_APBE_CTRL_DEVICE extern struct device_driver apbe_pwrctrl_driver; device_register_driver(&apbe_pwrctrl_driver); #endif #ifdef CONFIG_BATTERY_GOOD_DEVICE_COMP extern struct device_driver comp_batt_good_driver; device_register_driver(&comp_batt_good_driver); #endif #ifdef CONFIG_GREYBUS_SENSORS_EXT_DUMMY_PRESSURE extern struct device_driver sensor_dummy_pressure_driver; device_register_driver(&sensor_dummy_pressure_driver); #endif #ifdef CONFIG_GREYBUS_SENSORS_EXT_DUMMY_ACCEL extern struct device_driver sensor_dummy_accel_driver; device_register_driver(&sensor_dummy_accel_driver); #endif #ifdef CONFIG_HDMI_DISPLAY extern struct device_driver hdmi_display_driver; device_register_driver(&hdmi_display_driver); #endif #ifdef CONFIG_STM32_UART_DEVICE extern struct device_driver stm32_uart_driver; device_register_driver(&stm32_uart_driver); #endif #if CONFIG_MHB_UART extern struct device_driver mhb_driver; device_register_driver(&mhb_driver); #endif #ifdef CONFIG_MHB_DSI_DISPLAY extern struct device_driver dsi_display_driver; device_register_driver(&dsi_display_driver); #endif #ifdef CONFIG_BACKLIGHT_DCS extern struct device_driver dcs_backlight_driver; device_register_driver(&dcs_backlight_driver); #endif #ifdef CONFIG_BACKLIGHT_ISL98611 extern struct device_driver isl98611_backlight_driver; device_register_driver(&isl98611_backlight_driver); #endif #ifdef CONFIG_BACKLIGHT_LM27965 extern struct device_driver lm27965_backlight_driver; device_register_driver(&lm27965_backlight_driver); #endif #if defined(CONFIG_MHB_CAMERA) extern struct device_driver cam_ext_mhb_driver; device_register_driver(&cam_ext_mhb_driver); #endif #if defined(CONFIG_CAMERA_IMX220) extern struct device_driver imx220_mhb_camera_driver; device_register_driver(&imx220_mhb_camera_driver); #endif #if defined(CONFIG_CAMERA_IMX230) extern struct device_driver imx230_mhb_camera_driver; device_register_driver(&imx230_mhb_camera_driver); #endif #ifdef CONFIG_MODS_AUDIO_TFA9890 extern struct device_driver tfa9890_i2s_direct_driver; device_register_driver(&tfa9890_i2s_direct_driver); extern struct device_driver tfa9890_audio_dev_driver; device_register_driver(&tfa9890_audio_dev_driver); #endif #ifdef CONFIG_MODS_RAW_FACTORY extern struct device_driver display_mux_driver; device_register_driver(&display_mux_driver); extern struct device_driver mods_raw_factory_driver; device_register_driver(&mods_raw_factory_driver); #endif #endif #if defined(CONFIG_CHARGER_BQ24292) (void)bq24292_driver_init(GPIO_MODS_CHG_INT_N, GPIO_MODS_CHG_PG_N); #endif #ifdef CONFIG_BATTERY_MAX17050 struct i2c_dev_s *i2c = up_i2cinitialize(MAX17050_I2C_BUS); if (i2c) { g_battery = max17050_initialize(i2c, MAX17050_I2C_FREQ, GPIO_MODS_CC_ALERT); if (!g_battery) { up_i2cuninitialize(i2c); } } # if defined(CONFIG_BATTERY_STATE) /* Must be initialized after MAX17050 core driver has been initialized */ battery_state_init(); # endif #endif #if !defined(CONFIG_GREYBUS_PTP_EXT_SUPPORTED) /* Set the power paths to be able to use USB VBUS as the system power and * to prevent applying voltage to VBUS pin on the Mod connector. Also, * prevent accepting power from the PCARD VBUS connection. */ gpio_set_value(GPIO_MODS_CHG_VINA_EN, 1); gpio_set_value(GPIO_MODS_CHG_VINB_EN, 0); #endif }