This is an automated email from the ASF dual-hosted git repository.

GUIDINGLI pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git

commit 8955cdfe2e5dc505f399476a10552964654a8e08
Author: likun17 <[email protected]>
AuthorDate: Wed Nov 12 11:30:40 2025 +0800

    drivers/sensors: Let the driver report the effective interval.
    
    When the interval changes while the driver is batching, the driver
    keeps the samples already buffered at the old rate. The upper half
    updates state.min_interval as soon as set_interval() returns, so the
    interval reported to users does not match the data still being
    delivered, and sensor_update_interval() fails with -EINVAL whenever the
    driver chooses an interval larger than requested.
    
    Add sensor_lowerhalf_s::notify_interval(), through which the driver
    reports the interval it actually uses, and forward it through
    sensor_rpmsg. sensor_update_interval() accepts the interval returned by
    the driver, and does not overwrite state.min_interval if the driver
    already reported a new value while the upper lock was released.
    
    Signed-off-by: likun17 <[email protected]>
---
 drivers/sensors/sensor.c       | 46 ++++++++++++++++++++++++++++++------------
 drivers/sensors/sensor_rpmsg.c | 27 +++++++++++++++++--------
 include/nuttx/sensors/sensor.h | 16 ++++++++++++++-
 3 files changed, 67 insertions(+), 22 deletions(-)

diff --git a/drivers/sensors/sensor.c b/drivers/sensors/sensor.c
index 00ec388405a..e11e369720f 100644
--- a/drivers/sensors/sensor.c
+++ b/drivers/sensors/sensor.c
@@ -269,6 +269,17 @@ static void sensor_unlock(FAR void *priv)
   nxrmutex_unlock(&upper->lock);
 }
 
