/****************************************************************************
* Name: syslog_dev_uninitialize
*
* Description:
* Called to disable the last device/file channel in preparation to use
* a different SYSLOG device. Currently only used for CONFIG_SYSLOG_FILE.
*
* Input Parameters:
* None
*
* Returned Value:
* Zero (OK) is returned on success; a negated errno value is returned on
* any failure.
*
* Assumptions:
* The caller has already switched the SYSLOG source to some safe channel
* (the default channel).
*
****************************************************************************/
#ifdef CONFIG_SYSLOG_FILE /* Currently only used in this configuration */
int syslog_dev_uninitialize(void)
{
/* Attempt to flush any buffered data */
sched_lock();
(void)syslog_dev_flush();
/* Close the detached file instance */
(void)file_close_detached(&g_syslog_dev.sl_file);
/* Free the device path */
if (g_syslog_dev.sl_devpath != NULL)
{
kmm_free(g_syslog_dev.sl_devpath);
}
/* Destroy the semaphore */
nxsem_destroy(&g_syslog_dev.sl_sem);
/* Reset the state structure */
memset(&g_syslog_dev, 0, sizeof(struct syslog_dev_s));
sched_unlock();
return OK;
}
int sam_ajoy_initialization(void)
{
int ret;
int fd;
int i;
/* NOTE: The ADC driver was initialized earlier in the bring-up sequence. */
/* Open the ADC driver for reading. */
fd = open("/dev/adc0", O_RDONLY);
if (fd < 0)
{
int errcode = get_errno();
ierr("ERROR: Failed to open /dev/adc0: %d\n", errcode);
return -errcode;
}
/* Detach the file structure from the file descriptor so that it can be
* used on any thread.
*/
ret = file_detach(fd, &g_adcfile);
if (ret < 0)
{
ierr("ERROR: Failed to detach from file descriptor: %d\n", ret);
(void)close(fd);
return ret;
}
/* Configure the GPIO pins as interrupting inputs. */
for (i = 0; i < AJOY_NGPIOS; i++)
{
/* Configure the PIO as an input */
sam_configpio(g_joypio[i]);
/* Configure PIO interrupts, attach the interrupt handler, but leave
* the interrupt disabled.
*/
sam_pioirq(g_joypio[i]);
(void)irq_attach(g_joyirq[i], ajoy_interrupt);
sam_pioirqdisable(g_joyirq[i]);
}
/* Register the joystick device as /dev/ajoy0 */
ret = ajoy_register("/dev/ajoy0", &g_ajoylower);
if (ret < 0)
{
ierr("ERROR: ajoy_register failed: %d\n", ret);
file_close_detached(&g_adcfile);
}
return ret;
}
static void pty_destroy(FAR struct pty_devpair_s *devpair)
{
char devname[16];
/* Un-register the slave device */
#ifdef CONFIG_PSEUDOTERM_BSD
snprintf(devname, 16, "/dev/ttyp%d", devpair->pp_minor);
#else
snprintf(devname, 16, "/dev/pts/%d", devpair->pp_minor);
#endif
(void)unregister_driver(devname);
/* Un-register the master device (/dev/ptyN may have already been
* unlinked).
*/
snprintf(devname, 16, "/dev/pty%d", (int)devpair->pp_minor);
(void)unregister_driver(devname);
/* Close the contained file structures */
(void)file_close_detached(&devpair->pp_master.pd_src);
(void)file_close_detached(&devpair->pp_master.pd_sink);
(void)file_close_detached(&devpair->pp_slave.pd_src);
(void)file_close_detached(&devpair->pp_slave.pd_sink);
#ifdef CONFIG_PSEUDOTERM_SUSV1
/* Free this minor number so that it can be reused */
ptmx_minor_free(devpair->pp_minor);
#endif
/* And free the device structure */
nxsem_destroy(&devpair->pp_exclsem);
kmm_free(devpair);
}
void blockmtd_teardown(FAR struct mtd_dev_s *dev)
{
FAR struct file_dev_s *priv;
/* Close the enclosed file */
priv = (FAR struct file_dev_s *) dev;
file_close_detached(&priv->mtdfile);
#ifdef CONFIG_MTD_REGISTRATION
/* Un-register the MTD with the procfs system if enabled */
mtd_unregister(&priv->mtd);
#endif
/* Free the memory */
kmm_free(priv);
}
int board_ajoy_initialize(void)
{
int ret;
int i;
#ifndef NO_JOYSTICK_ADC
int fd;
iinfo("Initialize ADC driver: /dev/adc0\n");
/* NOTE: The ADC driver was initialized earlier in the bring-up sequence. */
/* Open the ADC driver for reading. */
fd = open("/dev/adc0", O_RDONLY);
if (fd < 0)
{
int errcode = get_errno();
ierr("ERROR: Failed to open /dev/adc0: %d\n", errcode);
return -errcode;
}
/* Detach the file structure from the file descriptor so that it can be
* used on any thread.
*/
ret = file_detach(fd, &g_adcfile);
if (ret < 0)
{
ierr("ERROR: Failed to detach from file descriptor: %d\n", ret);
(void)close(fd);
return ret;
}
#endif
/* Configure the GPIO pins as interrupting inputs. NOTE: This is
* unnecessary for interrupting pins since it will also be done by
* stm32_gpiosetevent().
*/
for (i = 0; i < AJOY_NGPIOS; i++)
{
/* Configure the PIO as an input */
stm32_configgpio(g_joygpio[i]);
}
/* Register the joystick device as /dev/ajoy0 */
iinfo("Initialize joystick driver: /dev/ajoy0\n");
ret = ajoy_register("/dev/ajoy0", &g_ajoylower);
if (ret < 0)
{
ierr("ERROR: ajoy_register failed: %d\n", ret);
#ifndef NO_JOYSTICK_ADC
file_close_detached(&g_adcfile);
#endif
}
return ret;
}
int pty_register(int minor)
{
FAR struct pty_devpair_s *devpair;
int pipe_a[2];
int pipe_b[2];
char devname[16];
int ret;
/* Allocate a device instance */
devpair = kmm_zalloc(sizeof(struct pty_devpair_s));
if (devpair == NULL)
{
return -ENOMEM;
}
/* Initialize semaphores */
nxsem_init(&devpair->pp_slavesem, 0, 0);
nxsem_init(&devpair->pp_exclsem, 0, 1);
/* The pp_slavesem semaphore is used for signaling and, hence, should not
* have priority inheritance enabled.
*/
nxsem_setprotocol(&devpair->pp_slavesem, SEM_PRIO_NONE);
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
devpair->pp_minor = minor;
#endif
devpair->pp_locked = true;
devpair->pp_master.pd_devpair = devpair;
devpair->pp_master.pd_master = true;
devpair->pp_slave.pd_devpair = devpair;
/* Create two pipes:
*
* pipe_a: Master source, slave sink (TX, slave-to-master)
* pipe_b: Master sink, slave source (RX, master-to-slave)
*/
ret = pipe2(pipe_a, CONFIG_PSEUDOTERM_TXBUFSIZE);
if (ret < 0)
{
goto errout_with_devpair;
}
ret = pipe2(pipe_b, CONFIG_PSEUDOTERM_RXBUFSIZE);
if (ret < 0)
{
goto errout_with_pipea;
}
/* Detach the pipe file descriptors (closing them in the process)
*
* fd[0] is for reading;
* fd[1] is for writing.
*/
ret = file_detach(pipe_a[0], &devpair->pp_master.pd_src);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_a[0] = -1;
ret = file_detach(pipe_a[1], &devpair->pp_slave.pd_sink);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_a[1] = -1;
ret = file_detach(pipe_b[0], &devpair->pp_slave.pd_src);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_b[0] = -1;
ret = file_detach(pipe_b[1], &devpair->pp_master.pd_sink);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_b[1] = -1;
/* Register the slave device
*
* BSD style (deprecated): /dev/ttypN
* SUSv1 style: /dev/pts/N
*
* Where N is the minor number
*/
#ifdef CONFIG_PSEUDOTERM_BSD
snprintf(devname, 16, "/dev/ttyp%d", minor);
#else
snprintf(devname, 16, "/dev/pts/%d", minor);
#endif
ret = register_driver(devname, &g_pty_fops, 0666, &devpair->pp_slave);
if (ret < 0)
{
goto errout_with_pipeb;
}
/* Register the master device
*
* BSD style (deprecated): /dev/ptyN
* SUSv1 style: Master: /dev/ptmx (multiplexor, see ptmx.c)
*
* Where N is the minor number
*/
snprintf(devname, 16, "/dev/pty%d", minor);
ret = register_driver(devname, &g_pty_fops, 0666, &devpair->pp_master);
if (ret < 0)
{
goto errout_with_slave;
}
return OK;
errout_with_slave:
#ifdef CONFIG_PSEUDOTERM_BSD
snprintf(devname, 16, "/dev/ttyp%d", minor);
#else
snprintf(devname, 16, "/dev/pts/%d", minor);
#endif
(void)unregister_driver(devname);
errout_with_pipeb:
if (pipe_b[0] >= 0)
{
close(pipe_b[0]);
}
else
{
(void)file_close_detached(&devpair->pp_master.pd_src);
}
if (pipe_b[1] >= 0)
{
close(pipe_b[1]);
}
else
{
(void)file_close_detached(&devpair->pp_slave.pd_sink);
}
errout_with_pipea:
if (pipe_a[0] >= 0)
{
close(pipe_a[0]);
}
else
{
(void)file_close_detached(&devpair->pp_slave.pd_src);
}
if (pipe_a[1] >= 0)
{
close(pipe_a[1]);
}
else
{
(void)file_close_detached(&devpair->pp_master.pd_sink);
}
errout_with_devpair:
nxsem_destroy(&devpair->pp_exclsem);
nxsem_destroy(&devpair->pp_slavesem);
kmm_free(devpair);
return ret;
}
int pty_register(int minor)
{
FAR struct pty_devpair_s *devpair;
int pipe_a[2];
int pipe_b[2];
char devname[16];
int ret;
/* Allocate a device instance */
devpair = kmm_zalloc(sizeof(struct pty_devpair_s));
if (devpair == NULL)
{
return -ENOMEM;
}
sem_init(&devpair->pp_slavesem, 0, 0);
sem_init(&devpair->pp_exclsem, 0, 1);
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
devpair->pp_minor = minor;
#endif
devpair->pp_locked = true;
devpair->pp_master.pd_devpair = devpair;
devpair->pp_master.pd_master = true;
devpair->pp_slave.pd_devpair = devpair;
/* Create two pipes */
ret = pipe(pipe_a);
if (ret < 0)
{
goto errout_with_devpair;
}
ret = pipe(pipe_b);
if (ret < 0)
{
goto errout_with_pipea;
}
/* Detach the pipe file descriptors (closing them in the process)
*
* fd[0] is for reading;
* fd[1] is for writing.
*/
ret = file_detach(pipe_a[0], &devpair->pp_master.pd_src);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_a[0] = -1;
ret = file_detach(pipe_a[1], &devpair->pp_slave.pd_sink);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_a[1] = -1;
ret = file_detach(pipe_b[0], &devpair->pp_slave.pd_src);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_b[0] = -1;
ret = file_detach(pipe_b[1], &devpair->pp_master.pd_sink);
if (ret < 0)
{
goto errout_with_pipeb;
}
pipe_b[1] = -1;
/* Register the slave device
*
* BSD style (deprecated): /dev/ttypN
* SUSv1 style: /dev/pts/N
*
* Where N is the minor number
*/
#ifdef CONFIG_PSEUDOTERM_BSD
snprintf(devname, 16, "/dev/ttyp%d", minor);
#else
snprintf(devname, 16, "/dev/pts/%d", minor);
#endif
ret = register_driver(devname, &pty_fops, 0666, &devpair->pp_slave);
if (ret < 0)
{
goto errout_with_pipeb;
}
/* Register the master device
*
* BSD style (deprecated): /dev/ptyN
* SUSv1 style: Master: /dev/ptmx (multiplexor, see ptmx.c)
*
* Where N is the minor number
*/
snprintf(devname, 16, "/dev/pty%d", minor);
ret = register_driver(devname, &pty_fops, 0666, &devpair->pp_master);
if (ret < 0)
{
goto errout_with_slave;
}
return OK;
errout_with_slave:
#ifdef CONFIG_PSEUDOTERM_BSD
snprintf(devname, 16, "/dev/ttyp%d", minor);
#else
snprintf(devname, 16, "/dev/pts/%d", minor);
#endif
(void)unregister_driver(devname);
errout_with_pipeb:
if (pipe_b[0] >= 0)
{
close(pipe_b[0]);
}
else
{
(void)file_close_detached(&devpair->pp_master.pd_src);
}
if (pipe_b[1] >= 0)
{
close(pipe_b[1]);
}
else
{
(void)file_close_detached(&devpair->pp_slave.pd_sink);
}
errout_with_pipea:
if (pipe_a[0] >= 0)
{
close(pipe_a[0]);
}
else
{
(void)file_close_detached(&devpair->pp_slave.pd_src);
}
if (pipe_a[1] >= 0)
{
close(pipe_a[1]);
}
else
{
(void)file_close_detached(&devpair->pp_master.pd_sink);
}
errout_with_devpair:
sem_destroy(&devpair->pp_exclsem);
sem_destroy(&devpair->pp_slavesem);
kmm_free(devpair);
return ret;
}
FAR struct mtd_dev_s *blockmtd_initialize(FAR const char *path, size_t offset,
size_t mtdlen, int16_t sectsize,
int32_t erasesize)
{
FAR struct file_dev_s *priv;
size_t nblocks;
int mode;
int ret;
int fd;
/* Create an instance of the FILE MTD device state structure */
priv = (FAR struct file_dev_s *)kmm_zalloc(sizeof(struct file_dev_s));
if (!priv)
{
ferr("ERROR: Failed to allocate the FILE MTD state structure\n");
return NULL;
}
/* Determine the file open mode */
mode = O_RDOK;
#ifdef CONFIG_FS_WRITABLE
mode |= O_WROK;
#endif
/* Try to open the file. NOTE that block devices will use a character
* driver proxy.
*/
fd = open(path, mode);
if (fd <0)
{
ferr("ERROR: Failed to open the FILE MTD file %s\n", path);
kmm_free(priv);
return NULL;
}
/* Detach the file descriptor from the open file */
ret = file_detach(fd, &priv->mtdfile);
if (ret < 0)
{
ferr("ERROR: Failed to detail the FILE MTD file %s\n", path);
close(fd);
kmm_free(priv);
return NULL;
}
/* Set the block size based on the provided sectsize parameter */
if (sectsize <= 0)
{
priv->blocksize = CONFIG_FILEMTD_BLOCKSIZE;
}
else
{
priv->blocksize = sectsize;
}
/* Set the erase size based on the provided erasesize parameter */
if (erasesize <= 0)
{
priv->erasesize = CONFIG_FILEMTD_ERASESIZE;
}
else
{
priv->erasesize = erasesize;
}
/* Force the size to be an even number of the erase block size */
nblocks = mtdlen / priv->erasesize;
if (nblocks < 3)
{
ferr("ERROR: Need to provide at least three full erase block\n");
file_close_detached(&priv->mtdfile);
kmm_free(priv);
return NULL;
}
/* Perform initialization as necessary. (unsupported methods were
* nullified by kmm_zalloc).
*/
priv->mtd.erase = filemtd_erase;
priv->mtd.bread = filemtd_bread;
priv->mtd.bwrite = filemtd_bwrite;
priv->mtd.read = filemtd_byteread;
#ifdef CONFIG_MTD_BYTE_WRITE
priv->mtd.write = file_bytewrite;
#endif
priv->mtd.ioctl = filemtd_ioctl;
priv->offset = offset;
priv->nblocks = nblocks;
#ifdef CONFIG_MTD_REGISTRATION
/* Register the MTD with the procfs system if enabled */
mtd_register(&priv->mtd, "filemtd");
#endif
return &priv->mtd;
}
