int mtdpart_main(int argc, char *argv[]) { FAR struct mtd_dev_s *master; FAR struct mtd_dev_s *part[CONFIG_EXAMPLES_MTDPART_NPARTITIONS]; FAR struct mtd_geometry_s geo; FAR uint32_t *buffer; char blockname[32]; char charname[32]; size_t partsize; ssize_t nbytes; off_t nblocks; off_t offset; off_t check; off_t sectoff; off_t seekpos; unsigned int blkpererase; int fd; int i; int j; int k; int ret; /* Create and initialize a RAM MTD FLASH driver instance */ #ifdef CONFIG_EXAMPLES_MTDPART_ARCHINIT master = mtdpart_archinitialize(); #else master = rammtd_initialize(g_simflash, MTDPART_BUFSIZE); #endif if (!master) { message("ERROR: Failed to create RAM MTD instance\n"); msgflush(); exit(1); } /* Perform the IOCTL to erase the entire FLASH part */ ret = master->ioctl(master, MTDIOC_BULKERASE, 0); if (ret < 0) { message("ERROR: MTDIOC_BULKERASE ioctl failed: %d\n", ret); } /* Initialize to provide an FTL block driver on the MTD FLASH interface. * * NOTE: We could just skip all of this FTL and BCH stuff. We could * instead just use the MTD drivers bwrite and bread to perform this * test. Creating the character drivers, however, makes this test more * interesting. */ ret = ftl_initialize(0, master); if (ret < 0) { message("ERROR: ftl_initialize /dev/mtdblock0 failed: %d\n", ret); msgflush(); exit(2); } /* Now create a character device on the block device */ ret = bchdev_register("/dev/mtdblock0", "/dev/mtd0", false); if (ret < 0) { message("ERROR: bchdev_register /dev/mtd0 failed: %d\n", ret); msgflush(); exit(3); } /* Get the geometry of the FLASH device */ ret = master->ioctl(master, MTDIOC_GEOMETRY, (unsigned long)((uintptr_t)&geo)); if (ret < 0) { fdbg("ERROR: mtd->ioctl failed: %d\n", ret); exit(3); } message("Flash Geometry:\n"); message(" blocksize: %lu\n", (unsigned long)geo.blocksize); message(" erasesize: %lu\n", (unsigned long)geo.erasesize); message(" neraseblocks: %lu\n", (unsigned long)geo.neraseblocks); /* Determine the size of each partition. Make each partition an even * multiple of the erase block size (perhaps not using some space at the * end of the FLASH). */ blkpererase = geo.erasesize / geo.blocksize; nblocks = (geo.neraseblocks / CONFIG_EXAMPLES_MTDPART_NPARTITIONS) * blkpererase; partsize = nblocks * geo.blocksize; message(" No. partitions: %u\n", CONFIG_EXAMPLES_MTDPART_NPARTITIONS); message(" Partition size: %lu Blocks (%lu bytes)\n", nblocks, partsize); /* Now create MTD FLASH partitions */ message("Creating partitions\n"); for (offset = 0, i = 1; i <= CONFIG_EXAMPLES_MTDPART_NPARTITIONS; offset += nblocks, i++) { message(" Partition %d. Block offset=%lu, size=%lu\n", i, (unsigned long)offset, (unsigned long)nblocks); /* Create the partition */ part[i] = mtd_partition(master, offset, nblocks); if (!part[i]) { message("ERROR: mtd_partition failed. offset=%lu nblocks=%lu\n", (unsigned long)offset, (unsigned long)nblocks); msgflush(); exit(4); } /* Initialize to provide an FTL block driver on the MTD FLASH interface */ snprintf(blockname, 32, "/dev/mtdblock%d", i); snprintf(charname, 32, "/dev/mtd%d", i); ret = ftl_initialize(i, part[i]); if (ret < 0) { message("ERROR: ftl_initialize %s failed: %d\n", blockname, ret); msgflush(); exit(5); } /* Now create a character device on the block device */ ret = bchdev_register(blockname, charname, false); if (ret < 0) { message("ERROR: bchdev_register %s failed: %d\n", charname, ret); msgflush(); exit(6); } } /* Allocate a buffer */ buffer = (FAR uint32_t *)malloc(geo.blocksize); if (!buffer) { message("ERROR: failed to allocate a sector buffer\n"); msgflush(); exit(7); } /* Open the master MTD FLASH character driver for writing */ fd = open("/dev/mtd0", O_WRONLY); if (fd < 0) { message("ERROR: open /dev/mtd0 failed: %d\n", errno); msgflush(); exit(8); } /* Now write the offset into every block */ message("Initializing media:\n"); offset = 0; for (i = 0; i < geo.neraseblocks; i++) { for (j = 0; j < blkpererase; j++) { /* Fill the block with the offset */ for (k = 0; k < geo.blocksize / sizeof(uint32_t); k++) { buffer[k] = offset; offset += 4; } /* And write it using the character driver */ nbytes = write(fd, buffer, geo.blocksize); if (nbytes < 0) { message("ERROR: write to /dev/mtd0 failed: %d\n", errno); msgflush(); exit(9); } } } close(fd); /* Now read each partition */ message("Checking partitions:\n"); for (offset = 0, i = 1; i <= CONFIG_EXAMPLES_MTDPART_NPARTITIONS; offset += partsize, i++) { message(" Partition %d. Byte offset=%lu, size=%lu\n", i, (unsigned long)offset, (unsigned long)partsize); /* Open the master MTD partition character driver for writing */ snprintf(charname, 32, "/dev/mtd%d", i); fd = open(charname, O_RDWR); if (fd < 0) { message("ERROR: open %s failed: %d\n", charname, errno); msgflush(); exit(10); } /* Now verify the offset in every block */ check = offset; sectoff = 0; for (j = 0; j < nblocks; j++) { #if 0 /* Too much */ message(" block=%u offset=%lu\n", j, (unsigned long) check); #endif /* Seek to the next read position */ seekpos = lseek(fd, sectoff, SEEK_SET); if (seekpos != sectoff) { message("ERROR: lseek to offset %ld failed: %d\n", (unsigned long)sectoff, errno); msgflush(); exit(11); } /* Read the next block into memory */ nbytes = read(fd, buffer, geo.blocksize); if (nbytes < 0) { message("ERROR: read from %s failed: %d\n", charname, errno); msgflush(); exit(12); } else if (nbytes == 0) { message("ERROR: Unexpected end-of file in %s\n", charname); msgflush(); exit(13); } else if (nbytes != geo.blocksize) { message("ERROR: Unexpected read size from %s: %ld\n", charname, (unsigned long)nbytes); msgflush(); exit(14); } /* Since we forced the size of the partition to be an even number * of erase blocks, we do not expect to encounter the end of file * indication. */ else if (nbytes == 0) { message("ERROR: Unexpected end of file on %s\n", charname); msgflush(); exit(15); } /* This is not expected at all */ else if (nbytes != geo.blocksize) { message("ERROR: Short read from %s failed: %lu\n", charname, (unsigned long)nbytes); msgflush(); exit(16); } /* Verfy the offsets in the block */ for (k = 0; k < geo.blocksize / sizeof(uint32_t); k++) { if (buffer[k] != check) { message("ERROR: Bad offset %lu, expected %lu\n", (long)buffer[k], (long)check); msgflush(); exit(17); } /* Invert the value to indicate that we have verified * this value. */ buffer[k] = ~check; check += sizeof(uint32_t); } /* Seek to the next write position */ seekpos = lseek(fd, sectoff, SEEK_SET); if (seekpos != sectoff) { message("ERROR: lseek to offset %ld failed: %d\n", (unsigned long)sectoff, errno); msgflush(); exit(18); } /* Now write the block back to FLASH with the modified value */ nbytes = write(fd, buffer, geo.blocksize); if (nbytes < 0) { message("ERROR: write to %s failed: %d\n", charname, errno); msgflush(); exit(19); } else if (nbytes != geo.blocksize) { message("ERROR: Unexpected write size to %s: %ld\n", charname, (unsigned long)nbytes); msgflush(); exit(20); } /* Get the offset to the next block */ sectoff += geo.blocksize; } /* Try reading one more time. We should get the end of file */ nbytes = read(fd, buffer, geo.blocksize); if (nbytes != 0) { message("ERROR: Expected end-of-file from %s failed: %d %d\n", charname, nbytes, errno); msgflush(); exit(22); } close(fd); } /* Now verify that all of the verifed blocks appear where we thing they * should on the device. */ message("Verfying media:\n"); fd = open("/dev/mtd0", O_RDONLY); if (fd < 0) { message("ERROR: open /dev/mtd0 failed: %d\n", errno); msgflush(); exit(23); } offset = 0; check = 0; for (i = 0; i < nblocks * CONFIG_EXAMPLES_MTDPART_NPARTITIONS; i++) { /* Read the next block into memory */ nbytes = read(fd, buffer, geo.blocksize); if (nbytes < 0) { message("ERROR: read from %s failed: %d\n", charname, errno); msgflush(); exit(24); } else if (nbytes == 0) { message("ERROR: Unexpected end-of file in %s\n", charname); msgflush(); exit(25); } else if (nbytes != geo.blocksize) { message("ERROR: Unexpected read size from %s: %ld\n", charname, (unsigned long)nbytes); msgflush(); exit(26); } /* Verfy the values in the block */ for (k = 0; k < geo.blocksize / sizeof(uint32_t); k++) { if (buffer[k] != ~check) { message("ERROR: Bad value %lu, expected %lu\n", (long)buffer[k], (long)(~check)); msgflush(); exit(27); } check += sizeof(uint32_t); } } close(fd); /* And exit without bothering to clean up */ message("PASS: Everything looks good\n"); msgflush(); return 0; }
static void mtd_start(char *partition_names[], unsigned n_partitions) { int ret; if (started) errx(1, "mtd already mounted"); if (!attached) { #ifdef CONFIG_ARCH_BOARD_PX4FMU_V1 at24xxx_attach(); #else #if defined(CONFIG_ARCH_BOARD_AERODROID) #ifdef CONFIG_RAMTRON_FUJITSU ramtron_attach(); #else spansion_attach(); #endif #else ramtron_attach(); #endif #endif } if (!mtd_dev) { warnx("ERROR: Failed to create RAMTRON FRAM MTD instance"); exit(1); } unsigned long blocksize, erasesize, neraseblocks; unsigned blkpererase, nblocks, partsize; ret = mtd_get_geometry(&blocksize, &erasesize, &neraseblocks, &blkpererase, &nblocks, &partsize, n_partitions); if (ret) exit(3); /* Now create MTD FLASH partitions */ FAR struct mtd_dev_s *part[n_partitions]; char blockname[32]; unsigned offset; unsigned i; for (offset = 0, i = 0; i < n_partitions; offset += nblocks, i++) { /* Create the partition */ part[i] = mtd_partition(mtd_dev, offset, nblocks); if (!part[i]) { warnx("ERROR: mtd_partition failed. offset=%lu nblocks=%lu", (unsigned long)offset, (unsigned long)nblocks); exit(4); } /* Initialize to provide an FTL block driver on the MTD FLASH interface */ snprintf(blockname, sizeof(blockname), "/dev/mtdblock%d", i); ret = ftl_initialize(i, part[i]); if (ret < 0) { warnx("ERROR: ftl_initialize %s failed: %d", blockname, ret); exit(5); } /* Now create a character device on the block device */ ret = bchdev_register(blockname, partition_names[i], false); if (ret < 0) { warnx("ERROR: bchdev_register %s failed: %d", partition_names[i], ret); exit(6); } } n_partitions_current = n_partitions; started = true; exit(0); }
int sam_bringup(void) { #ifdef HAVE_PROGMEM_CHARDEV FAR struct mtd_dev_s *mtd; char blockdev[18]; char chardev[12]; #endif int ret; /* Register I2C drivers on behalf of the I2C tool */ sam_i2ctool(); #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(LOG_ERR, "ERROR: sam_emac0_setmac() failed: %d\n", ret); } #endif #ifdef CONFIG_FS_PROCFS /* Mount the procfs file system */ ret = mount(NULL, SAME70_PROCFS_MOUNTPOINT, "procfs", 0, NULL); if (ret < 0) { syslog(LOG_ERR, "ERROR: Failed to mount procfs at %s: %d\n", SAME70_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(LOG_ERR, "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(LOG_ERR, "ERROR: sam_hsmci_initialize(%d,%d) failed: %d\n", HSMCI0_SLOTNO, HSMCI0_MINOR, ret); } #ifdef CONFIG_SAME70XPLAINED_HSMCI0_MOUNT else { /* REVISIT: A delay seems to be required here or the mount will fail. */ /* Mount the volume on HSMCI0 */ ret = mount(CONFIG_SAME70XPLAINED_HSMCI0_MOUNT_BLKDEV, CONFIG_SAME70XPLAINED_HSMCI0_MOUNT_MOUNTPOINT, CONFIG_SAME70XPLAINED_HSMCI0_MOUNT_FSTYPE, 0, NULL); if (ret < 0) { syslog(LOG_ERR, "ERROR: Failed to mount %s: %d\n", CONFIG_SAME70XPLAINED_HSMCI0_MOUNT_MOUNTPOINT, errno); } } #endif /* CONFIG_SAME70XPLAINED_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_SAME70XPLAINED_ROMFS_ROMDISK_MINOR, romfs_img, NSECTORS(romfs_img_len), CONFIG_SAME70XPLAINED_ROMFS_ROMDISK_SECTSIZE); if (ret < 0) { syslog(LOG_ERR, "ERROR: romdisk_register failed: %d\n", -ret); } else { /* Mount the file system */ ret = mount(CONFIG_SAME70XPLAINED_ROMFS_ROMDISK_DEVNAME, CONFIG_SAME70XPLAINED_ROMFS_MOUNT_MOUNTPOINT, "romfs", MS_RDONLY, NULL); if (ret < 0) { syslog(LOG_ERR, "ERROR: mount(%s,%s,romfs) failed: %d\n", CONFIG_SAME70XPLAINED_ROMFS_ROMDISK_DEVNAME, CONFIG_SAME70XPLAINED_ROMFS_MOUNT_MOUNTPOINT, errno); } } #endif #ifdef HAVE_PROGMEM_CHARDEV /* Initialize the SAME70 FLASH programming memory library */ sam_progmem_initialize(); /* Create an instance of the SAME70 FLASH program memory device driver */ mtd = progmem_initialize(); if (!mtd) { syslog(LOG_ERR, "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(LOG_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", 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(LOG_ERR, "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(LOG_ERR, "ERROR: Failed to initialize USB host: %d\n", ret); } #endif #ifdef HAVE_USBMONITOR /* Start the USB Monitor */ ret = usbmonitor_start(); if (ret != OK) { syslog(LOG_ERR, "ERROR: Failed to start the USB monitor: %d\n", ret); } #endif #ifdef CONFIG_SAMV7_MCAN /* Initialize CAN and register the CAN driver. */ ret = sam_can_setup(); if (ret < 0) { syslog(LOG_ERR, "ERROR: sam_can_setup failed: %d\n", ret); } #endif #ifdef HAVE_ELF /* Initialize the ELF binary loader */ syslog(LOG_ERR, "Initializing the ELF binary loader\n"); ret = elf_initialize(); if (ret < 0) { syslog(LOG_ERR, "ERROR: Initialization of the ELF loader failed: %d\n", ret); } #endif #if defined(CONFIG_SAMV7_DAC0) || defined(CONFIG_SAMV7_DAC1) ret = sam_dacdev_initialize(); if (ret < 0) { syslog(LOG_ERR, "ERROR: Initialization of the DAC module 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; }
int block_proxy(FAR const char *blkdev, int oflags) { FAR char *chardev; bool readonly; int ret; int fd; DEBUGASSERT(blkdev); /* Create a unique temporary file name for the character device */ chardev = unique_chardev(); if (chardev == NULL) { ferr("ERROR: Failed to create temporary device name\n"); return -ENOMEM; } /* Should this character driver be read-only? */ readonly = ((oflags & O_WROK) == 0); /* Wrap the block driver with an instance of the BCH driver */ ret = bchdev_register(blkdev, chardev, readonly); if (ret < 0) { ferr("ERROR: bchdev_register(%s, %s) failed: %d\n", blkdev, chardev, ret); goto errout_with_chardev; } /* Open the newly created character driver */ oflags &= ~(O_CREAT | O_EXCL | O_APPEND | O_TRUNC); fd = open(chardev, oflags); if (fd < 0) { ret = -errno; ferr("ERROR: Failed to open %s: %d\n", chardev, ret); goto errout_with_bchdev; } /* Unlink the character device name. The driver instance will persist, * provided that CONFIG_DISABLE_PSEUDOFS_OPERATIONS=y (otherwise, we have * a problem here!) */ ret = unlink(chardev); if (ret < 0) { ret = -errno; ferr("ERROR: Failed to unlink %s: %d\n", chardev, ret); } /* Free the allocate character driver name and return the open file * descriptor. */ kmm_free(chardev); return fd; errout_with_bchdev: (void)unlink(chardev); errout_with_chardev: kmm_free(chardev); return ret; }
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 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; }