int nsh_romfsetc(void)
{
int ret;
/* Create a ROM disk for the /etc filesystem */
ret = romdisk_register(CONFIG_NSH_ROMFSDEVNO, romfs_img,
NSECTORS(romfs_img_len), CONFIG_NSH_ROMFSSECTSIZE);
if (ret < 0)
{
dbg("nsh: romdisk_register failed: %d\n", -ret);
return ERROR;
}
/* Mount the file system */
vdbg("Mounting ROMFS filesystem at target=%s with source=%s\n",
CONFIG_NSH_ROMFSMOUNTPT, MOUNT_DEVNAME);
ret = mount(MOUNT_DEVNAME, CONFIG_NSH_ROMFSMOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
dbg("nsh: mount(%s,%s,romfs) failed: %d\n",
MOUNT_DEVNAME, CONFIG_NSH_ROMFSMOUNTPT, errno);
return ERROR;
}
return OK;
}
int bastest_main(int argc, char *argv[])
#endif
{
int ret;
/* Create a ROM disk for the ROMFS filesystem */
printf("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_BASTEST_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_BASTEST_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
fprintf(stderr, "ERROR: romdisk_register failed: %d\n", ret);
return 1;
}
/* Mount the file system */
printf("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_BASTEST_DEVPATH);
ret = mount(CONFIG_EXAMPLES_BASTEST_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
fprintf(stderr, "ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_BASTEST_DEVPATH, MOUNTPT, errno);
return 1;
}
return 0;
}
int romfs_main(int argc, char *argv[])
{
int ret;
/* Create a RAM disk for the test */
ret = romdisk_register(CONFIG_EXAMPLES_ROMFS_RAMDEVNO, testdir_img,
NSECTORS(testdir_img_len), CONFIG_EXAMPLES_ROMFS_SECTORSIZE);
if (ret < 0)
{
printf("ERROR: Failed to create RAM disk\n");
return 1;
}
/* Mount the test file system */
printf("Mounting ROMFS filesystem at target=%s with source=%s\n",
CONFIG_EXAMPLES_ROMFS_MOUNTPOINT, MOUNT_DEVNAME);
ret = mount(MOUNT_DEVNAME, CONFIG_EXAMPLES_ROMFS_MOUNTPOINT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
printf("ERROR: Mount failed: %d\n", errno);
return 1;
}
/* Perform the test */
connectem();
readdirectories(CONFIG_EXAMPLES_ROMFS_MOUNTPOINT, &g_adir);
checkdirectories(&g_adir);
if (g_nerrors)
{
printf("Finished with %d errors\n", g_nerrors);
return g_nerrors;
}
printf("PASSED\n");
return 0;
}
int trv_mount_world(int minor, FAR const char *mountpoint)
{
char devpath[16];
int ret;
/* Create a ROM disk for the ROMFS filesystem */
ret = romdisk_register(minor, (FAR uint8_t *)trv_romfs_img,
NSECTORS(trv_romfs_img_len), SECTORSIZE);
if (ret < 0)
{
return ret;
}
/* Get the ROM disk device name */
snprintf(devpath, 16, "/dev/ram%d", minor);
/* Mount the file system */
ret = mount(devpath, mountpoint, "romfs", MS_RDONLY, NULL);
return ret;
}
int thttp_main(int argc, char *argv[])
#endif
{
struct in_addr addr;
#ifdef CONFIG_EXAMPLES_THTTPD_NOMAC
uint8_t mac[IFHWADDRLEN];
#endif
char *thttpd_argv = "thttpd";
int ret;
/* Configure SLIP */
#ifdef CONFIG_NET_SLIP
ret = slip_initialize(SLIP_DEVNO, CONFIG_NET_SLIPTTY);
if (ret < 0)
{
printf("ERROR: SLIP initialization failed: %d\n", ret);
exit(1);
}
#endif
/* Many embedded network interfaces must have a software assigned MAC */
#ifdef CONFIG_EXAMPLES_THTTPD_NOMAC
printf("Assigning MAC\n");
mac[0] = 0x00;
mac[1] = 0xe0;
mac[2] = 0xde;
mac[3] = 0xad;
mac[4] = 0xbe;
mac[5] = 0xef;
netlib_setmacaddr(NET_DEVNAME, mac);
#endif
/* Set up our host address */
printf("Setup network addresses\n");
addr.s_addr = HTONL(CONFIG_THTTPD_IPADDR);
netlib_sethostaddr(NET_DEVNAME, &addr);
/* Set up the default router address */
addr.s_addr = HTONL(CONFIG_EXAMPLES_THTTPD_DRIPADDR);
netlib_setdraddr(NET_DEVNAME, &addr);
/* Setup the subnet mask */
addr.s_addr = HTONL(CONFIG_EXAMPLES_THTTPD_NETMASK);
netlib_setnetmask(NET_DEVNAME, &addr);
/* Initialize the NXFLAT binary loader */
printf("Initializing the NXFLAT binary loader\n");
ret = nxflat_initialize();
if (ret < 0)
{
printf("ERROR: Initialization of the NXFLAT loader failed: %d\n", ret);
exit(2);
}
/* Create a ROM disk for the ROMFS filesystem */
printf("Registering romdisk\n");
ret = romdisk_register(0, (uint8_t*)romfs_img, NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
printf("ERROR: romdisk_register failed: %d\n", ret);
nxflat_uninitialize();
exit(1);
}
/* Mount the file system */
printf("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, ROMFSDEV);
ret = mount(ROMFSDEV, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
printf("ERROR: mount(%s,%s,romfs) failed: %s\n",
ROMFSDEV, MOUNTPT, errno);
nxflat_uninitialize();
}
/* Start THTTPD. At present, symbol table info is passed via global variables */
g_thttpdsymtab = exports;
g_thttpdnsymbols = NEXPORTS;
printf("Starting THTTPD\n");
fflush(stdout);
thttpd_main(1, &thttpd_argv);
printf("THTTPD terminated\n");
fflush(stdout);
return 0;
}
int sam_bringup(void)
{
int ret;
/* Register I2C drivers on behalf of the I2C tool */
sam_i2ctool();
#ifdef HAVE_NAND
/* Initialize the NAND driver */
ret = sam_nand_automount(NAND_MINOR);
if (ret < 0)
{
_err("ERROR: sam_nand_automount failed: %d\n", ret);
}
#endif
#ifdef HAVE_AT25
/* Initialize the AT25 driver */
ret = sam_at25_automount(AT25_MINOR);
if (ret < 0)
{
_err("ERROR: sam_at25_automount failed: %d\n", ret);
}
#endif
#ifdef HAVE_HSMCI
#ifdef CONFIG_SAMA5_HSMCI0
/* Initialize the HSMCI0 driver */
ret = sam_hsmci_initialize(HSMCI0_SLOTNO, HSMCI0_MINOR);
if (ret < 0)
{
_err("ERROR: sam_hsmci_initialize(%d,%d) failed: %d\n",
HSMCI0_SLOTNO, HSMCI0_MINOR, ret);
}
#ifdef CONFIG_SAMA5D4EK_HSMCI0_MOUNT
else
{
/* REVISIT: A delay seems to be required here or the mount will fail. */
/* Mount the volume on HSMCI0 */
ret = mount(CONFIG_SAMA5D4EK_HSMCI0_MOUNT_BLKDEV,
CONFIG_SAMA5D4EK_HSMCI0_MOUNT_MOUNTPOINT,
CONFIG_SAMA5D4EK_HSMCI0_MOUNT_FSTYPE,
0, NULL);
if (ret < 0)
{
_err("ERROR: Failed to mount %s: %d\n",
CONFIG_SAMA5D4EK_HSMCI0_MOUNT_MOUNTPOINT, errno);
}
}
#endif
#endif
#ifdef CONFIG_SAMA5_HSMCI1
/* Initialize the HSMCI1 driver */
ret = sam_hsmci_initialize(HSMCI1_SLOTNO, HSMCI1_MINOR);
if (ret < 0)
{
_err("ERROR: sam_hsmci_initialize(%d,%d) failed: %d\n",
HSMCI1_SLOTNO, HSMCI1_MINOR, ret);
}
#ifdef CONFIG_SAMA5D4EK_HSMCI1_MOUNT
else
{
/* REVISIT: A delay seems to be required here or the mount will fail. */
/* Mount the volume on HSMCI1 */
ret = mount(CONFIG_SAMA5D4EK_HSMCI1_MOUNT_BLKDEV,
CONFIG_SAMA5D4EK_HSMCI1_MOUNT_MOUNTPOINT,
CONFIG_SAMA5D4EK_HSMCI1_MOUNT_FSTYPE,
0, NULL);
if (ret < 0)
{
_err("ERROR: Failed to mount %s: %d\n",
CONFIG_SAMA5D4EK_HSMCI1_MOUNT_MOUNTPOINT, errno);
}
}
#endif
#endif
#endif
#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_SAMA5D4EK_ROMFS_ROMDISK_MINOR, romfs_img,
NSECTORS(romfs_img_len),
CONFIG_SAMA5D4EK_ROMFS_ROMDISK_SECTSIZE);
if (ret < 0)
{
_err("ERROR: romdisk_register failed: %d\n", -ret);
}
else
{
/* Mount the file system */
ret = mount(CONFIG_SAMA5D4EK_ROMFS_ROMDISK_DEVNAME,
CONFIG_SAMA5D4EK_ROMFS_MOUNT_MOUNTPOINT,
"romfs", MS_RDONLY, NULL);
if (ret < 0)
{
_err("ERROR: mount(%s,%s,romfs) failed: %d\n",
CONFIG_SAMA5D4EK_ROMFS_ROMDISK_DEVNAME,
CONFIG_SAMA5D4EK_ROMFS_MOUNT_MOUNTPOINT, errno);
}
}
#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)
{
_err("ERROR: Failed to initialize USB host: %d\n", ret);
}
#endif
#ifdef HAVE_USBMONITOR
/* Start the USB Monitor */
ret = usbmonitor_start();
if (ret != OK)
{
_err("ERROR: Failed to start the USB monitor: %d\n", ret);
}
#endif
#ifdef HAVE_MAXTOUCH
/* Initialize the touchscreen */
ret = sam_tsc_setup(0);
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: sam_tsc_setup failed: %d\n", ret);
}
#endif
#ifdef CONFIG_PWM
/* Initialize PWM and register the PWM device. */
ret = sam_pwm_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: sam_pwm_setup() failed: %d\n", ret);
}
#endif
#ifdef CONFIG_ADC
/* Initialize ADC and register the ADC driver. */
ret = sam_adc_setup();
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: sam_adc_setup failed: %d\n", ret);
}
#endif
#ifdef HAVE_WM8904
/* Configure WM8904 audio */
ret = sam_wm8904_initialize(0);
if (ret != OK)
{
_err("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)
{
_err("ERROR: Failed to initialize the NULL audio device: %d\n", ret);
}
#endif
#ifdef CONFIG_FS_PROCFS
/* Mount the procfs file system */
ret = mount(NULL, SAMA5_PROCFS_MOUNTPOINT, "procfs", 0, NULL);
if (ret < 0)
{
_err("ERROR: Failed to mount procfs at %s: %d\n",
SAMA5_PROCFS_MOUNTPOINT, 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 nxflat_main(int argc, char *argv[])
{
struct binary_s bin;
int ret;
int i;
/* Initialize the NXFLAT binary loader */
message("Initializing the NXFLAT binary loader\n");
ret = nxflat_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the NXFLAT loader failed: %d\n", ret);
exit(1);
}
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk\n");
ret = romdisk_register(0, romfs_img, NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
nxflat_uninitialize();
exit(1);
}
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, ROMFSDEV);
ret = mount(ROMFSDEV, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
ROMFSDEV, MOUNTPT, errno);
nxflat_uninitialize();
}
/* Now excercise every progrm in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
testheader(dirlist[i]);
memset(&bin, 0, sizeof(struct binary_s));
snprintf(path, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = path;
bin.exports = exports;
bin.nexports = NEXPORTS;
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
ret = exec_module(&bin, 50);
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
unload_module(&bin);
}
message("Wait a bit for test completion\n");
sleep(4);
}
message("End-of-Test.. Exit-ing\n");
return 0;
}
int elf_main(int argc, char *argv[])
#endif
{
struct binary_s bin;
int ret;
int i;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Does the system support the PATH variable? Has the PATH variable
* already been set? If YES and NO, then set the PATH variable to
* the ROMFS mountpoint.
*/
#if defined(CONFIG_BINFMT_EXEPATH) && !defined(CONFIG_PATH_INITIAL)
(void)setenv("PATH", MOUNTPT, 1);
#endif
/* Now excercise every program in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
/* Output a seperated so that we can clearly discrinmate the output of
* this program from the others.
*/
testheader(dirlist[i]);
/* Initialize the binary_s structure */
memset(&bin, 0, sizeof(struct binary_s));
/* If the binary loader does not support the PATH variable, then
* create the full path to the executable program. Otherwise,
* use the relative path so that the binary loader will have to
* search the PATH variable to find the executable.
*/
#ifdef CONFIG_BINFMT_EXEPATH
bin.filename = dirlist[i];
#else
snprintf(fullpath, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = fullpath;
#endif
bin.exports = exports;
bin.nexports = nexports;
/* Load the ELF module */
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
mm_update(&g_mmstep, "after load_module");
/* Execute the ELF module */
ret = exec_module(&bin);
mm_update(&g_mmstep, "after exec_module");
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
}
else
{
message("Wait a bit for test completion\n");
sleep(4);
}
unload_module(&bin);
mm_update(&g_mmstep, "after unload_module");
}
mm_update(&g_mmstep, "End-of-Test");
return 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 elf_main(int argc, char *argv[])
{
struct binary_s bin;
int ret;
int i;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Now excercise every program in the ROMFS file system */
for (i = 0; dirlist[i]; i++)
{
testheader(dirlist[i]);
memset(&bin, 0, sizeof(struct binary_s));
snprintf(path, 128, "%s/%s", MOUNTPT, dirlist[i]);
bin.filename = path;
bin.exports = exports;
bin.nexports = nexports;
ret = load_module(&bin);
if (ret < 0)
{
err("ERROR: Failed to load program '%s'\n", dirlist[i]);
exit(1);
}
mm_update(&g_mmstep, "after load_module");
ret = exec_module(&bin, 50);
mm_update(&g_mmstep, "after exec_module");
if (ret < 0)
{
err("ERROR: Failed to execute program '%s'\n", dirlist[i]);
}
else
{
message("Wait a bit for test completion\n");
sleep(4);
}
unload_module(&bin);
mm_update(&g_mmstep, "after unload_module");
}
mm_update(&g_mmstep, "End-of-Test");
return 0;
}
int spawn_main(int argc, char *argv[])
{
posix_spawn_file_actions_t file_actions;
posix_spawnattr_t attr;
FAR const char *filepath;
pid_t pid;
int ret;
/* Initialize the memory monitor */
mm_initmonitor();
/* Initialize the ELF binary loader */
message("Initializing the ELF binary loader\n");
ret = elf_initialize();
if (ret < 0)
{
err("ERROR: Initialization of the ELF loader failed: %d\n", ret);
exit(1);
}
mm_update(&g_mmstep, "after elf_initialize");
/* Create a ROM disk for the ROMFS filesystem */
message("Registering romdisk at /dev/ram%d\n", CONFIG_EXAMPLES_ELF_DEVMINOR);
ret = romdisk_register(CONFIG_EXAMPLES_ELF_DEVMINOR, (FAR uint8_t *)romfs_img,
NSECTORS(romfs_img_len), SECTORSIZE);
if (ret < 0)
{
err("ERROR: romdisk_register failed: %d\n", ret);
elf_uninitialize();
exit(1);
}
mm_update(&g_mmstep, "after romdisk_register");
/* Mount the file system */
message("Mounting ROMFS filesystem at target=%s with source=%s\n",
MOUNTPT, CONFIG_EXAMPLES_ELF_DEVPATH);
ret = mount(CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, "romfs", MS_RDONLY, NULL);
if (ret < 0)
{
err("ERROR: mount(%s,%s,romfs) failed: %s\n",
CONFIG_EXAMPLES_ELF_DEVPATH, MOUNTPT, errno);
elf_uninitialize();
}
mm_update(&g_mmstep, "after mount");
/* Does the system support the PATH variable? Has the PATH variable
* already been set? If YES and NO, then set the PATH variable to
* the ROMFS mountpoint.
*/
#if defined(CONFIG_BINFMT_EXEPATH) && !defined(CONFIG_PATH_INITIAL)
(void)setenv("PATH", MOUNTPT, 1);
#endif
/* Make sure that we are using our symbol take */
exec_setsymtab(exports, nexports);
/*************************************************************************
* Case 1: Simple program with arguments
*************************************************************************/
/* Output a seperated so that we can clearly discriminate the output of
* this program from the others.
*/
testheader(g_hello);
/* Initialize the attributes file actions structure */
ret = posix_spawn_file_actions_init(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_init failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_init(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_init failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr init");
/* If the binary loader does not support the PATH variable, then
* create the full path to the executable program. Otherwise,
* use the relative path so that the binary loader will have to
* search the PATH variable to find the executable.
*/
#ifdef CONFIG_BINFMT_EXEPATH
filepath = g_hello;
#else
snprintf(fullpath, 128, "%s/%s", MOUNTPT, g_hello);
filepath = fullpath;
#endif
/* Execute the program */
mm_update(&g_mmstep, "before posix_spawn");
ret = posix_spawn(&pid, filepath, &file_actions, &attr, NULL, (FAR char * const*)&g_argv);
if (ret != 0)
{
err("ERROR: posix_spawn failed: %d\n", ret);
}
sleep(4);
mm_update(&g_mmstep, "after posix_spawn");
/* Free attibutes and file actions */
ret = posix_spawn_file_actions_destroy(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_destroy failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_destroy(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_destroy failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr destruction");
/*************************************************************************
* Case 2: Simple program with redirection of stdin to a file input
*************************************************************************/
/* Output a seperated so that we can clearly discriminate the output of
* this program from the others.
*/
testheader(g_redirect);
/* Initialize the attributes file actions structure */
ret = posix_spawn_file_actions_init(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_init failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_init(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_init failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr init");
/* Set up to close stdin (0) and open testdata.txt as the program input */
ret = posix_spawn_file_actions_addclose(&file_actions, 0);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_addclose failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
snprintf(fullpath, 128, "%s/%s", MOUNTPT, g_data);
ret = posix_spawn_file_actions_addopen(&file_actions, 0, fullpath, O_RDONLY, 0644);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_addopen failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
mm_update(&g_mmstep, "after adding file_actions");
/* If the binary loader does not support the PATH variable, then
* create the full path to the executable program. Otherwise,
* use the relative path so that the binary loader will have to
* search the PATH variable to find the executable.
*/
#ifdef CONFIG_BINFMT_EXEPATH
filepath = g_redirect;
#else
snprintf(fullpath, 128, "%s/%s", MOUNTPT, g_redirect);
filepath = fullpath;
#endif
/* Execute the program */
mm_update(&g_mmstep, "before posix_spawn");
ret = posix_spawn(&pid, filepath, &file_actions, &attr, NULL, NULL);
if (ret != 0)
{
err("ERROR: posix_spawn failed: %d\n", ret);
}
sleep(2);
mm_update(&g_mmstep, "after posix_spawn");
/* Free attibutes and file actions */
ret = posix_spawn_file_actions_destroy(&file_actions);
if (ret != 0)
{
err("ERROR: posix_spawn_file_actions_destroy failed: %d\n", ret);
}
posix_spawn_file_actions_dump(&file_actions);
ret = posix_spawnattr_destroy(&attr);
if (ret != 0)
{
err("ERROR: posix_spawnattr_destroy failed: %d\n", ret);
}
posix_spawnattr_dump(&attr);
mm_update(&g_mmstep, "after file_action/attr destruction");
/* Clean-up */
elf_uninitialize();
mm_update(&g_mmstep, "End-of-Test");
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;
}
int sam_bringup(void)
{
int ret;
#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 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_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;
}
