int stm32_w25initialize(int minor) { #ifdef HAVE_W25 FAR struct spi_dev_s *spi; FAR struct mtd_dev_s *mtd; #ifndef CONFIG_FS_NXFFS uint8_t devname[12]; #endif int ret; /* Get the SPI port */ spi = up_spiinitialize(2); if (!spi) { fdbg("ERROR: Failed to initialize SPI port 2\n"); return -ENODEV; } /* Now bind the SPI interface to the SST 25 SPI FLASH driver */ mtd = sst25_initialize(spi); if (!mtd) { fdbg("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) { fdbg("ERROR: Initialize the FTL layer\n"); return ret; } #else /* Initialize to provide NXFFS on the MTD interface */ ret = nxffs_initialize(mtd); if (ret < 0) { fdbg("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) { fdbg("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #endif #endif return OK; }
static void eeprom_start(void) { int ret; if (started) errx(1, "EEPROM already mounted"); if (!attached) eeprom_attach(); /* start NXFFS */ ret = nxffs_initialize(eeprom_mtd); if (ret < 0) errx(1, "failed to initialize NXFFS - erase EEPROM to reformat"); /* mount the EEPROM */ ret = mount(NULL, "/eeprom", "nxffs", 0, NULL); if (ret < 0) errx(1, "failed to mount /eeprom - erase EEPROM to reformat"); started = true; warnx("mounted EEPROM at /eeprom"); exit(0); }
static void ramtron_start(void) { int ret; if (started) errx(1, "ramtron already mounted"); if (!attached) ramtron_attach(); /* start NXFFS */ ret = nxffs_initialize(ramtron_mtd); if (ret < 0) errx(1, "failed to initialize NXFFS - erase ramtron to reformat"); /* mount the ramtron */ ret = mount(NULL, "/ramtron", "nxffs", 0, NULL); if (ret < 0) errx(1, "failed to mount /ramtron - erase ramtron to reformat"); started = true; warnx("mounted ramtron at /ramtron"); exit(0); }
int nsh_archinitialize(void) { #ifdef HAVE_SST25 FAR struct spi_dev_s *spi; FAR struct mtd_dev_s *mtd; int ret; /* Get the SPI port */ spi = up_spiinitialize(2); if (!spi) { fdbg("ERROR: Failed to initialize SPI port 2\n"); return -ENODEV; } /* Now bind the SPI interface to the SST 25 SPI FLASH driver */ mtd = sst25_initialize(spi); if (!mtd) { fdbg("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(CONFIG_NSH_MMCSDMINOR, mtd); if (ret < 0) { fdbg("ERROR: Initialize the FTL layer\n"); return ret; } #else /* Initialize to provide NXFFS on the MTD interface */ ret = nxffs_initialize(mtd); if (ret < 0) { fdbg("ERROR: NXFFS initialization failed: %d\n", -ret); return ret; } /* Mount the file system at /mnt/sst25 */ ret = mount(NULL, "/mnt/sst25", "nxffs", 0, NULL); if (ret < 0) { fdbg("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #endif #endif return OK; }
int sam_nand_automount(int minor) { FAR struct mtd_dev_s *mtd; static bool initialized = false; int ret; /* Have we already initialized? */ if (!initialized) { /* Create and initialize an NAND MATD device */ mtd = sam_nand_initialize(HSMC_CS3); if (!mtd) { ferr("ERROR: Failed to create the NAND driver on CS%d\n", HSMC_CS3); return -ENODEV; } #if defined(CONFIG_SAMA5D4EK_NAND_FTL) /* Use the FTL layer to wrap the MTD driver as a block driver */ ret = ftl_initialize(NAND_MINOR, mtd); if (ret < 0) { ferr("ERROR: Failed to initialize the FTL layer: %d\n", ret); return ret; } #elif defined(CONFIG_SAMA5D4EK_NAND_NXFFS) /* 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/nand */ ret = mount(NULL, "/mnt/nand", "nxffs", 0, NULL); if (ret < 0) { ferr("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #endif /* Now we are initialized */ initialized = true; } return OK; }
static int nsh_spifi_initialize(void) { FAR struct mtd_dev_s *mtd; int ret; /* Initialize the SPIFI interface and create the MTD driver instance */ mtd = lpc43_spifi_initialize(); if (!mtd) { fdbg("ERROR: lpc43_spifi_initialize failed\n"); return -ENODEV; } #ifndef CONFIG_SPFI_NXFFS /* And finally, use the FTL layer to wrap the MTD driver as a block driver */ ret = ftl_initialize(CONFIG_SPIFI_DEVNO, mtd); if (ret < 0) { fdbg("ERROR: Initializing the FTL layer: %d\n", ret); return ret; } #else /* Initialize to provide NXFFS on the MTD interface */ ret = nxffs_initialize(mtd); if (ret < 0) { fdbg("ERROR: NXFFS initialization failed: %d\n", ret); return ret; } /* Mount the file system at /mnt/spifi */ ret = mount(NULL, "/mnt/spifi", "nxffs", 0, NULL); if (ret < 0) { fdbg("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #endif return OK; }
int sam_at25_automount(int minor) { FAR struct spi_dev_s *spi; FAR struct mtd_dev_s *mtd; static bool initialized = false; int ret; /* Have we already initialized? */ if (!initialized) { /* No.. Get the SPI port driver */ spi = sam_spibus_initialize(AT25_PORT); if (!spi) { ferr("ERROR: Failed to initialize SPI port %d\n", AT25_PORT); return -ENODEV; } /* Now bind the SPI interface to the AT25 SPI FLASH driver */ mtd = at25_initialize(spi); if (!mtd) { ferr("ERROR: Failed to bind SPI port %d to the AT25 FLASH driver\n"); return -ENODEV; } #if defined(CONFIG_SAMA5D3XPLAINED_AT25_FTL) /* And finally, use the FTL layer to wrap the MTD driver as a block driver */ ret = ftl_initialize(AT25_MINOR, mtd); if (ret < 0) { ferr("ERROR: Failed to initialize the FTL layer: %d\n", ret); return ret; } #elif defined(CONFIG_SAMA5D3XPLAINED_AT25_NXFFS) /* 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/at25 */ ret = mount(NULL, "/mnt/at25", "nxffs", 0, NULL); if (ret < 0) { ferr("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #endif /* Now we are initializeed */ initialized = true; } return OK; }
int board_app_initialize(uintptr_t arg) { #ifdef HAVE_RTC_DRIVER FAR struct rtc_lowerhalf_s *rtclower; #endif #if defined(HAVE_N25QXXX) FAR struct mtd_dev_s *mtd_temp; #endif #if defined(HAVE_N25QXXX_CHARDEV) char blockdev[18]; char chardev[12]; #endif int ret; (void)ret; #ifdef HAVE_PROC /* mount the proc filesystem */ syslog(LOG_INFO, "Mounting procfs to /proc\n"); ret = mount(NULL, CONFIG_NSH_PROC_MOUNTPOINT, "procfs", 0, NULL); if (ret < 0) { syslog(LOG_ERR, "ERROR: Failed to mount the PROC filesystem: %d (%d)\n", ret, errno); return ret; } #endif #ifdef HAVE_RTC_DRIVER /* Instantiate the STM32 lower-half RTC driver */ rtclower = stm32l4_rtc_lowerhalf(); if (!rtclower) { serr("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, rtclower); if (ret < 0) { serr("ERROR: Failed to bind/register the RTC driver: %d\n", ret); return ret; } } #endif #ifdef HAVE_N25QXXX /* Create an instance of the STM32L4 QSPI device driver */ g_qspi = stm32l4_qspi_initialize(0); if (!g_qspi) { _err("ERROR: stm32l4_qspi_initialize failed\n"); return ret; } else { /* Use the QSPI device instance to initialize the * N25QXXX device. */ mtd_temp = n25qxxx_initialize(g_qspi, true); if (!mtd_temp) { _err("ERROR: n25qxxx_initialize failed\n"); return ret; } g_mtd_fs = mtd_temp; #ifdef CONFIG_MTD_PARTITION { FAR struct mtd_geometry_s geo; off_t nblocks; /* Setup a partition of 256KiB for our file system. */ ret = MTD_IOCTL(g_mtd_fs, MTDIOC_GEOMETRY, (unsigned long)(uintptr_t)&geo); if (ret < 0) { _err("ERROR: MTDIOC_GEOMETRY failed\n"); return ret; } nblocks = (256*1024) / geo.blocksize; mtd_temp = mtd_partition(g_mtd_fs, 0, nblocks); if (!mtd_temp) { _err("ERROR: mtd_partition failed\n"); return ret; } g_mtd_fs = mtd_temp; } #endif #ifdef HAVE_N25QXXX_SMARTFS /* Configure the device with no partition support */ ret = smart_initialize(N25QXXX_SMART_MINOR, g_mtd_fs, NULL); if (ret != OK) { _err("ERROR: Failed to initialize SmartFS: %d\n", ret); } #elif defined(HAVE_N25QXXX_NXFFS) /* Initialize to provide NXFFS on the N25QXXX MTD interface */ ret = nxffs_initialize(g_mtd_fs); if (ret < 0) { _err("ERROR: NXFFS initialization failed: %d\n", ret); } /* Mount the file system at /mnt/nxffs */ ret = mount(NULL, "/mnt/nxffs", "nxffs", 0, NULL); if (ret < 0) { _err("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #else /* if defined(HAVE_N25QXXX_CHARDEV) */ /* Use the FTL layer to wrap the MTD driver as a block driver */ ret = ftl_initialize(N25QXXX_MTD_MINOR, g_mtd_fs); if (ret < 0) { _err("ERROR: Failed to initialize the FTL layer: %d\n", ret); return ret; } /* Use the minor number to create device paths */ snprintf(blockdev, 18, "/dev/mtdblock%d", N25QXXX_MTD_MINOR); snprintf(chardev, 12, "/dev/mtd%d", N25QXXX_MTD_MINOR); /* Now create a character device on the block device */ /* NOTE: for this to work, you will need to make sure that * CONFIG_FS_WRITABLE is set in the config. It's not a user- * visible setting, but you can make it set by selecting an * arbitrary writable file system (you don't have to actually * use it, just select it so that the block device created via * ftl_initialize() will be writable). */ ret = bchdev_register(blockdev, chardev, false); if (ret < 0) { _err("ERROR: bchdev_register %s failed: %d\n", chardev, ret); return ret; } #endif } #endif #ifdef HAVE_USBHOST /* Initialize USB host operation. stm32l4_usbhost_initialize() starts a thread * will monitor for USB connection and disconnection events. */ ret = stm32l4_usbhost_initialize(); if (ret != OK) { udbg("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) { udbg("ERROR: Failed to start USB monitor: %d\n", ret); return ret; } #endif return OK; }
int stm32_at24_automount(int minor) { FAR struct i2c_master_s *i2c; FAR struct mtd_dev_s *mtd; static bool initialized = false; int ret; /* Have we already initialized? */ if (!initialized) { /* No.. Get the I2C bus driver */ finfo("Initialize I2C%d\n", AT24_I2C_BUS); i2c = stm32_i2cbus_initialize(AT24_I2C_BUS); if (!i2c) { ferr("ERROR: Failed to initialize I2C%d\n", AT24_I2C_BUS); return -ENODEV; } /* Now bind the I2C interface to the AT24 I2C EEPROM driver */ finfo("Bind the AT24 EEPROM driver to I2C%d\n", AT24_I2C_BUS); mtd = at24c_initialize(i2c); if (!mtd) { ferr("ERROR: Failed to bind TWI%d to the AT24 EEPROM driver\n", AT24_I2C_BUS); return -ENODEV; } #if defined(CONFIG_STM32F103MINIMUM_AT24_FTL) /* And finally, use the FTL layer to wrap the MTD driver as a block driver */ finfo("Initialize the FTL layer to create /dev/mtdblock%d\n", AT24_MINOR); ret = ftl_initialize(AT24_MINOR, mtd); if (ret < 0) { ferr("ERROR: Failed to initialize the FTL layer: %d\n", ret); return ret; } #elif defined(CONFIG_STM32F103MINIMUM_AT24_NXFFS) /* Initialize to provide NXFFS on the MTD interface */ finfo("Initialize the NXFFS file system\n"); ret = nxffs_initialize(mtd); if (ret < 0) { ferr("ERROR: NXFFS initialization failed: %d\n", ret); return ret; } /* Mount the file system at /mnt/at24 */ finfo("Mount the NXFFS file system at /dev/at24\n"); ret = mount(NULL, "/mnt/at24", "nxffs", 0, NULL); if (ret < 0) { ferr("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #endif /* Now we are initialized */ initialized = true; } return OK; }
int nxffs_main(int argc, char *argv[]) { FAR struct mtd_dev_s *mtd; unsigned int i; int ret; /* Seed the random number generated */ srand(0x93846); /* Create and initialize a RAM MTD device instance */ #ifdef CONFIG_EXAMPLES_NXFFS_ARCHINIT mtd = nxffs_archinitialize(); #else mtd = rammtd_initialize(g_simflash, EXAMPLES_NXFFS_BUFSIZE); #endif if (!mtd) { message("ERROR: Failed to create RAM MTD instance\n"); msgflush(); exit(1); } /* Initialize to provide NXFFS on an MTD interface */ ret = nxffs_initialize(mtd); if (ret < 0) { message("ERROR: NXFFS initialization failed: %d\n", -ret); msgflush(); exit(2); } /* Mount the file system */ ret = mount(NULL, CONFIG_EXAMPLES_NXFFS_MOUNTPT, "nxffs", 0, NULL); if (ret < 0) { message("ERROR: Failed to mount the NXFFS volume: %d\n", errno); msgflush(); exit(3); } /* Set up memory monitoring */ #ifdef CONFIG_CAN_PASS_STRUCTS g_mmbefore = mallinfo(); g_mmprevious = g_mmbefore; #else (void)mallinfo(&g_mmbefore); memcpy(&g_mmprevious, &g_mmbefore, sizeof(struct mallinfo)); #endif /* Loop a few times ... file the file system with some random, files, * delete some files randomly, fill the file system with more random file, * delete, etc. This beats the FLASH very hard! */ #if CONFIG_EXAMPLES_NXFFS_NLOOPS == 0 for (i = 0; ; i++) #else for (i = 1; i <= CONFIG_EXAMPLES_NXFFS_NLOOPS; i++) #endif { /* Write a files to the NXFFS file system until either (1) all of the * open file structures are utilized or until (2) NXFFS reports an error * (hopefully that the file system is full) */ message("\n=== FILLING %u =============================\n", i); (void)nxffs_fillfs(); message("Filled file system\n"); message(" Number of files: %d\n", g_nfiles); message(" Number deleted: %d\n", g_ndeleted); nxffs_dump(mtd, CONFIG_EXAMPLES_NXFFS_VERBOSE); /* Directory listing */ nxffs_directory(); /* Verify all files written to FLASH */ ret = nxffs_verifyfs(); if (ret < 0) { message("ERROR: Failed to verify files\n"); message(" Number of files: %d\n", g_nfiles); message(" Number deleted: %d\n", g_ndeleted); } else { #if CONFIG_EXAMPLES_NXFFS_VERBOSE != 0 message("Verified!\n"); message(" Number of files: %d\n", g_nfiles); message(" Number deleted: %d\n", g_ndeleted); #endif } /* Delete some files */ message("\n=== DELETING %u ============================\n", i); ret = nxffs_delfiles(); if (ret < 0) { message("ERROR: Failed to delete files\n"); message(" Number of files: %d\n", g_nfiles); message(" Number deleted: %d\n", g_ndeleted); } else { message("Deleted some files\n"); message(" Number of files: %d\n", g_nfiles); message(" Number deleted: %d\n", g_ndeleted); } nxffs_dump(mtd, CONFIG_EXAMPLES_NXFFS_VERBOSE); /* Directory listing */ nxffs_directory(); /* Verify all files written to FLASH */ ret = nxffs_verifyfs(); if (ret < 0) { message("ERROR: Failed to verify files\n"); message(" Number of files: %d\n", g_nfiles); message(" Number deleted: %d\n", g_ndeleted); } else { #if CONFIG_EXAMPLES_NXFFS_VERBOSE != 0 message("Verified!\n"); message(" Number of files: %d\n", g_nfiles); message(" Number deleted: %d\n", g_ndeleted); #endif } /* Show memory usage */ nxffs_loopmemusage(); msgflush(); } /* Delete all files then show memory usage again */ nxffs_delallfiles(); nxffs_endmemusage(); msgflush(); return 0; }
int sam_bringup(void) { #ifdef HAVE_S25FL1 FAR struct qspi_dev_s *qspi; #endif #if defined(HAVE_S25FL1) || defined(HAVE_PROGMEM_CHARDEV) FAR struct mtd_dev_s *mtd; #endif #if defined(HAVE_RTC_DSXXXX) || defined(HAVE_RTC_PCF85263) FAR struct i2c_master_s *i2c; #endif #if defined(HAVE_S25FL1_CHARDEV) || defined(HAVE_PROGMEM_CHARDEV) char blockdev[18]; char chardev[12]; #endif int ret; /* Register I2C drivers on behalf of the I2C tool */ sam_i2ctool(); #if defined(HAVE_RTC_PCF85263) /* Get an instance of the TWIHS0 I2C interface */ i2c = sam_i2cbus_initialize(PCF85263_TWI_BUS); if (i2c == NULL) { SYSLOG("ERROR: sam_i2cbus_initialize(%d) failed\n", PCF85263_TWI_BUS); } else { /* Use the I2C interface to initialize the PCF2863 timer */ ret = pcf85263_rtc_initialize(i2c); if (ret < 0) { SYSLOG("ERROR: pcf85263_rtc_initialize() failed: %d\n", ret); } else { /* Synchronize the system time to the RTC time */ clock_synchronize(); } } #elif defined(HAVE_RTC_DSXXXX) /* Get an instance of the TWIHS0 I2C interface */ i2c = sam_i2cbus_initialize(DSXXXX_TWI_BUS); if (i2c == NULL) { SYSLOG("ERROR: sam_i2cbus_initialize(%d) failed\n", DSXXXX_TWI_BUS); } else { /* Use the I2C interface to initialize the DSXXXX timer */ ret = dsxxxx_rtc_initialize(i2c); if (ret < 0) { SYSLOG("ERROR: dsxxxx_rtc_initialize() failed: %d\n", ret); } else { /* Synchronize the system time to the RTC time */ clock_synchronize(); } } #endif #ifdef HAVE_MACADDR /* Read the Ethernet MAC address from the AT24 FLASH and configure the * Ethernet driver with that address. */ ret = sam_emac0_setmac(); if (ret < 0) { SYSLOG("ERROR: sam_emac0_setmac() failed: %d\n", ret); } #endif #ifdef CONFIG_FS_PROCFS /* Mount the procfs file system */ ret = mount(NULL, SAMV71_PROCFS_MOUNTPOINT, "procfs", 0, NULL); if (ret < 0) { SYSLOG("ERROR: Failed to mount procfs at %s: %d\n", SAMV71_PROCFS_MOUNTPOINT, ret); } #endif #ifdef HAVE_MTDCONFIG /* Create an AT24xx-based MTD configuration device for storage device * configuration information. */ ret = sam_at24config(); if (ret < 0) { SYSLOG("ERROR: sam_at24config() failed: %d\n", ret); } #endif #ifdef HAVE_HSMCI /* Initialize the HSMCI0 driver */ ret = sam_hsmci_initialize(HSMCI0_SLOTNO, HSMCI0_MINOR); if (ret < 0) { SYSLOG("ERROR: sam_hsmci_initialize(%d,%d) failed: %d\n", HSMCI0_SLOTNO, HSMCI0_MINOR, ret); } #ifdef CONFIG_SAMV71XULT_HSMCI0_MOUNT else { /* REVISIT: A delay seems to be required here or the mount will fail. */ /* Mount the volume on HSMCI0 */ ret = mount(CONFIG_SAMV71XULT_HSMCI0_MOUNT_BLKDEV, CONFIG_SAMV71XULT_HSMCI0_MOUNT_MOUNTPOINT, CONFIG_SAMV71XULT_HSMCI0_MOUNT_FSTYPE, 0, NULL); if (ret < 0) { SYSLOG("ERROR: Failed to mount %s: %d\n", CONFIG_SAMV71XULT_HSMCI0_MOUNT_MOUNTPOINT, errno); } } #endif /* CONFIG_SAMV71XULT_HSMCI0_MOUNT */ #endif /* HAVE_HSMCI */ #ifdef HAVE_AUTOMOUNTER /* Initialize the auto-mounter */ sam_automount_initialize(); #endif #ifdef HAVE_ROMFS /* Create a ROM disk for the /etc filesystem */ ret = romdisk_register(CONFIG_SAMV71XULT_ROMFS_ROMDISK_MINOR, romfs_img, NSECTORS(romfs_img_len), CONFIG_SAMV71XULT_ROMFS_ROMDISK_SECTSIZE); if (ret < 0) { SYSLOG("ERROR: romdisk_register failed: %d\n", -ret); } else { /* Mount the file system */ ret = mount(CONFIG_SAMV71XULT_ROMFS_ROMDISK_DEVNAME, CONFIG_SAMV71XULT_ROMFS_MOUNT_MOUNTPOINT, "romfs", MS_RDONLY, NULL); if (ret < 0) { SYSLOG("ERROR: mount(%s,%s,romfs) failed: %d\n", CONFIG_SAMV71XULT_ROMFS_ROMDISK_DEVNAME, CONFIG_SAMV71XULT_ROMFS_MOUNT_MOUNTPOINT, errno); } } #endif #ifdef HAVE_S25FL1 /* Create an instance of the SAMV71 QSPI device driver */ qspi = sam_qspi_initialize(0); if (!qspi) { SYSLOG("ERROR: sam_qspi_initialize failed\n"); } else { /* Use the QSPI device instance to initialize the * S25FL1 device. */ mtd = s25fl1_initialize(qspi, true); if (!mtd) { SYSLOG("ERROR: s25fl1_initialize failed\n"); } #ifdef HAVE_S25FL1_SMARTFS /* Configure the device with no partition support */ ret = smart_initialize(S25FL1_SMART_MINOR, mtd, NULL); if (ret != OK) { SYSLOG("ERROR: Failed to initialize SmartFS: %d\n", ret); } #elif defined(HAVE_S25FL1_NXFFS) /* Initialize to provide NXFFS on the S25FL1 MTD interface */ ret = nxffs_initialize(mtd); if (ret < 0) { SYSLOG("ERROR: NXFFS initialization failed: %d\n", ret); } /* Mount the file system at /mnt/s25fl1 */ ret = mount(NULL, "/mnt/s25fl1", "nxffs", 0, NULL); if (ret < 0) { SYSLOG("ERROR: Failed to mount the NXFFS volume: %d\n", errno); return ret; } #else /* if defined(HAVE_S25FL1_CHARDEV) */ /* Use the FTL layer to wrap the MTD driver as a block driver */ ret = ftl_initialize(S25FL1_MTD_MINOR, mtd); if (ret < 0) { SYSLOG("ERROR: Failed to initialize the FTL layer: %d\n", ret); return ret; } /* Use the minor number to create device paths */ snprintf(blockdev, 18, "/dev/mtdblock%d", S25FL1_MTD_MINOR); snprintf(chardev, 12, "/dev/mtd%d", S25FL1_MTD_MINOR); /* Now create a character device on the block device */ ret = bchdev_register(blockdev, chardev, false); if (ret < 0) { SYSLOG("ERROR: bchdev_register %s failed: %d\n", chardev, ret); return ret; } #endif } #endif #ifdef HAVE_PROGMEM_CHARDEV /* Initialize the SAMV71 FLASH programming memory library */ sam_progmem_initialize(); /* Create an instance of the SAMV71 FLASH program memory device driver */ mtd = progmem_initialize(); if (!mtd) { SYSLOG("ERROR: progmem_initialize failed\n"); } /* Use the FTL layer to wrap the MTD driver as a block driver */ ret = ftl_initialize(PROGMEM_MTD_MINOR, mtd); if (ret < 0) { SYSLOG("ERROR: Failed to initialize the FTL layer: %d\n", ret); return ret; } /* Use the minor number to create device paths */ snprintf(blockdev, 18, "/dev/mtdblock%d", PROGMEM_MTD_MINOR); snprintf(chardev, 12, "/dev/mtd%d", PROGMEM_MTD_MINOR); /* Now create a character device on the block device */ ret = bchdev_register(blockdev, chardev, false); if (ret < 0) { SYSLOG("ERROR: bchdev_register %s failed: %d\n", chardev, ret); return ret; } #endif #ifdef HAVE_USBHOST /* Initialize USB host operation. sam_usbhost_initialize() starts a thread * will monitor for USB connection and disconnection events. */ ret = sam_usbhost_initialize(); if (ret != OK) { SYSLOG("ERROR: Failed to initialize USB host: %d\n", ret); } #endif #ifdef HAVE_USBMONITOR /* Start the USB Monitor */ ret = usbmonitor_start(0, NULL); if (ret != OK) { SYSLOG("ERROR: Failed to start the USB monitor: %d\n", ret); } #endif #ifdef HAVE_WM8904 /* Configure WM8904 audio */ ret = sam_wm8904_initialize(0); if (ret != OK) { SYSLOG("ERROR: Failed to initialize WM8904 audio: %d\n", ret); } #endif #ifdef HAVE_AUDIO_NULL /* Configure the NULL audio device */ ret = sam_audio_null_initialize(0); if (ret != OK) { SYSLOG("ERROR: Failed to initialize the NULL audio device: %d\n", ret); } #endif #ifdef HAVE_ELF /* Initialize the ELF binary loader */ SYSLOG("Initializing the ELF binary loader\n"); ret = elf_initialize(); if (ret < 0) { SYSLOG("ERROR: Initialization of the ELF loader failed: %d\n", ret); } #endif /* If we got here then perhaps not all initialization was successful, but * at least enough succeeded to bring-up NSH with perhaps reduced * capabilities. */ UNUSED(ret); return OK; }