FAR int board_lcd_initialize(void)
{
lcdinfo("Initializing lcd\n");
lcdinfo("init spi1\n");
spi = stm32_spibus_initialize(1);
DEBUGASSERT(spi);
lcdinfo("configure related io\n");
stm32_configgpio(GPIO_MEMLCD_EXTCOMIN);
stm32_configgpio(GPIO_MEMLCD_DISP);
lcdinfo("configure EXTCOMIN timer\n");
if (tim == NULL)
{
tim = stm32_tim_init(2);
DEBUGASSERT(tim);
STM32_TIM_SETPERIOD(tim, TIMER_FREQ / EXTCOMIN_FREQ);
STM32_TIM_SETCLOCK(tim, TIMER_FREQ);
STM32_TIM_SETMODE(tim, STM32_TIM_MODE_UP);
}
lcdinfo("init lcd\n");
l_lcddev = memlcd_initialize(spi, &memlcd_priv, 0);
DEBUGASSERT(l_lcddev);
return OK;
}
int stm32_w25initialize(int minor)
{
#ifdef HAVE_W25
FAR struct spi_dev_s *spi;
FAR struct mtd_dev_s *mtd;
#ifdef CONFIG_FS_NXFFS
char devname[12];
#endif
int ret;
/* Get the SPI port */
spi = stm32_spibus_initialize(1);
if (!spi)
{
ferr("ERROR: Failed to initialize SPI port 2\n");
return -ENODEV;
}
/* Now bind the SPI interface to the W25 SPI FLASH driver */
mtd = w25_initialize(spi);
if (!mtd)
{
ferr("ERROR: Failed to bind SPI port 2 to the SST 25 FLASH driver\n");
return -ENODEV;
}
#ifndef CONFIG_FS_NXFFS
/* And finally, use the FTL layer to wrap the MTD driver as a block driver */
ret = ftl_initialize(minor, mtd);
if (ret < 0)
{
ferr("ERROR: Initialize the FTL layer\n");
return ret;
}
#else
/* Initialize to provide NXFFS on the MTD interface */
ret = nxffs_initialize(mtd);
if (ret < 0)
{
ferr("ERROR: NXFFS initialization failed: %d\n", -ret);
return ret;
}
/* Mount the file system at /mnt/w25 */
snprintf(devname, 12, "/mnt/w25%c", 'a' + minor);
ret = mount(NULL, devname, "nxffs", 0, NULL);
if (ret < 0)
{
ferr("ERROR: Failed to mount the NXFFS volume: %d\n", errno);
return ret;
}
#endif
#endif
return OK;
}
void stm32_wlinitialize(void)
{
# ifndef CONFIG_STM32_SPI2
# error "STM32_SPI2 is required to support nRF24L01 module on this board"
# endif
int result;
FAR struct spi_dev_s *spidev;
/* Setup CE & IRQ line IOs */
stm32_configgpio(GPIO_NRF24L01_CE);
stm32_configgpio(GPIO_NRF24L01_IRQ);
/* Init SPI bus */
spidev = stm32_spibus_initialize(2);
if (!spidev)
{
_err("ERROR: Failed to initialize SPI bus\n");
return;
}
result = nrf24l01_register(spidev, &nrf_cfg);
if (result != OK)
{
_err("ERROR: Failed to register initialize SPI bus\n");
return;
}
}
FAR struct spi_dev_s *stm32_spi5initialize(void)
{
if (!g_spidev5)
{
g_spidev5 = stm32_spibus_initialize(5);
}
return g_spidev5;
}
int board_lcd_initialize(void)
{
g_spidev = stm32_spibus_initialize(LCD_SPI_PORTNO);
if (!g_spidev)
{
lcderr("ERROR: Failed to initialize SPI port %d\n", LCD_SPI_PORTNO);
return 0;
}
return 1;
}
void weak_function stm32_spidev_initialize(void)
{
#ifdef CONFIG_STM32_SPI1
/* Configure SPI-based devices */
g_spi1 = stm32_spibus_initialize(1);
if (!g_spi1)
{
spierr("ERROR: FAILED to initialize SPI port 1\n");
}
#ifdef HAVE_MMCSD
stm32_configgpio(GPIO_SPI_CS_SD_CARD);
#endif
#endif
#ifdef CONFIG_STM32_SPI2
/* Configure SPI-based devices */
g_spi2 = stm32_spibus_initialize(2);
#endif
}
int usbmsc_archinitialize(void)
{
/* If system/usbmsc is built as an NSH command, then SD slot should
* already have been initialized in board_app_initialize() (see stm32_appinit.c).
* In this case, there is nothing further to be done here.
*/
FAR struct spi_dev_s *spi;
int ret;
/* First, get an instance of the SPI interface */
syslog(LOG_INFO, "Initializing SPI port %d\n",
OLIMEXINO_STM32_MMCSDSPIPORTNO);
spi = stm32_spibus_initialize(OLIMEXINO_STM32_MMCSDSPIPORTNO);
if (!spi)
{
syslog(LOG_ERR, "ERROR: Failed to initialize SPI port %d\n",
OLIMEXINO_STM32_MMCSDSPIPORTNO);
return -ENODEV;
}
syslog(LOG_INFO, "Successfully initialized SPI port %d\n",
OLIMEXINO_STM32_MMCSDSPIPORTNO);
/* Now bind the SPI interface to the MMC/SD driver */
syslog(LOG_INFO, "Bind SPI to the MMC/SD driver, minor=%d slot=%d\n",
CONFIG_SYSTEM_USBMSC_DEVMINOR1, OLIMEXINO_STM32_MMCSDSLOTNO);
ret = mmcsd_spislotinitialize(CONFIG_SYSTEM_USBMSC_DEVMINOR1,
OLIMEXINO_STM32_MMCSDSLOTNO, spi);
if (ret < 0)
{
syslog(LOG_ERR,
"ERROR: Failed to bind SPI port %d to MMC/SD minor=%d slot=%d %d\n",
OLIMEXINO_STM32_MMCSDSPIPORTNO, CONFIG_SYSTEM_USBMSC_DEVMINOR1,
OLIMEXINO_STM32_MMCSDSLOTNO, ret);
return ret;
}
syslog(LOG_INFO, "Successfully bound SPI to the MMC/SD driver\n");
return OK;
}
FAR struct lcd_dev_s *board_graphics_setup(unsigned int devno)
{
FAR struct spi_dev_s *spi;
FAR struct lcd_dev_s *dev;
/* Configure the OLED GPIOs. This initial configuration is RESET low,
* putting the OLED into reset state.
*/
(void)stm32_configgpio(GPIO_OLED_RESET);
/* Wait a bit then release the OLED from the reset state */
up_mdelay(20);
stm32_gpiowrite(GPIO_OLED_RESET, true);
/* Get the SPI1 port interface */
spi = stm32_spibus_initialize(1);
if (spi == NULL)
{
lcddbg("Failed to initialize SPI port 1\n");
}
else
{
/* Bind the SPI port to the OLED */
dev = ssd1351_initialize(spi, devno);
if (dev == NULL)
{
lcddbg("Failed to bind SPI port 1 to OLED %d: %d\n", devno);
}
else
{
lcdvdbg("Bound SPI port 1 to OLED %d\n", devno);
/* And turn the OLED on */
(void)dev->setpower(dev, LCD_FULL_ON);
return dev;
}
}
return NULL;
}
int stm32_max6675initialize(FAR const char *devpath)
{
FAR struct spi_dev_s *spi;
int ret;
spi = stm32_spibus_initialize(MAX6675_SPI_PORTNO);
if (!spi)
{
return -ENODEV;
}
/* Then register the barometer sensor */
ret = max6675_register(devpath, spi);
if (ret < 0)
{
snerr("ERROR: Error registering MAX6675\n");
}
return ret;
}
int stm32_sdinitialize(int minor)
{
#ifdef HAVE_MMCSD
FAR struct spi_dev_s *spi;
int ret;
/* Get the SPI port */
finfo("Initializing SPI port %d\n", STM32_MMCSDSPIPORTNO);
spi = stm32_spibus_initialize(STM32_MMCSDSPIPORTNO);
if (!spi)
{
ferr("ERROR: Failed to initialize SPI port %d\n", STM32_MMCSDSPIPORTNO);
return -ENODEV;
}
finfo("Successfully initialized SPI port %d\n", STM32_MMCSDSPIPORTNO);
/* Bind the SPI port to the slot */
finfo("Binding SPI port %d to MMC/SD slot %d\n",
STM32_MMCSDSPIPORTNO, STM32_MMCSDSLOTNO);
ret = mmcsd_spislotinitialize(minor, STM32_MMCSDSLOTNO, spi);
if (ret < 0)
{
ferr("ERROR: Failed to bind SPI port %d to MMC/SD slot %d: %d\n",
STM32_MMCSDSPIPORTNO, STM32_MMCSDSLOTNO, ret);
return ret;
}
finfo("Successfuly bound SPI port %d to MMC/SD slot %d\n",
STM32_MMCSDSPIPORTNO, STM32_MMCSDSLOTNO);
#endif
return OK;
}
int board_app_initialize(void)
{
#if defined(CONFIG_STM32_SPI4)
FAR struct spi_dev_s *spi;
FAR struct mtd_dev_s *mtd;
FAR struct mtd_geometry_s geo;
#endif
#if defined(CONFIG_MTD_PARTITION_NAMES)
FAR const char *partname = CONFIG_STM32F429I_DISCO_FLASH_PART_NAMES;
#endif
#if defined(CONFIG_MTD) && defined(CONFIG_MTD_SST25XX)
int ret;
#elif defined(HAVE_USBHOST) || defined(HAVE_USBMONITOR)
int ret;
#endif
/* Configure SPI-based devices */
#ifdef CONFIG_STM32_SPI4
/* Get the SPI port */
syslog(LOG_INFO, "Initializing SPI port 4\n");
spi = stm32_spibus_initialize(4);
if (!spi)
{
syslog(LOG_ERR, "ERROR: Failed to initialize SPI port 4\n");
return -ENODEV;
}
syslog(LOG_INFO, "Successfully initialized SPI port 4\n");
/* Now bind the SPI interface to the SST25F064 SPI FLASH driver. This
* is a FLASH device that has been added external to the board (i.e.
* the board does not ship from STM with any on-board FLASH.
*/
#if defined(CONFIG_MTD) && defined(CONFIG_MTD_SST25XX)
syslog(LOG_INFO, "Bind SPI to the SPI flash driver\n");
mtd = sst25xx_initialize(spi);
if (!mtd)
{
syslog(LOG_ERR, "ERROR: Failed to bind SPI port 4 to the SPI FLASH driver\n");
}
else
{
syslog(LOG_INFO, "Successfully bound SPI port 4 to the SPI FLASH driver\n");
/* Get the geometry of the FLASH device */
ret = mtd->ioctl(mtd, MTDIOC_GEOMETRY, (unsigned long)((uintptr_t)&geo));
if (ret < 0)
{
fdbg("ERROR: mtd->ioctl failed: %d\n", ret);
return ret;
}
#ifdef CONFIG_STM32F429I_DISCO_FLASH_PART
{
int partno;
int partsize;
int partoffset;
int partszbytes;
int erasesize;
const char *partstring = CONFIG_STM32F429I_DISCO_FLASH_PART_LIST;
const char *ptr;
FAR struct mtd_dev_s *mtd_part;
char partref[4];
/* Now create a partition on the FLASH device */
partno = 0;
ptr = partstring;
partoffset = 0;
/* Get the Flash erase size */
erasesize = geo.erasesize;
while (*ptr != '\0')
{
/* Get the partition size */
partsize = atoi(ptr);
partszbytes = (partsize << 10); /* partsize is defined in KB */
/* Check if partition size is bigger then erase block */
if (partszbytes < erasesize)
{
fdbg("ERROR: Partition size is lesser than erasesize!\n");
return -1;
}
/* Check if partition size is multiple of erase block */
if ((partszbytes % erasesize) != 0)
{
fdbg("ERROR: Partition size is not multiple of erasesize!\n");
return -1;
}
mtd_part = mtd_partition(mtd, partoffset, partszbytes / erasesize);
partoffset += partszbytes / erasesize;
#ifdef CONFIG_STM32F429I_DISCO_FLASH_CONFIG_PART
/* Test if this is the config partition */
if (CONFIG_STM32F429I_DISCO_FLASH_CONFIG_PART_NUMBER == partno)
{
/* Register the partition as the config device */
mtdconfig_register(mtd_part);
}
else
#endif
{
/* Now initialize a SMART Flash block device and bind it
* to the MTD device.
*/
#if defined(CONFIG_MTD_SMART) && defined(CONFIG_FS_SMARTFS)
sprintf(partref, "p%d", partno);
smart_initialize(CONFIG_STM32F429I_DISCO_FLASH_MINOR, mtd_part, partref);
#endif
}
#if defined(CONFIG_MTD_PARTITION_NAMES)
/* Set the partition name */
if (mtd_part == NULL)
{
dbg("Error: failed to create partition %s\n", partname);
return -1;
}
mtd_setpartitionname(mtd_part, partname);
/* Now skip to next name. We don't need to split the string here
* because the MTD partition logic will only display names up to
* the comma, thus allowing us to use a single static name
* in the code.
*/
while (*partname != ',' && *partname != '\0')
{
/* Skip to next ',' */
partname++;
}
if (*partname == ',')
{
partname++;
}
#endif
/* Update the pointer to point to the next size in the list */
while ((*ptr >= '0') && (*ptr <= '9'))
{
ptr++;
}
if (*ptr == ',')
{
ptr++;
}
/* Increment the part number */
partno++;
}
}
#else /* CONFIG_STM32F429I_DISCO_FLASH_PART */
/* Configure the device with no partition support */
smart_initialize(CONFIG_STM32F429I_DISCO_FLASH_MINOR, mtd, NULL);
#endif /* CONFIG_STM32F429I_DISCO_FLASH_PART */
}
#endif /* CONFIG_MTD */
#endif /* CONFIG_STM32_SPI4 */
/* Create a RAM MTD device if configured */
#if defined(CONFIG_RAMMTD) && defined(CONFIG_STM32F429I_DISCO_RAMMTD)
{
uint8_t *start = (uint8_t *) kmm_malloc(CONFIG_STM32F429I_DISCO_RAMMTD_SIZE * 1024);
mtd = rammtd_initialize(start, CONFIG_STM32F429I_DISCO_RAMMTD_SIZE * 1024);
mtd->ioctl(mtd, MTDIOC_BULKERASE, 0);
/* Now initialize a SMART Flash block device and bind it to the MTD device */
#if defined(CONFIG_MTD_SMART) && defined(CONFIG_FS_SMARTFS)
smart_initialize(CONFIG_STM32F429I_DISCO_RAMMTD_MINOR, mtd, NULL);
#endif
}
#endif /* CONFIG_RAMMTD && CONFIG_STM32F429I_DISCO_RAMMTD */
#ifdef HAVE_USBHOST
/* Initialize USB host operation. stm32_usbhost_initialize() starts a thread
* will monitor for USB connection and disconnection events.
*/
ret = stm32_usbhost_initialize();
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to initialize USB host: %d\n", ret);
return ret;
}
#endif
#ifdef HAVE_USBMONITOR
/* Start the USB Monitor */
ret = usbmonitor_start(0, NULL);
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to start USB monitor: %d\n", ret);
}
#endif
return OK;
}
int board_app_initialize(uintptr_t arg)
{
#ifdef CONFIG_STM32_SPI1
FAR struct spi_dev_s *spi;
FAR struct mtd_dev_s *mtd;
#endif
#ifdef NSH_HAVEMMCSD
FAR struct sdio_dev_s *sdio;
#endif
int ret;
/* Register I2C drivers on behalf of the I2C tool */
stm32_i2ctool();
/* Configure SPI-based devices */
#ifdef CONFIG_STM32_SPI1
/* Get the SPI port */
syslog(LOG_INFO, "Initializing SPI port 1\n");
spi = stm32_spibus_initialize(1);
if (!spi)
{
syslog(LOG_ERR, "ERROR: Failed to initialize SPI port 0\n");
return -ENODEV;
}
syslog(LOG_INFO, "Successfully initialized SPI port 0\n");
/* Now bind the SPI interface to the M25P64/128 SPI FLASH driver */
syslog(LOG_INFO, "Bind SPI to the SPI flash driver\n");
mtd = m25p_initialize(spi);
if (!mtd)
{
syslog(LOG_ERR, "ERROR: Failed to bind SPI port 0 to the SPI FLASH driver\n");
return -ENODEV;
}
syslog(LOG_INFO, "Successfully bound SPI port 0 to the SPI FLASH driver\n");
#warning "Now what are we going to do with this SPI FLASH driver?"
#endif
/* Create the SPI FLASH MTD instance */
/* The M25Pxx is not a give media to implement a file system..
* its block sizes are too large
*/
/* Mount the SDIO-based MMC/SD block driver */
#ifdef NSH_HAVEMMCSD
/* First, get an instance of the SDIO interface */
syslog(LOG_INFO, "Initializing SDIO slot %d\n",
CONFIG_NSH_MMCSDSLOTNO);
sdio = sdio_initialize(CONFIG_NSH_MMCSDSLOTNO);
if (!sdio)
{
syslog(LOG_ERR, "ERROR: Failed to initialize SDIO slot %d\n",
CONFIG_NSH_MMCSDSLOTNO);
return -ENODEV;
}
/* Now bind the SDIO interface to the MMC/SD driver */
syslog(LOG_INFO, "Bind SDIO to the MMC/SD driver, minor=%d\n",
CONFIG_NSH_MMCSDMINOR);
ret = mmcsd_slotinitialize(CONFIG_NSH_MMCSDMINOR, sdio);
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to bind SDIO to the MMC/SD driver: %d\n", ret);
return ret;
}
syslog(LOG_INFO, "Successfully bound SDIO to the MMC/SD driver\n");
/* Then let's guess and say that there is a card in the slot. I need to check to
* see if the STM3210E-EVAL board supports a GPIO to detect if there is a card in
* the slot.
*/
sdio_mediachange(sdio, true);
#endif
#ifdef CONFIG_ADC
/* Initialize ADC and register the ADC driver. */
ret = stm32_adc_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: stm32_adc_setup failed: %d\n", ret);
}
#endif
#ifdef CONFIG_CAN
/* Initialize CAN and register the CAN driver. */
ret = stm32_can_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: stm32_can_setup failed: %d\n", ret);
}
#endif
#ifdef CONFIG_DJOYSTICK
/* Initialize and register the joystick driver */
ret = stm32_djoy_initialization();
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to register the joystick driver: %d\n", ret);
return ret;
}
syslog(LOG_INFO, "Successfully registered the joystick driver\n");
#endif
UNUSED(ret);
return OK;
}
__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;
}
int board_app_initialize(void)
{
#ifdef HAVE_SST25
FAR struct spi_dev_s *spi;
FAR struct mtd_dev_s *mtd;
int ret;
/* Configure SPI-based devices */
/* Get the SPI port */
syslog(LOG_INFO, "Initializing SPI port %d\n",
CONFIG_SPARK_FLASH_SPI);
spi = stm32_spibus_initialize(CONFIG_SPARK_FLASH_SPI);
if (!spi)
{
syslog(LOG_ERR, "ERROR: Failed to initialize SPI port %d\n",
CONFIG_SPARK_FLASH_SPI);
return -ENODEV;
}
syslog(LOG_INFO, "Successfully initialized SPI port %d\n",
CONFIG_SPARK_FLASH_SPI);
/* Now bind the SPI interface to the SST25 SPI FLASH driver */
syslog(LOG_INFO, "Bind SPI to the SPI flash driver\n");
mtd = sst25_initialize(spi);
if (!mtd)
{
syslog(LOG_ERR, "ERROR: Failed to bind SPI port %d to the SPI FLASH driver\n",
CONFIG_SPARK_FLASH_SPI);
}
else
{
syslog(LOG_INFO, "Successfully bound SPI port %d to the SPI FLASH driver\n",
CONFIG_SPARK_FLASH_SPI);
}
#ifndef CONFIG_SPARK_FLASH_PART
/* Use the FTL layer to wrap the MTD driver as a block driver */
ret = ftl_initialize(CONFIG_SPARK_FLASH_MINOR, mtd);
if (ret < 0)
{
fdbg("ERROR: Initialize the FTL layer\n");
return ret;
}
#ifdef CONFIG_SPARK_MOUNT_FLASH
char partname[16];
char mntpoint[16];
/* mount -t vfat /dev/mtdblock0 /mnt/p0 */
snprintf(partname, sizeof(partname), "/dev/mtdblock%d",
CONFIG_SPARK_FLASH_MINOR);
snprintf(mntpoint, sizeof(mntpoint)-1, CONFIG_SPARK_FLASH_MOUNT_POINT,
CONFIG_SPARK_FLASH_MINOR);
/* Mount the file system at /mnt/pn */
ret = mount(partname, mntpoint, "vfat", 0, NULL);
if (ret < 0)
{
fdbg("ERROR: Failed to mount the FAT volume: %d\n", errno);
return ret;
}
#endif
#else
{
int partno;
int partsize;
int partoffset;
const char *partstring = CONFIG_SPARK_FLASH_PART_LIST;
const char *ptr;
FAR struct mtd_dev_s *mtd_part;
char partname[16];
char mntpoint[16];
/* Now create a partition on the FLASH device */
partno = CONFIG_SPARK_FLASH_MINOR;
ptr = partstring;
partoffset = 0;
while (*ptr != '\0')
{
/* Get the partition size */
partsize = atoi(ptr);
mtd_part = mtd_partition(mtd, partoffset, (partsize >> 2) * 16);
partoffset += (partsize >> 2) * 16;
/* Use the FTL layer to wrap the MTD driver as a block driver */
ret = ftl_initialize(partno, mtd_part);
if (ret < 0)
{
fdbg("ERROR: Initialize the FTL layer\n");
return ret;
}
snprintf(partname,sizeof(partname), "/dev/mtdblock%d", partno);
snprintf(mntpoint,sizeof(mntpoint)-1, CONFIG_SPARK_FLASH_MOUNT_POINT,
partno);
/* Mount the file system at /mnt/pn */
ret = mount(partname, mntpoint, "vfat", 0, NULL);
if (ret < 0)
{
fdbg("ERROR: Failed to mount the FAT volume: %d\n", errno);
return ret;
}
/* Update the pointer to point to the next size in the list */
while ((*ptr >= '0') && (*ptr <= '9'))
{
ptr++;
}
if (*ptr == ',')
{
ptr++;
}
/* Increment the part number */
partno++;
}
}
#endif /* CONFIG_SPARK_FLASH_PART */
#endif /* HAVE_SST25 */
#ifdef HAVE_USBMONITOR
/* Start the USB Monitor */
ret = usbmonitor_start(0, NULL);
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to start USB monitor: %d\n", ret);
}
#endif
return OK;
}
int board_app_initialize(uintptr_t arg)
{
#ifdef HAVE_RTC_DRIVER
FAR struct rtc_lowerhalf_s *lower;
#endif
#ifdef CONFIG_STM32_SPI1
FAR struct spi_dev_s *spi;
FAR struct mtd_dev_s *mtd;
#endif
#ifdef HAVE_MMCSD
FAR struct sdio_dev_s *sdio;
#endif
int ret;
/* Register I2C drivers on behalf of the I2C tool */
stm32_i2ctool();
#ifdef HAVE_RTC_DRIVER
/* Instantiate the STM32 lower-half RTC driver */
lower = stm32_rtc_lowerhalf();
if (!lower)
{
syslog(LOG_ERR,
"ERROR: Failed to instantiate the RTC lower-half driver\n");
return -ENOMEM;
}
else
{
/* Bind the lower half driver and register the combined RTC driver
* as /dev/rtc0
*/
ret = rtc_initialize(0, lower);
if (ret < 0)
{
syslog(LOG_ERR,
"ERROR: Failed to bind/register the RTC driver: %d\n",
ret);
return ret;
}
}
#endif
/* Configure SPI-based devices */
#ifdef CONFIG_STM32_SPI1
/* Get the SPI port */
spi = stm32_spibus_initialize(1);
if (!spi)
{
syslog(LOG_ERR, "ERROR: Failed to initialize SPI port 0\n");
return -ENODEV;
}
/* Now bind the SPI interface to the M25P64/128 SPI FLASH driver */
mtd = m25p_initialize(spi);
if (!mtd)
{
syslog(LOG_ERR,
"ERROR: Failed to bind SPI port 0 to the SPI FLASH driver\n");
return -ENODEV;
}
#warning "Now what are we going to do with this SPI FLASH driver?"
#endif
/* Mount the SDIO-based MMC/SD block driver */
#ifdef HAVE_MMCSD
/* First, get an instance of the SDIO interface */
sdio = sdio_initialize(CONFIG_NSH_MMCSDSLOTNO);
if (!sdio)
{
syslog(LOG_ERR,
"ERROR: Failed to initialize SDIO slot %d\n",
CONFIG_NSH_MMCSDSLOTNO);
return -ENODEV;
}
/* Now bind the SDIO interface to the MMC/SD driver */
ret = mmcsd_slotinitialize(CONFIG_NSH_MMCSDMINOR, sdio);
if (ret != OK)
{
syslog(LOG_ERR,
"ERROR: 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. I need to check to
* see if the STM3240G-EVAL board supports a GPIO to detect if there is a card in
* the slot.
*/
sdio_mediachange(sdio, true);
#endif
#ifdef HAVE_USBHOST
/* Initialize USB host operation. stm32_usbhost_initialize() starts a thread
* will monitor for USB connection and disconnection events.
*/
ret = stm32_usbhost_initialize();
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to initialize USB host: %d\n", ret);
return ret;
}
#endif
#ifdef CONFIG_PWM
/* Initialize PWM and register the PWM device. */
ret = stm32_pwm_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: stm32_pwm_setup() failed: %d\n", ret);
}
#endif
#ifdef CONFIG_ADC
/* Initialize ADC and register the ADC driver. */
ret = stm32_adc_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: stm32_adc_setup failed: %d\n", ret);
}
#endif
#ifdef CONFIG_CAN
/* Initialize CAN and register the CAN driver. */
ret = stm32_can_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: stm32_can_setup failed: %d\n", ret);
}
#endif
UNUSED(ret);
return OK;
}
__EXPORT int stm32_spi_bus_initialize(void)
{
/* Configure SPI-based devices */
/* Get the SPI port for the Sensors */
spi_sensors = stm32_spibus_initialize(PX4_SPI_BUS_SENSORS);
if (!spi_sensors) {
message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_SENSORS);
return -ENODEV;
}
/* Default PX4_SPI_BUS_SENSORS to 1MHz and de-assert the known chip selects. */
SPI_SETFREQUENCY(spi_sensors, 10000000);
SPI_SETBITS(spi_sensors, 8);
SPI_SETMODE(spi_sensors, SPIDEV_MODE3);
for (int cs = PX4_SENSORS_BUS_FIRST_CS; cs <= PX4_SENSORS_BUS_LAST_CS; cs++) {
SPI_SELECT(spi_sensors, cs, false);
}
/* Get the SPI port for the Memory */
spi_memory = stm32_spibus_initialize(PX4_SPI_BUS_MEMORY);
if (!spi_memory) {
message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_MEMORY);
return -ENODEV;
}
/* Default PX4_SPI_BUS_MEMORY to 12MHz and de-assert the known chip selects.
*/
SPI_SETFREQUENCY(spi_memory, 12 * 1000 * 1000);
SPI_SETBITS(spi_memory, 8);
SPI_SETMODE(spi_memory, SPIDEV_MODE3);
for (int cs = PX4_MEMORY_BUS_FIRST_CS; cs <= PX4_MEMORY_BUS_LAST_CS; cs++) {
SPI_SELECT(spi_memory, cs, false);
}
/* Get the SPI port for the BARO */
spi_baro = stm32_spibus_initialize(PX4_SPI_BUS_BARO);
if (!spi_baro) {
message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_BARO);
return -ENODEV;
}
/* MS5611 has max SPI clock speed of 20MHz
*/
SPI_SETFREQUENCY(spi_baro, 20 * 1000 * 1000);
SPI_SETBITS(spi_baro, 8);
SPI_SETMODE(spi_baro, SPIDEV_MODE3);
for (int cs = PX4_BARO_BUS_FIRST_CS; cs <= PX4_BARO_BUS_LAST_CS; cs++) {
SPI_SELECT(spi_baro, cs, false);
}
/* Get the SPI port for the PX4_SPI_EXTERNAL */
spi_ext = stm32_spibus_initialize(PX4_SPI_BUS_EXTERNAL);
if (!spi_ext) {
message("[boot] FAILED to initialize SPI port %d\n", PX4_SPI_BUS_EXTERNAL);
return -ENODEV;
}
SPI_SETFREQUENCY(spi_ext, 8 * 1000 * 1000);
SPI_SETBITS(spi_ext, 8);
SPI_SETMODE(spi_ext, SPIDEV_MODE3);
for (int cs = PX4_EXTERNAL_BUS_FIRST_CS; cs <= PX4_EXTERNAL_BUS_LAST_CS; cs++) {
SPI_SELECT(spi_ext, cs, false);
}
return OK;
}
__EXPORT int board_app_initialize(uintptr_t arg)
{
int result;
/* IN12 and IN13 further below */
#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
/* configure the high-resolution time/callout interface */
hrt_init();
/* 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);
/* initial LED state */
drv_led_start();
led_off(LED_AMBER);
led_off(LED_BLUE);
/* Configure SPI-based devices */
spi1 = stm32_spibus_initialize(1);
if (!spi1) {
message("[boot] FAILED to initialize SPI port 1\r\n");
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);
SPI_SELECT(spi1, PX4_SPIDEV_GYRO, false);
SPI_SELECT(spi1, PX4_SPIDEV_ACCEL, false);
SPI_SELECT(spi1, PX4_SPIDEV_MPU, false);
up_udelay(20);
/*
* If SPI2 is enabled in the defconfig, we loose some ADC pins as chip selects.
* Keep the SPI2 init optional and conditionally initialize the ADC pins
*/
#ifdef CONFIG_STM32_SPI2
spi2 = stm32_spibus_initialize(2);
/* Default SPI2 to 1MHz and de-assert the known chip selects. */
SPI_SETFREQUENCY(spi2, 10000000);
SPI_SETBITS(spi2, 8);
SPI_SETMODE(spi2, SPIDEV_MODE3);
SPI_SELECT(spi2, PX4_SPIDEV_GYRO, false);
SPI_SELECT(spi2, PX4_SPIDEV_ACCEL_MAG, false);
message("[boot] Initialized SPI port2 (ADC IN12/13 blocked)\n");
#else
spi2 = NULL;
message("[boot] Enabling IN12/13 instead of SPI2\n");
/* no SPI2, use pins for ADC */
stm32_configgpio(GPIO_ADC1_IN12);
stm32_configgpio(GPIO_ADC1_IN13); // jumperable to MPU6000 DRDY on some boards
#endif
/* Get the SPI port for the microSD slot */
spi3 = stm32_spibus_initialize(3);
if (!spi3) {
message("[boot] FAILED to initialize SPI port 3\n");
board_autoled_on(LED_AMBER);
return -ENODEV;
}
/* Now bind the SPI interface to the MMCSD driver */
result = mmcsd_spislotinitialize(CONFIG_NSH_MMCSDMINOR, CONFIG_NSH_MMCSDSLOTNO, spi3);
if (result != OK) {
message("[boot] FAILED to bind SPI port 3 to the MMCSD driver\n");
board_autoled_on(LED_AMBER);
return -ENODEV;
}
return OK;
}
__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
/* configure the high-resolution time/callout interface */
hrt_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)
/* 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
#endif // CONFIG_STM32_SAVE_CRASHDUMP
#endif // CONFIG_STM32_BBSRAM
/* initial LED state */
drv_led_start();
led_off(LED_RED);
led_off(LED_GREEN);
led_off(LED_BLUE);
/* Configure SPI-based devices */
spi1 = stm32_spibus_initialize(1);
if (!spi1) {
message("[boot] FAILED to initialize SPI port 1\n");
board_autoled_on(LED_RED);
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);
SPI_SELECT(spi1, PX4_SPIDEV_GYRO, false);
SPI_SELECT(spi1, PX4_SPIDEV_HMC, false);
SPI_SELECT(spi1, PX4_SPIDEV_MPU, false);
up_udelay(20);
/* Get the SPI port for the FRAM */
spi2 = stm32_spibus_initialize(2);
if (!spi2) {
message("[boot] FAILED to initialize SPI port 2\n");
board_autoled_on(LED_RED);
return -ENODEV;
}
/* Default SPI2 to 12MHz and de-assert the known chip selects.
* MS5611 has max SPI clock speed of 20MHz
*/
// XXX start with 10.4 MHz and go up to 20 once validated
SPI_SETFREQUENCY(spi2, 20 * 1000 * 1000);
SPI_SETBITS(spi2, 8);
SPI_SETMODE(spi2, SPIDEV_MODE3);
SPI_SELECT(spi2, SPIDEV_FLASH, false);
SPI_SELECT(spi2, PX4_SPIDEV_BARO, false);
#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;
}
int board_app_initialize(uintptr_t arg)
{
#ifdef CONFIG_STM32_SPI3
FAR struct spi_dev_s *spi;
FAR struct mtd_dev_s *mtd;
#endif
int ret = OK;
/* Configure SPI-based devices */
#ifdef CONFIG_STM32_SPI3
/* Get the SPI port */
syslog(LOG_INFO, "Initializing SPI port 3\n");
spi = stm32_spibus_initialize(3);
if (!spi)
{
syslog(LOG_ERR, "ERROR: Failed to initialize SPI port 3\n");
return -ENODEV;
}
syslog(LOG_INFO, "Successfully initialized SPI port 3\n");
/* Now bind the SPI interface to the M25P8 SPI FLASH driver */
#if defined(CONFIG_MTD) && defined(CONFIG_MIKROE_FLASH)
syslog(LOG_INFO, "Bind SPI to the SPI flash driver\n");
mtd = m25p_initialize(spi);
if (!mtd)
{
syslog(LOG_ERR, "ERROR: Failed to bind SPI port 3 to the SPI FLASH driver\n");
}
else
{
syslog(LOG_INFO, "Successfully bound SPI port 3 to the SPI FLASH driver\n");
#ifdef CONFIG_MIKROE_FLASH_PART
{
int partno;
int partsize;
int partoffset;
const char *partstring = CONFIG_MIKROE_FLASH_PART_LIST;
const char *ptr;
FAR struct mtd_dev_s *mtd_part;
char partname[4];
/* Now create a partition on the FLASH device */
partno = 0;
ptr = partstring;
partoffset = 0;
while (*ptr != '\0')
{
/* Get the partition size */
partsize = atoi(ptr);
mtd_part = mtd_partition(mtd, partoffset, (partsize>>2)*16);
partoffset += (partsize >> 2) * 16;
#ifdef CONFIG_MIKROE_FLASH_CONFIG_PART
/* Test if this is the config partition */
if (CONFIG_MIKROE_FLASH_CONFIG_PART_NUMBER == partno)
{
/* Register the partition as the config device */
mtdconfig_register(mtd_part);
}
else
#endif
{
/* Now initialize a SMART Flash block device and bind it
* to the MTD device.
*/
#if defined(CONFIG_MTD_SMART) && defined(CONFIG_FS_SMARTFS)
sprintf(partname, "p%d", partno);
smart_initialize(CONFIG_MIKROE_FLASH_MINOR, mtd_part, partname);
#endif
}
/* Update the pointer to point to the next size in the list */
while ((*ptr >= '0') && (*ptr <= '9'))
{
ptr++;
}
if (*ptr == ',')
{
ptr++;
}
/* Increment the part number */
partno++;
}
}
#else /* CONFIG_MIKROE_FLASH_PART */
/* Configure the device with no partition support */
smart_initialize(CONFIG_MIKROE_FLASH_MINOR, mtd, NULL);
#endif /* CONFIG_MIKROE_FLASH_PART */
}
/* Create a RAM MTD device if configured */
#if defined(CONFIG_RAMMTD) && defined(CONFIG_MIKROE_RAMMTD)
{
uint8_t *start = (uint8_t *) kmm_malloc(CONFIG_MIKROE_RAMMTD_SIZE * 1024);
mtd = rammtd_initialize(start, CONFIG_MIKROE_RAMMTD_SIZE * 1024);
mtd->ioctl(mtd, MTDIOC_BULKERASE, 0);
/* Now initialize a SMART Flash block device and bind it to the MTD device */
#if defined(CONFIG_MTD_SMART) && defined(CONFIG_FS_SMARTFS)
smart_initialize(CONFIG_MIKROE_RAMMTD_MINOR, mtd, NULL);
#endif
}
#endif /* CONFIG_RAMMTD && CONFIG_MIKROE_RAMMTD */
#endif /* CONFIG_MTD */
#endif /* CONFIG_STM32_SPI3 */
/* Create the SPI FLASH MTD instance */
/* The M25Pxx is not a good media to implement a file system..
* its block sizes are too large
*/
/* Mount the SDIO-based MMC/SD block driver */
#ifdef NSH_HAVEMMCSD
/* Bind the spi interface to the MMC/SD driver */
syslog(LOG_INFO, "Bind SDIO to the MMC/SD driver, minor=%d\n",
CONFIG_NSH_MMCSDMINOR);
ret = mmcsd_spislotinitialize(CONFIG_NSH_MMCSDMINOR, CONFIG_NSH_MMCSDSLOTNO, spi);
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to bind SPI to the MMC/SD driver: %d\n", ret);
}
else
{
syslog(LOG_INFO, "Successfully bound SPI to the MMC/SD driver\n");
}
#endif
#ifdef HAVE_USBHOST
/* Initialize USB host operation. stm32_usbhost_initialize() starts a thread
* will monitor for USB connection and disconnection events.
*/
ret = stm32_usbhost_initialize();
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to initialize USB host: %d\n", ret);
return ret;
}
#endif
#ifdef HAVE_USBMONITOR
/* Start the USB Monitor */
ret = usbmonitor_start();
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to start USB monitor: %d\n", ret);
}
#endif
#ifdef CONFIG_INPUT
/* Initialize the touchscreen */
ret = stm32_tsc_setup(0);
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: stm32_tsc_setup failed: %d\n", ret);
}
#endif
#ifdef CONFIG_PWM
/* Initialize PWM and register the PWM device. */
ret = stm32_pwm_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: stm32_pwm_setup() failed: %d\n", ret);
}
#endif
#if defined(CONFIG_LCD_MIO283QT2) || defined(CONFIG_LCD_MIO283QT9A)
/* Configure the TFT LCD module */
syslog(LOG_INFO, "Initializing TFT LCD module\n");
ret = board_lcd_initialize();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: Failed to initialize TFT LCD module\n");
}
#endif
#ifdef CONFIG_SENSORS_QENCODER
/* Initialize and register the qencoder driver */
ret = stm32_qencoder_initialize("/dev/qe0", CONFIG_MIKROE_QETIMER);
if (ret != OK)
{
syslog(LOG_ERR,
"ERROR: Failed to register the qencoder: %d\n",
ret);
return ret;
}
#endif
#ifdef CONFIG_AUDIO
/* Configure the Audio sub-system if enabled and bind it to SPI 3 */
up_vs1053initialize(spi);
#endif
return ret;
}
