2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* drivers/note/noteram_driver.c
|
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
|
|
* this work for additional information regarding copyright ownership. The
|
|
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
|
|
* "License"); you may not use this file except in compliance with the
|
|
|
|
* License. You may obtain a copy of the License at
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
* License for the specific language governing permissions and limitations
|
|
|
|
* under the License.
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sched.h>
|
2020-09-09 02:06:38 +02:00
|
|
|
#include <fcntl.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
#include <assert.h>
|
|
|
|
#include <errno.h>
|
2020-10-28 02:45:30 +01:00
|
|
|
#include <string.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
#include <nuttx/spinlock.h>
|
2020-10-28 02:45:30 +01:00
|
|
|
#include <nuttx/sched.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
#include <nuttx/sched_note.h>
|
2022-12-16 11:31:28 +01:00
|
|
|
#include <nuttx/note/note_driver.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
#include <nuttx/note/noteram_driver.h>
|
|
|
|
#include <nuttx/fs/fs.h>
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Types
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
struct noteram_info_s
|
|
|
|
{
|
2022-03-26 21:51:22 +01:00
|
|
|
unsigned int ni_overwrite;
|
2020-09-08 12:44:29 +02:00
|
|
|
volatile unsigned int ni_head;
|
|
|
|
volatile unsigned int ni_tail;
|
2020-09-09 02:06:38 +02:00
|
|
|
volatile unsigned int ni_read;
|
2020-09-08 12:44:29 +02:00
|
|
|
uint8_t ni_buffer[CONFIG_DRIVER_NOTERAM_BUFSIZE];
|
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Function Prototypes
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
static int noteram_open(FAR struct file *filep);
|
2020-09-08 12:44:29 +02:00
|
|
|
static ssize_t noteram_read(FAR struct file *filep,
|
|
|
|
FAR char *buffer, size_t buflen);
|
2020-09-09 02:06:38 +02:00
|
|
|
static int noteram_ioctl(struct file *filep, int cmd, unsigned long arg);
|
2022-12-16 11:31:28 +01:00
|
|
|
static void noteram_add(FAR struct note_driver_s *drv,
|
|
|
|
FAR const void *note, size_t len);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static const struct file_operations g_noteram_fops =
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
noteram_open, /* open */
|
2020-09-08 12:44:29 +02:00
|
|
|
NULL, /* close */
|
|
|
|
noteram_read, /* read */
|
|
|
|
NULL, /* write */
|
|
|
|
NULL, /* seek */
|
2020-09-09 02:06:38 +02:00
|
|
|
noteram_ioctl, /* ioctl */
|
2020-09-08 12:44:29 +02:00
|
|
|
NULL /* poll */
|
|
|
|
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
|
2022-01-10 15:51:17 +01:00
|
|
|
, NULL /* unlink */
|
2020-09-08 12:44:29 +02:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
static struct noteram_info_s g_noteram_info =
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
#ifdef CONFIG_DRIVER_NOTERAM_DEFAULT_NOOVERWRITE
|
2022-03-26 21:51:22 +01:00
|
|
|
NOTERAM_MODE_OVERWRITE_DISABLE
|
2020-09-09 02:06:38 +02:00
|
|
|
#else
|
2022-03-26 21:51:22 +01:00
|
|
|
NOTERAM_MODE_OVERWRITE_ENABLE
|
2020-09-09 02:06:38 +02:00
|
|
|
#endif
|
2020-09-09 02:06:38 +02:00
|
|
|
};
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2022-12-16 11:31:28 +01:00
|
|
|
static const struct note_driver_ops_s g_noteram_ops =
|
|
|
|
{
|
|
|
|
noteram_add
|
|
|
|
};
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static volatile spinlock_t g_noteram_lock;
|
|
|
|
#endif
|
|
|
|
|
2022-12-16 11:31:28 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
struct note_driver_s g_noteram_driver =
|
|
|
|
{
|
|
|
|
&g_noteram_ops,
|
|
|
|
};
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_buffer_clear
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Clear all contents of the circular buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void noteram_buffer_clear(void)
|
|
|
|
{
|
|
|
|
irqstate_t flags;
|
|
|
|
|
|
|
|
flags = enter_critical_section();
|
|
|
|
|
|
|
|
g_noteram_info.ni_tail = g_noteram_info.ni_head;
|
|
|
|
g_noteram_info.ni_read = g_noteram_info.ni_head;
|
|
|
|
|
|
|
|
if (g_noteram_info.ni_overwrite == NOTERAM_MODE_OVERWRITE_OVERFLOW)
|
|
|
|
{
|
|
|
|
g_noteram_info.ni_overwrite = NOTERAM_MODE_OVERWRITE_DISABLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
leave_critical_section(flags);
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_next
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Return the circular buffer index at offset from the specified index
|
|
|
|
* value, handling wraparound
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* ndx - Old circular buffer index
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* New circular buffer index
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static inline unsigned int noteram_next(unsigned int ndx,
|
|
|
|
unsigned int offset)
|
|
|
|
{
|
|
|
|
ndx += offset;
|
|
|
|
if (ndx >= CONFIG_DRIVER_NOTERAM_BUFSIZE)
|
|
|
|
{
|
|
|
|
ndx -= CONFIG_DRIVER_NOTERAM_BUFSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ndx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_length
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Length of data currently in circular buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Length of data currently in circular buffer.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static unsigned int noteram_length(void)
|
|
|
|
{
|
|
|
|
unsigned int head = g_noteram_info.ni_head;
|
|
|
|
unsigned int tail = g_noteram_info.ni_tail;
|
|
|
|
|
|
|
|
if (tail > head)
|
|
|
|
{
|
|
|
|
head += CONFIG_DRIVER_NOTERAM_BUFSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return head - tail;
|
|
|
|
}
|
2020-09-09 02:06:38 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_unread_length
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Length of unread data currently in circular buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Length of unread data currently in circular buffer.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static unsigned int noteram_unread_length(void)
|
|
|
|
{
|
|
|
|
unsigned int head = g_noteram_info.ni_head;
|
|
|
|
unsigned int read = g_noteram_info.ni_read;
|
|
|
|
|
|
|
|
if (read > head)
|
|
|
|
{
|
|
|
|
head += CONFIG_DRIVER_NOTERAM_BUFSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return head - read;
|
|
|
|
}
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_remove
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Remove the variable length note from the tail of the circular buffer
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* We are within a critical section.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void noteram_remove(void)
|
|
|
|
{
|
|
|
|
unsigned int tail;
|
|
|
|
unsigned int length;
|
|
|
|
|
|
|
|
/* Get the tail index of the circular buffer */
|
|
|
|
|
|
|
|
tail = g_noteram_info.ni_tail;
|
|
|
|
DEBUGASSERT(tail < CONFIG_DRIVER_NOTERAM_BUFSIZE);
|
|
|
|
|
|
|
|
/* Get the length of the note at the tail index */
|
|
|
|
|
2021-12-06 04:02:32 +01:00
|
|
|
length = g_noteram_info.ni_buffer[tail];
|
2020-09-08 12:44:29 +02:00
|
|
|
DEBUGASSERT(length <= noteram_length());
|
|
|
|
|
|
|
|
/* Increment the tail index to remove the entire note from the circular
|
|
|
|
* buffer.
|
|
|
|
*/
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
if (g_noteram_info.ni_read == g_noteram_info.ni_tail)
|
|
|
|
{
|
|
|
|
/* The read index also needs increment. */
|
|
|
|
|
|
|
|
g_noteram_info.ni_read = noteram_next(tail, length);
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
g_noteram_info.ni_tail = noteram_next(tail, length);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_get
|
|
|
|
*
|
|
|
|
* Description:
|
2020-09-09 02:06:38 +02:00
|
|
|
* Get the next note from the read index of the circular buffer.
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* buffer - Location to return the next note
|
|
|
|
* buflen - The length of the user provided buffer.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* On success, the positive, non-zero length of the return note is
|
|
|
|
* provided. Zero is returned only if the circular buffer is empty. A
|
|
|
|
* negated errno value is returned in the event of any failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static ssize_t noteram_get(FAR uint8_t *buffer, size_t buflen)
|
|
|
|
{
|
|
|
|
FAR struct note_common_s *note;
|
|
|
|
irqstate_t flags;
|
|
|
|
unsigned int remaining;
|
2020-09-09 02:06:38 +02:00
|
|
|
unsigned int read;
|
2020-09-08 12:44:29 +02:00
|
|
|
ssize_t notelen;
|
|
|
|
size_t circlen;
|
|
|
|
|
|
|
|
DEBUGASSERT(buffer != NULL);
|
|
|
|
flags = enter_critical_section();
|
|
|
|
|
|
|
|
/* Verify that the circular buffer is not empty */
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
circlen = noteram_unread_length();
|
2020-09-08 12:44:29 +02:00
|
|
|
if (circlen <= 0)
|
|
|
|
{
|
|
|
|
notelen = 0;
|
|
|
|
goto errout_with_csection;
|
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Get the read index of the circular buffer */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
read = g_noteram_info.ni_read;
|
2020-10-06 08:23:58 +02:00
|
|
|
DEBUGASSERT(read < CONFIG_DRIVER_NOTERAM_BUFSIZE);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Get the length of the note at the read index */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
note = (FAR struct note_common_s *)&g_noteram_info.ni_buffer[read];
|
2020-09-08 12:44:29 +02:00
|
|
|
notelen = note->nc_length;
|
|
|
|
DEBUGASSERT(notelen <= circlen);
|
|
|
|
|
|
|
|
/* Is the user buffer large enough to hold the note? */
|
|
|
|
|
|
|
|
if (buflen < notelen)
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Skip the large note so that we do not get constipated. */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
g_noteram_info.ni_read = noteram_next(read, notelen);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/* and return an error */
|
|
|
|
|
|
|
|
notelen = -EFBIG;
|
|
|
|
goto errout_with_csection;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Loop until the note has been transferred to the user buffer */
|
|
|
|
|
|
|
|
remaining = (unsigned int)notelen;
|
|
|
|
while (remaining > 0)
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Copy the next byte at the read index */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
*buffer++ = g_noteram_info.ni_buffer[read];
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/* Adjust indices and counts */
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
read = noteram_next(read, 1);
|
2020-09-08 12:44:29 +02:00
|
|
|
remaining--;
|
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
g_noteram_info.ni_read = read;
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
errout_with_csection:
|
|
|
|
leave_critical_section(flags);
|
|
|
|
return notelen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_size
|
|
|
|
*
|
|
|
|
* Description:
|
2020-09-09 02:06:38 +02:00
|
|
|
* Return the size of the next note at the read index of the circular
|
|
|
|
* buffer.
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Zero is returned if the circular buffer is empty. Otherwise, the size
|
|
|
|
* of the next note is returned.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static ssize_t noteram_size(void)
|
|
|
|
{
|
|
|
|
FAR struct note_common_s *note;
|
|
|
|
irqstate_t flags;
|
2020-09-09 02:06:38 +02:00
|
|
|
unsigned int read;
|
2020-09-08 12:44:29 +02:00
|
|
|
ssize_t notelen;
|
|
|
|
size_t circlen;
|
|
|
|
|
|
|
|
flags = enter_critical_section();
|
|
|
|
|
|
|
|
/* Verify that the circular buffer is not empty */
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
circlen = noteram_unread_length();
|
2020-09-08 12:44:29 +02:00
|
|
|
if (circlen <= 0)
|
|
|
|
{
|
|
|
|
notelen = 0;
|
|
|
|
goto errout_with_csection;
|
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Get the read index of the circular buffer */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
read = g_noteram_info.ni_read;
|
2020-10-06 08:23:58 +02:00
|
|
|
DEBUGASSERT(read < CONFIG_DRIVER_NOTERAM_BUFSIZE);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Get the length of the note at the read index */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
note = (FAR struct note_common_s *)&g_noteram_info.ni_buffer[read];
|
2020-09-08 12:44:29 +02:00
|
|
|
notelen = note->nc_length;
|
|
|
|
DEBUGASSERT(notelen <= circlen);
|
|
|
|
|
|
|
|
errout_with_csection:
|
|
|
|
leave_critical_section(flags);
|
|
|
|
return notelen;
|
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_open
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static int noteram_open(FAR struct file *filep)
|
|
|
|
{
|
|
|
|
/* Reset the read index of the circular buffer */
|
|
|
|
|
|
|
|
g_noteram_info.ni_read = g_noteram_info.ni_tail;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_read
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static ssize_t noteram_read(FAR struct file *filep,
|
|
|
|
FAR char *buffer, size_t buflen)
|
|
|
|
{
|
|
|
|
ssize_t notelen;
|
|
|
|
ssize_t retlen ;
|
|
|
|
|
|
|
|
DEBUGASSERT(filep != 0 && buffer != NULL && buflen > 0);
|
|
|
|
|
|
|
|
/* Then loop, adding as many notes as possible to the user buffer. */
|
|
|
|
|
|
|
|
retlen = 0;
|
|
|
|
sched_lock();
|
|
|
|
do
|
|
|
|
{
|
|
|
|
/* Get the next note (removing it from the buffer) */
|
|
|
|
|
|
|
|
notelen = noteram_get((FAR uint8_t *)buffer, buflen);
|
|
|
|
if (notelen < 0)
|
|
|
|
{
|
|
|
|
/* We were unable to read the next note, probably because it will
|
|
|
|
* not fit into the user buffer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (retlen == 0)
|
|
|
|
{
|
|
|
|
/* If nothing was read then report the error. Otherwise,
|
|
|
|
* just silently drop the note.
|
|
|
|
*/
|
|
|
|
|
|
|
|
retlen = notelen;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update pointers from the note that was transferred */
|
|
|
|
|
|
|
|
retlen += notelen;
|
|
|
|
buffer += notelen;
|
|
|
|
buflen -= notelen;
|
|
|
|
|
|
|
|
/* Will the next note fit? There is a race here and even if the next
|
|
|
|
* note will fit, it may fail still when noteram_get() is called.
|
|
|
|
*
|
|
|
|
* It won't fit (or an error occurred). Return what we have without
|
|
|
|
* trying to get the next note (which would cause it to be deleted).
|
|
|
|
*/
|
|
|
|
|
|
|
|
notelen = noteram_size();
|
|
|
|
}
|
|
|
|
while (notelen > 0 && notelen <= buflen);
|
|
|
|
|
|
|
|
sched_unlock();
|
|
|
|
return retlen;
|
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_ioctl
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-12-26 06:18:33 +01:00
|
|
|
static int noteram_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
|
2020-09-09 02:06:38 +02:00
|
|
|
{
|
|
|
|
int ret = -ENOSYS;
|
|
|
|
|
|
|
|
/* Handle the ioctl commands */
|
|
|
|
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
/* NOTERAM_CLEAR
|
|
|
|
* - Clear all contents of the circular buffer
|
|
|
|
* Argument: Ignored
|
|
|
|
*/
|
|
|
|
|
|
|
|
case NOTERAM_CLEAR:
|
|
|
|
noteram_buffer_clear();
|
|
|
|
ret = OK;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* NOTERAM_GETMODE
|
|
|
|
* - Get overwrite mode
|
|
|
|
* Argument: A writable pointer to unsigned int
|
|
|
|
*/
|
|
|
|
|
|
|
|
case NOTERAM_GETMODE:
|
|
|
|
if (arg == 0)
|
|
|
|
{
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*(unsigned int *)arg = g_noteram_info.ni_overwrite;
|
|
|
|
ret = OK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* NOTERAM_SETMODE
|
|
|
|
* - Set overwrite mode
|
|
|
|
* Argument: A read-only pointer to unsigned int
|
|
|
|
*/
|
|
|
|
|
|
|
|
case NOTERAM_SETMODE:
|
|
|
|
if (arg == 0)
|
|
|
|
{
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_noteram_info.ni_overwrite = *(unsigned int *)arg;
|
|
|
|
ret = OK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2022-12-26 06:18:33 +01:00
|
|
|
#ifdef NOTERAM_GETTASKNAME
|
2020-10-28 02:45:30 +01:00
|
|
|
/* NOTERAM_GETTASKNAME
|
|
|
|
* - Get task name string
|
|
|
|
* Argument: A writable pointer to struct note_get_taskname_s
|
|
|
|
* Result: If -ESRCH, the corresponding task name doesn't
|
|
|
|
* exist.
|
|
|
|
*/
|
|
|
|
|
|
|
|
case NOTERAM_GETTASKNAME:
|
|
|
|
{
|
2022-12-26 06:18:33 +01:00
|
|
|
FAR struct noteram_get_taskname_s *param;
|
2020-10-28 02:45:30 +01:00
|
|
|
|
2022-12-26 06:18:33 +01:00
|
|
|
if (arg == 0)
|
2020-10-28 02:45:30 +01:00
|
|
|
{
|
2022-12-26 06:18:33 +01:00
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
2020-10-28 02:45:30 +01:00
|
|
|
}
|
2022-12-26 06:18:33 +01:00
|
|
|
|
|
|
|
param = (FAR struct noteram_get_taskname_s *)arg;
|
|
|
|
ret = note_get_taskname(param->pid, param->taskname);
|
2020-10-28 02:45:30 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
2022-12-16 11:31:28 +01:00
|
|
|
* Name: noteram_add
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Add the variable length note to the transport layer
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* note - The note buffer
|
|
|
|
* notelen - The buffer length
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* We are within a critical section.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-12-16 11:31:28 +01:00
|
|
|
static void noteram_add(FAR struct note_driver_s *drv,
|
|
|
|
FAR const void *note, size_t notelen)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
|
|
|
FAR const char *buf = note;
|
|
|
|
unsigned int head;
|
|
|
|
unsigned int next;
|
2020-09-09 02:06:38 +02:00
|
|
|
irqstate_t flags;
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
flags = up_irq_save();
|
2020-09-08 12:44:29 +02:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
spin_lock_wo_note(&g_noteram_lock);
|
|
|
|
#endif
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
if (g_noteram_info.ni_overwrite == NOTERAM_MODE_OVERWRITE_OVERFLOW)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
spin_unlock_wo_note(&g_noteram_lock);
|
|
|
|
#endif
|
|
|
|
up_irq_restore(flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/* Get the index to the head of the circular buffer */
|
|
|
|
|
|
|
|
DEBUGASSERT(note != NULL && notelen < CONFIG_DRIVER_NOTERAM_BUFSIZE);
|
|
|
|
head = g_noteram_info.ni_head;
|
|
|
|
|
|
|
|
/* Loop until all bytes have been transferred to the circular buffer */
|
|
|
|
|
|
|
|
while (notelen > 0)
|
|
|
|
{
|
|
|
|
/* Get the next head index. Would it collide with the current tail
|
|
|
|
* index?
|
|
|
|
*/
|
|
|
|
|
|
|
|
next = noteram_next(head, 1);
|
|
|
|
if (next == g_noteram_info.ni_tail)
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
if (g_noteram_info.ni_overwrite == NOTERAM_MODE_OVERWRITE_DISABLE)
|
|
|
|
{
|
|
|
|
/* Stop recording if not in overwrite mode */
|
|
|
|
|
|
|
|
g_noteram_info.ni_overwrite = NOTERAM_MODE_OVERWRITE_OVERFLOW;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
spin_unlock_wo_note(&g_noteram_lock);
|
|
|
|
#endif
|
|
|
|
up_irq_restore(flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/* Yes, then remove the note at the tail index */
|
|
|
|
|
|
|
|
noteram_remove();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Save the next byte at the head index */
|
|
|
|
|
|
|
|
g_noteram_info.ni_buffer[head] = *buf++;
|
|
|
|
|
|
|
|
head = next;
|
|
|
|
notelen--;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_noteram_info.ni_head = head;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
spin_unlock_wo_note(&g_noteram_lock);
|
|
|
|
#endif
|
2020-09-09 02:06:38 +02:00
|
|
|
up_irq_restore(flags);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
2022-12-16 11:31:28 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_register
|
|
|
|
*
|
|
|
|
* Description:
|
2022-12-14 05:53:09 +01:00
|
|
|
* Register a serial driver at /dev/note/ram that can be used by an
|
2020-09-08 12:44:29 +02:00
|
|
|
* application to read data from the circular note buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Zero on succress. A negated errno value is returned on a failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int noteram_register(void)
|
|
|
|
{
|
2022-12-14 05:53:09 +01:00
|
|
|
return register_driver("/dev/note/ram", &g_noteram_fops, 0666, NULL);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|