int sercon_main(int argc, char *argv[]) #endif { int ret; /* Check if there is a non-NULL USB mass storage device handle (meaning that the * USB mass storage device is already configured). */ if (g_cdcacm.handle) { printf("sercon:: ERROR: Already connected\n"); return EXIT_FAILURE; } /* Then, in any event, enable trace data collection as configured BEFORE * enabling the CDC/ACM device. */ usbtrace_enable(TRACE_BITSET); /* Initialize the USB CDC/ACM serial driver */ printf("sercon: Registering CDC/ACM serial driver\n"); ret = cdcacm_initialize(CONFIG_SYSTEM_CDCACM_DEVMINOR, &g_cdcacm.handle); if (ret < 0) { printf("sercon: ERROR: Failed to create the CDC/ACM serial device: %d\n", -ret); return EXIT_FAILURE; } printf("sercon: Successfully registered the CDC/ACM serial driver\n"); return EXIT_SUCCESS; }
int nsh_consolemain(int argc, char *argv[]) { FAR struct console_stdio_s *pstate = nsh_newconsole(); int ret; DEBUGASSERT(pstate); /* Initialize any USB tracing options that were requested */ #ifdef CONFIG_NSH_USBDEV_TRACE usbtrace_enable(TRACE_BITSET); #endif /* Initialize the USB serial driver */ #if defined(CONFIG_PL2303) || defined(CONFIG_CDCACM) #ifdef CONFIG_CDCACM ret = cdcacm_initialize(CONFIG_NSH_USBDEV_MINOR, NULL); #else ret = usbdev_serialinitialize(CONFIG_NSH_USBDEV_MINOR); #endif DEBUGASSERT(ret == OK); #endif /* Configure to use /dev/null if we do not have a valid console. */ #ifndef CONFIG_DEV_CONSOLE (void)nsh_nullstdio(); #endif /* Execute the one-time start-up script (output may go to /dev/null) */ #ifdef CONFIG_NSH_ROMFSETC (void)nsh_initscript(&pstate->cn_vtbl); #endif /* Now loop, executing creating a session for each USB connection */ for (;;) { /* Wait for the USB to be connected to the host and switch * standard I/O to the USB serial device. */ ret = nsh_waitusbready(); DEBUGASSERT(ret == OK); /* Execute the session */ (void)nsh_session(pstate); /* Switch to /dev/null because we probably no longer have a * valid console device. */ (void)nsh_nullstdio(); } }
static int tash_nonftdi_usbconinit(void) { int ret = OK; int nlc; int fd; char inch; ssize_t nbytes; #if defined(CONFIG_CDCACM) #define CONFIG_TASH_USBCONSOLE "/dev/ttyACM0" #define CONFIG_USBDEV_MINOR 0 ret = cdcacm_initialize(CONFIG_USBDEV_MINOR, NULL); /* For future if (ret != 0) RETRY logic */ #endif restart: do { /* Try to open the console */ fd = open(CONFIG_TASH_USBCONSOLE, O_RDWR); if (fd < 0) { /* ENOTCONN means that the USB device is not yet connected. Anything * else is bad. */ //DEBUGASSERT(errno == ENOTCONN); /* Sleep a bit and try again */ sleep(2); } } while (fd < 0); nlc = 0; do { /* Read one byte */ inch = 0; nbytes = read(fd, &inch, 1); /* Is it a carriage return (or maybe a newline)? */ if (nbytes == 1 && (inch == '\n' || inch == '\r')) { /* Yes.. increment the count */ nlc++; } else { /* No.. Reset the count. We need to see 3 in a row to continue. */ nlc = 0; /* If a read error occurred (nbytes < 0) or an end-of-file was * encountered (nbytes == 0), then close the driver and start * over. */ if (nbytes <= 0) { (void)close(fd); goto restart; } } } while (nlc < 2); (void)fclose(stdin); (void)fclose(stdout); (void)fclose(stderr); /* Dup the fd to create standard fd 0-2 */ (void)dup2(fd, 0); (void)dup2(fd, 1); (void)dup2(fd, 2); /* fdopen to get the stdin, stdout and stderr streams. The following logic depends * on the fact that the library layer will allocate FILEs in order. And since * we closed stdin, stdout, and stderr above, that is what we should get. * * fd = 0 is stdin (read-only) * fd = 1 is stdout (write-only, append) * fd = 2 is stderr (write-only, append) */ (void)fdopen(0, "r"); (void)fdopen(1, "a"); (void)fdopen(2, "a"); if (fd > 2) { close(fd); } return ret; }
int MAIN_NAME(int argc, char *argv[]) { pthread_attr_t attr; int ret; /* Initialize global data */ memset(&g_usbterm, 0, sizeof(struct usbterm_globals_s)); /* Initialization of the USB hardware may be performed by logic external to * this test. */ #ifdef CONFIG_EXAMPLES_USBTERM_DEVINIT message(MAIN_STRING "Performing external device initialization\n"); ret = usbterm_devinit(); if (ret != OK) { message(MAIN_STRING "usbterm_devinit failed: %d\n", ret); goto errout; } #endif /* Initialize the USB serial driver */ message(MAIN_STRING "Registering USB serial driver\n"); #ifdef CONFIG_CDCACM ret = cdcacm_initialize(0, NULL); #else ret = usbdev_serialinitialize(0); #endif if (ret < 0) { message(MAIN_STRING "ERROR: Failed to create the USB serial device: %d\n", -ret); goto errout_with_devinit; } message(MAIN_STRING "Successfully registered the serial driver\n"); #if CONFIG_USBDEV_TRACE && CONFIG_USBDEV_TRACE_INITIALIDSET != 0 /* If USB tracing is enabled and tracing of initial USB events is specified, * then dump all collected trace data to stdout */ sleep(5); dumptrace(); #endif /* Then, in any event, configure trace data collection as configured */ usbtrace_enable(TRACE_BITSET); /* Open the USB serial device for writing */ do { message(MAIN_STRING "Opening USB serial driver\n"); g_usbterm.outstream = fopen(USBTERM_DEVNAME, "w"); if (g_usbterm.outstream == NULL) { int errcode = errno; message(MAIN_STRING "ERROR: Failed to open " USBTERM_DEVNAME " for writing: %d\n", errcode); /* ENOTCONN means that the USB device is not yet connected */ if (errcode == ENOTCONN) { message(MAIN_STRING " Not connected. Wait and try again.\n"); sleep(5); } else { /* Give up on other errors */ goto errout_with_devinit; } } /* If USB tracing is enabled, then dump all collected trace data to stdout */ dumptrace(); } while (g_usbterm.outstream == NULL); /* Open the USB serial device for reading. Since we are already connected, this * should not fail. */ g_usbterm.instream = fopen(USBTERM_DEVNAME, "r"); if (g_usbterm.instream == NULL) { message(MAIN_STRING "ERROR: Failed to open " USBTERM_DEVNAME " for reading: %d\n", errno); goto errout_with_outstream; } message(MAIN_STRING "Successfully opened the serial driver\n"); /* Start the USB term listener thread */ message(MAIN_STRING "Starting the listener thread\n"); ret = pthread_attr_init(&attr); if (ret != OK) { message(MAIN_STRING "pthread_attr_init failed: %d\n", ret); goto errout_with_streams; } ret = pthread_create(&g_usbterm.listener, &attr, usbterm_listener, (pthread_addr_t)0); if (ret != 0) { message(MAIN_STRING "Error in thread creation: %d\n", ret); goto errout_with_streams; } /* Send messages and get responses -- forever */ message(MAIN_STRING "Waiting for local input\n"); for (;;) { /* Display the prompt string on stdout */ fputs("usbterm> ", stdout); fflush(stdout); /* Get the next line of input */ #ifdef CONFIG_EXAMPLES_USBTERM_FGETS /* fgets returns NULL on end-of-file or any I/O error */ if (fgets(g_usbterm.outbuffer, CONFIG_EXAMPLES_USBTERM_BUFLEN, stdin) == NULL) { printf("ERROR: fgets failed: %d\n", errno); return 1; } #else ret = readline(g_usbterm.outbuffer, CONFIG_EXAMPLES_USBTERM_BUFLEN, stdin, stdout); /* Readline normally returns the number of characters read, * but will return 0 on end of file or a negative value * if an error occurs. Either will cause the session to * terminate. */ if (ret <= 0) { printf("ERROR: readline failed: %d\n", ret); return 1; } #endif /* Is there anyone listening on the other end? */ else if (g_usbterm.peer) { /* Yes.. Send the line of input via USB */ fputs(g_usbterm.outbuffer, g_usbterm.outstream); /* Display the prompt string on the remote USB serial connection */ fputs("\rusbterm> ", g_usbterm.outstream); fflush(g_usbterm.outstream); } else { printf("Still waiting for remote peer. Please try again later.\n", ret); } /* If USB tracing is enabled, then dump all collected trace data to stdout */ dumptrace(); } /* Error exits */ errout_with_streams: fclose(g_usbterm.instream); errout_with_outstream: fclose(g_usbterm.outstream); errout_with_devinit: #ifdef CONFIG_EXAMPLES_USBTERM_DEVINIT usbterm_devuninit(); errout: #endif message(MAIN_STRING " Aborting\n"); return 1; }
int board_app_initialize(uintptr_t arg) { #if defined (HAVE_USBDEV) || defined(HAVE_HSMCI) || defined (HAVE_PROC) || \ defined(HAVE_USBMONITOR) int ret; #endif #ifdef HAVE_USBDEV syslog(LOG_INFO, "Registering CDC/ACM serial driver\n"); ret = cdcacm_initialize(CONFIG_SAM4S_XPLAINED_PRO_CDCACM_DEVMINOR, NULL); if (ret < 0) { syslog(LOG_ERR, "ERROR: Failed to create the CDC/ACM serial device: %d (%d)\n", ret, errno); return ret; } #endif #ifdef HAVE_HSMCI /* Initialize the HSMCI driver */ syslog(LOG_INFO, "initializing HSMCI\n"); ret = sam_hsmci_initialize(); if (ret < 0) { syslog(LOG_ERR, "ERROR: sam_hsmci_initialize() failed: %d (%d)\n", ret, errno); return ret; } #endif #ifdef HAVE_PROC /* mount the proc filesystem */ syslog(LOG_INFO, "Mounting procfs to /proc\n"); ret = mount(NULL, "/proc", "procfs", 0, NULL); if (ret < 0) { syslog(LOG_ERR, "ERROR: Failed to mount the PROC filesystem: %d (%d)\n", ret, errno); return ret; } #endif #if HAVE_HSMCI syslog(LOG_INFO, "Mounting /dev/mmcsd0 to /fat\n"); ret = mount("/dev/mmcsd0", "/fat", "vfat", 0, NULL); if (ret < 0) { syslog(LOG_ERR, "ERROR: Failed to mount the FAT filesystem: %d (%d)\n", ret, errno); return ret; } #endif #ifdef HAVE_USBMONITOR /* Start the USB Monitor */ syslog(LOG_INFO, "Starting USB Monitor\n"); ret = usbmonitor_start(); if (ret != OK) { syslog(LOG_ERR, "ERROR: Failed to start USB monitor: %d (%d)\n", ret, errno); return ret; } #endif return OK; }
int usbserial_main(int argc, char *argv[]) #endif { #ifndef CONFIG_EXAMPLES_USBSERIAL_INONLY int infd; #endif #ifndef CONFIG_EXAMPLES_USBSERIAL_OUTONLY int outfd; #endif #ifdef COUNTER_NEEDED int count = 0; #endif ssize_t nbytes; #ifndef CONFIG_EXAMPLES_USBSERIAL_INONLY int i, j, k; #endif int ret; /* Initialize the USB serial driver */ printf("usbserial_main: Registering USB serial driver\n"); #ifdef CONFIG_CDCACM ret = cdcacm_initialize(0, NULL); #else ret = usbdev_serialinitialize(0); #endif if (ret < 0) { printf("usbserial_main: ERROR: Failed to create the USB serial device: %d\n", -ret); return 1; } printf("usbserial_main: Successfully registered the serial driver\n"); #if CONFIG_USBDEV_TRACE && CONFIG_USBDEV_TRACE_INITIALIDSET != 0 /* If USB tracing is enabled and tracing of initial USB events is specified, * then dump all collected trace data to stdout */ sleep(5); dumptrace(); #endif /* Then, in any event, configure trace data collection as configured */ usbtrace_enable(TRACE_BITSET); /* Open the USB serial device for writing (blocking) */ #ifndef CONFIG_EXAMPLES_USBSERIAL_OUTONLY do { printf("usbserial_main: Opening USB serial driver\n"); outfd = open(USBSER_DEVNAME, O_WRONLY); if (outfd < 0) { int errcode = errno; printf("usbserial_main: ERROR: Failed to open " USBSER_DEVNAME " for writing: %d\n", errcode); /* ENOTCONN means that the USB device is not yet connected */ if (errcode == ENOTCONN) { printf("usbserial_main: Not connected. Wait and try again.\n"); sleep(5); } else { /* Give up on other errors */ printf("usbserial_main: Aborting\n"); return 2; } } /* If USB tracing is enabled, then dump all collected trace data to stdout */ dumptrace(); } while (outfd < 0); #endif /* Open the USB serial device for reading (non-blocking) */ #ifndef CONFIG_EXAMPLES_USBSERIAL_INONLY #ifndef CONFIG_EXAMPLES_USBSERIAL_OUTONLY infd = open(USBSER_DEVNAME, O_RDONLY|O_NONBLOCK); if (infd < 0) { printf("usbserial_main: ERROR: Failed to open " USBSER_DEVNAME " for reading: %d\n", errno); close(outfd); return 3; } #else do { infd = open(USBSER_DEVNAME, O_RDONLY|O_NONBLOCK); if (infd < 0) { int errcode = errno; printf("usbserial_main: ERROR: Failed to open " USBSER_DEVNAME " for reading: %d\n", errno); /* ENOTCONN means that the USB device is not yet connected */ if (errcode == ENOTCONN) { printf("usbserial_main: Not connected. Wait and try again.\n"); sleep(5); } else { /* Give up on other errors */ printf("usbserial_main: Aborting\n"); return 3; } } /* If USB tracing is enabled, then dump all collected trace data to stdout */ dumptrace(); } while (infd < 0); #endif #endif printf("usbserial_main: Successfully opened the serial driver\n"); /* Send messages and get responses -- forever */ for (;;) { /* Test IN (device-to-host) messages */ #ifndef CONFIG_EXAMPLES_USBSERIAL_OUTONLY #if !defined(CONFIG_EXAMPLES_USBSERIAL_ONLYBIG) && !defined(CONFIG_EXAMPLES_USBSERIAL_ONLYSMALL) if (count < 8) { printf("usbserial_main: Saying hello\n"); nbytes = write(outfd, g_shortmsg, sizeof(g_shortmsg)); count++; } else { printf("usbserial_main: Reciting QEI's speech of 1588\n"); nbytes = write(outfd, g_longmsg, sizeof(g_longmsg)); count = 0; } #elif !defined(CONFIG_EXAMPLES_USBSERIAL_ONLYSMALL) printf("usbserial_main: Reciting QEI's speech of 1588\n"); nbytes = write(outfd, g_longmsg, sizeof(g_longmsg)); #else /* !defined(CONFIG_EXAMPLES_USBSERIAL_ONLYBIG) */ printf("usbserial_main: Saying hello\n"); nbytes = write(outfd, g_shortmsg, sizeof(g_shortmsg)); #endif /* Test if the write was successful */ if (nbytes < 0) { printf("usbserial_main: ERROR: write failed: %d\n", errno); #ifndef CONFIG_EXAMPLES_USBSERIAL_INONLY close(infd); #endif close(outfd); return 4; } printf("usbserial_main: %ld bytes sent\n", (long)nbytes); #endif /* CONFIG_EXAMPLES_USBSERIAL_OUTONLY */ /* Test OUT (host-to-device) messages */ #ifndef CONFIG_EXAMPLES_USBSERIAL_INONLY /* Poll for incoming messages */ printf("usbserial_main: Polling for OUT messages\n"); for (i = 0; i < 5; i++) { memset(g_iobuffer, 'X', IOBUFFER_SIZE); nbytes = read(infd, g_iobuffer, IOBUFFER_SIZE); if (nbytes < 0) { int errorcode = errno; if (errorcode != EAGAIN) { printf("usbserial_main: ERROR: read failed: %d\n", errno); close(infd); #ifndef CONFIG_EXAMPLES_USBSERIAL_OUTONLY close(outfd); #endif return 6; } } else { printf("usbserial_main: Received l%d bytes:\n", (long)nbytes); if (nbytes > 0) { for (j = 0; j < nbytes; j += 16) { printf("usbserial_main: %03x: ", j); for (k = 0; k < 16; k++) { if (k == 8) { printf(" "); } if (j+k < nbytes) { printf("%02x", g_iobuffer[j+k]); } else { printf(" "); } } printf(" "); for (k = 0; k < 16; k++) { if (k == 8) { printf(" "); } if (j+k < nbytes) { if (g_iobuffer[j+k] >= 0x20 && g_iobuffer[j+k] < 0x7f) { printf("%c", g_iobuffer[j+k]); } else { printf("."); } } else { printf(" "); } } printf("\n"); } } } sleep(1); } #else /* CONFIG_EXAMPLES_USBSERIAL_INONLY */ printf("usbserial_main: Waiting\n"); sleep(5); #endif /* CONFIG_EXAMPLES_USBSERIAL_INONLY */ /* If USB tracing is enabled, then dump all collected trace data to stdout */ dumptrace(); } /* Won't get here, but if we did this what we would have to do */ #ifndef CONFIG_EXAMPLES_USBSERIAL_INONLY close(infd); #endif #ifndef CONFIG_EXAMPLES_USBSERIAL_OUTONLY close(outfd); #endif return 0; }
int nsh_usbconsole(void) { int fd; int ret; /* Don't start the NSH console until the console device is ready. Chances * are, we get here with no functional console. The USB console will not * be available until the device is connected to the host and until the * host-side application opens the connection. */ /* Initialize the USB serial driver */ #ifdef CONFIG_CDCACM ret = cdcacm_initialize(0, NULL); #else ret = usbdev_serialinitialize(0); #endif DEBUGASSERT(ret == OK); /* Make sure the stdin, stdout, and stderr are closed */ (void)fclose(stdin); (void)fclose(stdout); (void)fclose(stderr); /* Open the USB serial device for writing */ do { /* Try to open the console */ fd = open("/dev/console", O_RDWR); if (fd < 0) { /* ENOTCONN means that the USB device is not yet connected. Anything * else is bad. */ DEBUGASSERT(errno == ENOTCONN); /* Sleep a bit and try again */ sleep(2); } } while (fd < 0); /* Dup the fd to create standard fd 0-2 */ (void)dup2(fd, 0); (void)dup2(fd, 1); (void)dup2(fd, 2); /* We can close the original file descriptor now (unless it was one of 0-2) */ if (fd > 2) { close(fd); } /* fdopen to get the stdin, stdout and stderr streams. The following logic depends * on the fact that the library layer will allocate FILEs in order. And since * we closed stdin, stdout, and stderr above, that is what we should get. * * fd = 0 is stdin (read-only) * fd = 1 is stdout (write-only, append) * fd = 2 is stderr (write-only, append) */ (void)fdopen(0, "r"); (void)fdopen(1, "a"); (void)fdopen(2, "a"); return OK; }