+static void sensor_notify_interval(FAR void *priv, uint32_t interval)
+{
+  FAR struct sensor_upperhalf_s *upper = priv;
+
+  nxrmutex_lock(&upper->lock);
+  upper->state.min_interval = interval;
+  sensor_pollnotify(upper, POLLPRI, SENSOR_ROLE_WR);
+  nxrmutex_unlock(&upper->lock);
+  sminfo(upper->name, "notify interval %" PRIu32, interval);
+}
+
 static int sensor_update_interval(FAR struct file *filep,
                                   FAR struct sensor_upperhalf_s *upper,
                                   FAR struct sensor_user_s *user,
@@ -276,11 +287,11 @@ static int sensor_update_interval(FAR struct file *filep,
 {
   FAR struct sensor_lowerhalf_s *lower = upper->lower;
   FAR struct sensor_user_s *tmp;
-  uint32_t min_interval = interval;
   uint32_t min_latency = interval != UINT32_MAX ?
                          user->state.latency : UINT32_MAX;
-  uint32_t orig_min_interval;
+  uint32_t orig_min_interval = upper->state.min_interval;
   uint32_t orig_min_latency;
+  uint32_t min_interval;
   int ret = 0;
 
   if (interval == user->state.interval)
@@ -290,6 +301,7 @@ static int sensor_update_interval(FAR struct file *filep,
 
   nxrmutex_lock(&upper->lock);
 again:
+  min_interval = interval;
   list_for_every_entry(&upper->userlist, tmp, struct sensor_user_s, node)
     {
       if (tmp == user || tmp->state.interval == UINT32_MAX)
@@ -313,8 +325,6 @@ again:
       if (min_interval != UINT32_MAX &&
           min_interval != upper->state.min_interval)
         {
-          uint32_t expected_interval = min_interval;
-
           orig_min_interval = upper->state.min_interval;
           nxrmutex_unlock(&upper->lock);
           ret = lower->ops->set_interval(lower, filep, &min_interval);
@@ -322,10 +332,6 @@ again:
             {
               return ret;
             }
-          else if (min_interval > expected_interval)
-            {
-              return -EINVAL;
-            }
 
           nxrmutex_lock(&upper->lock);
           sminfo(upper->name, "update interval %" PRIu32, min_interval);
@@ -371,9 +377,22 @@ again:
         }
     }
 
-  upper->state.min_interval = min_interval;
+  /* Intercept updating the upper mini interval when setting up the batch.
+   *   -> set_interval
+   *   -> batch (unlock)
+   *   -> notify_interval
+   *   -> upper->state.min_interval is updated, mini interval still old value
+   * This logic will set the wrong interval for the driver.
+   */
+
+  if (upper->state.min_interval != min_interval &&
+      orig_min_interval != min_interval)
+    {
+      upper->state.min_interval = min_interval;
+      sensor_pollnotify(upper, POLLPRI, SENSOR_ROLE_WR);
+    }
+
   user->state.interval = interval;
-  sensor_pollnotify(upper, POLLPRI, SENSOR_ROLE_WR);
   nxrmutex_unlock(&upper->lock);
   return ret;
 }
@@ -1490,9 +1509,10 @@ int sensor_custom_register(FAR struct sensor_lowerhalf_s 
*lower,
 
   /* Bind the lower half data structure member */
 
-  lower->priv          = upper;
-  lower->sensor_lock   = sensor_lock;
-  lower->sensor_unlock = sensor_unlock;
+  lower->priv            = upper;
+  lower->sensor_lock     = sensor_lock;
+  lower->sensor_unlock   = sensor_unlock;
+  lower->notify_interval = sensor_notify_interval;
 
   if (!lower->ops->fetch)
     {
diff --git a/drivers/sensors/sensor_rpmsg.c b/drivers/sensors/sensor_rpmsg.c
index 62e63c6cbd3..b8ff9950151 100644
--- a/drivers/sensors/sensor_rpmsg.c
+++ b/drivers/sensors/sensor_rpmsg.c
@@ -97,6 +97,7 @@ struct sensor_rpmsg_dev_s
   int16_t                        nsubscribers;
   FAR void                      *upper;
   sensor_push_event_t            push_event;
+  sensor_notify_interval_t       notify_interval;
   FAR const char                *name;
   char                           path[1];
 };
@@ -1164,6 +1165,14 @@ static ssize_t sensor_rpmsg_push_event(FAR void *priv, 
FAR const void *data,
   return ret;
 }
 
+static void
+sensor_rpmsg_notify_interval(FAR void *priv, uint32_t interval)
+{
+  FAR struct sensor_rpmsg_dev_s *dev = priv;
+
+  dev->notify_interval(dev->upper, interval);
+}
+
 static FAR struct sensor_rpmsg_dev_s *
 sensor_rpmsg_find_dev(FAR const char *path)
 {
@@ -1698,15 +1707,17 @@ sensor_rpmsg_register(FAR struct sensor_lowerhalf_s 
*lower,
   list_initialize(&dev->proxylist);
   strlcpy(dev->path, path, size + 1);
 
-  dev->name           = basename(dev->path);
-  dev->nadvertisers   = lower->ops->activate ? 1 : -1;
-  dev->push_event     = lower->push_event;
-  dev->upper          = lower->priv;
-  lower->push_event   = sensor_rpmsg_push_event;
-  lower->priv         = dev;
+  dev->name              = basename(dev->path);
+  dev->nadvertisers      = lower->ops->activate ? 1 : -1;
+  dev->push_event        = lower->push_event;
+  dev->notify_interval   = lower->notify_interval;
+  dev->upper             = lower->priv;
+  lower->push_event      = sensor_rpmsg_push_event;
+  lower->notify_interval = sensor_rpmsg_notify_interval;
+  lower->priv            = dev;
   memcpy(&dev->lower, lower, sizeof(*lower));
-  dev->lower.ops      = &g_sensor_rpmsg_ops;
-  dev->drv            = lower;
+  dev->lower.ops         = &g_sensor_rpmsg_ops;
+  dev->drv               = lower;
 
   /* If openamp is ready, send advertisement to remote proc */
 
diff --git a/include/nuttx/sensors/sensor.h b/include/nuttx/sensors/sensor.h
index 7f981e0d019..7b72be5dfc2 100644
--- a/include/nuttx/sensors/sensor.h
+++ b/include/nuttx/sensors/sensor.h
@@ -550,7 +550,8 @@ typedef CODE ssize_t (*sensor_push_event_t)(FAR void *priv,
                                             FAR const void *data,
                                             size_t bytes);
 typedef CODE void (*sensor_notify_event_t)(FAR void *priv);
-
+typedef CODE void (*sensor_notify_interval_t)(FAR void *priv,
+                                              uint32_t interval);
 struct sensor_lowerhalf_s
 {
   /* The type of sensor device */
@@ -616,6 +617,19 @@ struct sensor_lowerhalf_s
       sensor_notify_event_t notify_event;
     };
 
+/****************************************************************************
+ * Name: notify_interval
+ *
+ * Description:
+ *   Lower half driver can notify upper half driver when interval changed.
+ *
+ * Input Parameters:
+ *   priv       - Upper half driver handle
+ *   interval   - The changed interval of the driver
+ ****************************************************************************/
+
+  sensor_notify_interval_t notify_interval;
+
 /****************************************************************************
  * Name: sensor_lock/sensor_unlock
  *

Reply via email to