2020-10-19 15:24:13 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* drivers/sensors/sensor.c
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2021-05-18 08:59:14 +02:00
|
|
|
#include <assert.h>
|
2020-10-19 15:24:13 +02:00
|
|
|
#include <errno.h>
|
|
|
|
#include <debug.h>
|
|
|
|
|
|
|
|
#include <poll.h>
|
|
|
|
#include <fcntl.h>
|
2022-03-22 08:46:02 +01:00
|
|
|
#include <nuttx/list.h>
|
2020-10-19 15:24:13 +02:00
|
|
|
#include <nuttx/kmalloc.h>
|
2020-11-12 11:40:37 +01:00
|
|
|
#include <nuttx/mm/circbuf.h>
|
2022-06-14 05:33:13 +02:00
|
|
|
#include <nuttx/mutex.h>
|
2020-10-19 15:24:13 +02:00
|
|
|
#include <nuttx/sensors/sensor.h>
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Pre-processor Definitions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/* Device naming ************************************************************/
|
|
|
|
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
#define ROUND_DOWN(x, y) (((x) / (y)) * (y))
|
2022-08-08 07:42:03 +02:00
|
|
|
#define DEVNAME_FMT "/dev/uorb/sensor_%s%s%d"
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
#define DEVNAME_UNCAL "_uncal"
|
|
|
|
#define TIMING_BUF_ESIZE (sizeof(unsigned long))
|
2020-10-19 15:24:13 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Types
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/* This structure describes sensor info */
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
struct sensor_info_s
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-23 10:09:46 +01:00
|
|
|
unsigned long esize;
|
2020-11-02 11:02:04 +01:00
|
|
|
FAR char *name;
|
2020-10-19 15:24:13 +02:00
|
|
|
};
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
/* This structure describes user info of sensor, the user may be
|
|
|
|
* advertiser or subscriber
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct sensor_user_s
|
|
|
|
{
|
|
|
|
/* The common info */
|
|
|
|
|
|
|
|
struct list_node node; /* Node of users list */
|
|
|
|
struct pollfd *fds; /* The poll structure of thread waiting events */
|
|
|
|
bool changed; /* This is used to indicate event happens and need to
|
|
|
|
* asynchronous notify other users
|
|
|
|
*/
|
|
|
|
sem_t buffersem; /* Wakeup user waiting for data in circular buffer */
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
size_t bufferpos; /* The index of user generation in buffer */
|
2022-03-22 08:46:02 +01:00
|
|
|
|
|
|
|
/* The subscriber info
|
|
|
|
* Support multi advertisers to subscribe their own data when they
|
|
|
|
* appear in dual role
|
|
|
|
*/
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
struct sensor_ustate_s state;
|
2022-03-22 08:46:02 +01:00
|
|
|
};
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
/* This structure describes the state of the upper half driver */
|
|
|
|
|
|
|
|
struct sensor_upperhalf_s
|
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_lowerhalf_s *lower; /* The handle of lower half driver */
|
|
|
|
struct sensor_state_s state; /* The state of sensor device */
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
struct circbuf_s timing; /* The circular buffer of generation */
|
|
|
|
struct circbuf_s buffer; /* The circular buffer of data */
|
2022-06-14 05:33:13 +02:00
|
|
|
rmutex_t lock; /* Manages exclusive access to file operations */
|
2022-03-22 08:46:02 +01:00
|
|
|
struct list_node userlist; /* List of users */
|
2020-10-19 15:24:13 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Function Prototypes
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void sensor_pollnotify(FAR struct sensor_upperhalf_s *upper,
|
|
|
|
pollevent_t eventset);
|
|
|
|
static int sensor_open(FAR struct file *filep);
|
|
|
|
static int sensor_close(FAR struct file *filep);
|
|
|
|
static ssize_t sensor_read(FAR struct file *filep, FAR char *buffer,
|
|
|
|
size_t buflen);
|
2022-03-11 10:05:47 +01:00
|
|
|
static ssize_t sensor_write(FAR struct file *filep, FAR const char *buffer,
|
|
|
|
size_t buflen);
|
2020-10-19 15:24:13 +02:00
|
|
|
static int sensor_ioctl(FAR struct file *filep, int cmd,
|
|
|
|
unsigned long arg);
|
|
|
|
static int sensor_poll(FAR struct file *filep, FAR struct pollfd *fds,
|
|
|
|
bool setup);
|
2022-03-11 10:05:47 +01:00
|
|
|
static ssize_t sensor_push_event(FAR void *priv, FAR const void *data,
|
|
|
|
size_t bytes);
|
2020-10-19 15:24:13 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
static const struct sensor_info_s g_sensor_info[] =
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-23 10:09:46 +01:00
|
|
|
{0, NULL},
|
|
|
|
{sizeof(struct sensor_accel), "accel"},
|
|
|
|
{sizeof(struct sensor_mag), "mag"},
|
|
|
|
{sizeof(struct sensor_gyro), "gyro"},
|
|
|
|
{sizeof(struct sensor_light), "light"},
|
|
|
|
{sizeof(struct sensor_baro), "baro"},
|
|
|
|
{sizeof(struct sensor_prox), "prox"},
|
|
|
|
{sizeof(struct sensor_humi), "humi"},
|
|
|
|
{sizeof(struct sensor_temp), "temp"},
|
|
|
|
{sizeof(struct sensor_rgb), "rgb"},
|
|
|
|
{sizeof(struct sensor_hall), "hall"},
|
|
|
|
{sizeof(struct sensor_ir), "ir"},
|
|
|
|
{sizeof(struct sensor_gps), "gps"},
|
|
|
|
{sizeof(struct sensor_uv), "uv"},
|
|
|
|
{sizeof(struct sensor_noise), "noise"},
|
|
|
|
{sizeof(struct sensor_pm25), "pm25"},
|
|
|
|
{sizeof(struct sensor_pm1p0), "pm1p0"},
|
|
|
|
{sizeof(struct sensor_pm10), "pm10"},
|
|
|
|
{sizeof(struct sensor_co2), "co2"},
|
|
|
|
{sizeof(struct sensor_hcho), "hcho"},
|
|
|
|
{sizeof(struct sensor_tvoc), "tvoc"},
|
|
|
|
{sizeof(struct sensor_ph), "ph"},
|
|
|
|
{sizeof(struct sensor_dust), "dust"},
|
|
|
|
{sizeof(struct sensor_hrate), "hrate"},
|
|
|
|
{sizeof(struct sensor_hbeat), "hbeat"},
|
|
|
|
{sizeof(struct sensor_ecg), "ecg"},
|
|
|
|
{sizeof(struct sensor_ppgd), "ppgd"},
|
|
|
|
{sizeof(struct sensor_ppgq), "ppgq"},
|
|
|
|
{sizeof(struct sensor_impd), "impd"},
|
|
|
|
{sizeof(struct sensor_ots), "ots"},
|
|
|
|
{sizeof(struct sensor_gps_satellite), "gps_satellite"},
|
|
|
|
{sizeof(struct sensor_wake_gesture), "wake_gesture"},
|
|
|
|
{sizeof(struct sensor_cap), "cap"},
|
2023-02-27 07:23:46 +01:00
|
|
|
{sizeof(struct sensor_gas), "gas"},
|
|
|
|
{sizeof(struct sensor_force), "force"},
|
2020-10-19 15:24:13 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct file_operations g_sensor_fops =
|
|
|
|
{
|
|
|
|
sensor_open, /* open */
|
|
|
|
sensor_close, /* close */
|
|
|
|
sensor_read, /* read */
|
2022-03-11 10:05:47 +01:00
|
|
|
sensor_write, /* write */
|
2020-10-19 15:24:13 +02:00
|
|
|
NULL, /* seek */
|
|
|
|
sensor_ioctl, /* ioctl */
|
2023-01-02 14:02:51 +01:00
|
|
|
NULL, /* mmap */
|
2023-01-02 18:06:12 +01:00
|
|
|
NULL, /* truncate */
|
2020-10-19 15:24:13 +02:00
|
|
|
sensor_poll /* poll */
|
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-06-23 06:13:56 +02:00
|
|
|
static void sensor_lock(FAR void *priv)
|
|
|
|
{
|
|
|
|
FAR struct sensor_upperhalf_s *upper = priv;
|
|
|
|
nxrmutex_lock(&upper->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sensor_unlock(FAR void *priv)
|
|
|
|
{
|
|
|
|
FAR struct sensor_upperhalf_s *upper = priv;
|
|
|
|
nxrmutex_unlock(&upper->lock);
|
|
|
|
}
|
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
static int sensor_update_interval(FAR struct file *filep,
|
|
|
|
FAR struct sensor_upperhalf_s *upper,
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user,
|
|
|
|
unsigned long interval)
|
|
|
|
{
|
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
|
|
|
FAR struct sensor_user_s *tmp;
|
|
|
|
unsigned long min_interval = interval;
|
2022-06-15 06:17:51 +02:00
|
|
|
unsigned long min_latency = interval != ULONG_MAX ?
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.latency : ULONG_MAX;
|
2022-03-22 08:46:02 +01:00
|
|
|
int ret = 0;
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
if (interval == user->state.interval)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_every_entry(&upper->userlist, tmp, struct sensor_user_s, node)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
if (tmp == user || tmp->state.interval == ULONG_MAX)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
continue;
|
|
|
|
}
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
if (min_interval > tmp->state.interval)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
min_interval = tmp->state.interval;
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
2020-11-04 14:31:30 +01:00
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
if (min_latency > tmp->state.latency)
|
2022-06-15 06:17:51 +02:00
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
min_latency = tmp->state.latency;
|
2022-06-15 06:17:51 +02:00
|
|
|
}
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
|
|
|
|
2022-06-15 06:17:51 +02:00
|
|
|
if (lower->ops->set_interval)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-06-15 06:17:51 +02:00
|
|
|
if (min_interval != ULONG_MAX &&
|
|
|
|
min_interval != upper->state.min_interval)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-06-25 11:12:39 +02:00
|
|
|
unsigned long expected_interval = min_interval;
|
2022-06-15 06:17:51 +02:00
|
|
|
ret = lower->ops->set_interval(lower, filep, &min_interval);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
2022-06-25 11:12:39 +02:00
|
|
|
else if (min_interval > expected_interval)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2022-06-15 06:17:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (min_latency == ULONG_MAX)
|
|
|
|
{
|
|
|
|
min_latency = 0;
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
2022-06-16 08:26:42 +02:00
|
|
|
|
2022-06-15 06:17:51 +02:00
|
|
|
if (lower->ops->batch &&
|
|
|
|
(min_latency != upper->state.min_latency ||
|
|
|
|
(min_interval != upper->state.min_interval && min_latency)))
|
2022-06-16 08:26:42 +02:00
|
|
|
{
|
2022-06-15 06:17:51 +02:00
|
|
|
ret = lower->ops->batch(lower, filep, &min_latency);
|
|
|
|
if (ret >= 0)
|
|
|
|
{
|
|
|
|
upper->state.min_latency = min_latency;
|
|
|
|
}
|
2022-06-16 08:26:42 +02:00
|
|
|
}
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
2022-03-22 08:46:02 +01:00
|
|
|
|
|
|
|
upper->state.min_interval = min_interval;
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.interval = interval;
|
2022-03-22 08:46:02 +01:00
|
|
|
sensor_pollnotify(upper, POLLPRI);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
static int sensor_update_latency(FAR struct file *filep,
|
|
|
|
FAR struct sensor_upperhalf_s *upper,
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user,
|
|
|
|
unsigned long latency)
|
|
|
|
{
|
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
|
|
|
FAR struct sensor_user_s *tmp;
|
|
|
|
unsigned long min_latency = latency;
|
|
|
|
int ret = 0;
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
if (latency == user->state.latency)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-06-15 06:17:51 +02:00
|
|
|
return 0;
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
if (user->state.interval == ULONG_MAX)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.latency = latency;
|
2022-03-22 08:46:02 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (latency <= upper->state.min_latency)
|
|
|
|
{
|
|
|
|
goto update;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_every_entry(&upper->userlist, tmp, struct sensor_user_s, node)
|
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
if (tmp == user || tmp->state.interval == ULONG_MAX)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
if (min_latency > tmp->state.latency)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
min_latency = tmp->state.latency;
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
update:
|
2022-06-15 06:17:51 +02:00
|
|
|
if (min_latency == ULONG_MAX)
|
|
|
|
{
|
|
|
|
min_latency = 0;
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
if (min_latency == upper->state.min_latency)
|
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.latency = latency;
|
2022-03-22 08:46:02 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-06-15 06:17:51 +02:00
|
|
|
if (lower->ops->batch)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = lower->ops->batch(lower, filep, &min_latency);
|
2022-03-22 08:46:02 +01:00
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
upper->state.min_latency = min_latency;
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.latency = latency;
|
2022-03-22 08:46:02 +01:00
|
|
|
sensor_pollnotify(upper, POLLPRI);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
static void sensor_generate_timing(FAR struct sensor_upperhalf_s *upper,
|
|
|
|
unsigned long nums)
|
|
|
|
{
|
|
|
|
unsigned long interval = upper->state.min_interval != ULONG_MAX ?
|
|
|
|
upper->state.min_interval : 1;
|
|
|
|
while (nums-- > 0)
|
|
|
|
{
|
|
|
|
upper->state.generation += interval;
|
|
|
|
circbuf_overwrite(&upper->timing, &upper->state.generation,
|
|
|
|
TIMING_BUF_ESIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool sensor_is_updated(FAR struct sensor_upperhalf_s *upper,
|
|
|
|
FAR struct sensor_user_s *user)
|
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
long delta = upper->state.generation - user->state.generation;
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
|
|
|
|
if (delta <= 0)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2022-06-29 11:34:55 +02:00
|
|
|
else if (user->state.interval == ULONG_MAX)
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Check whether next generation user want in buffer.
|
|
|
|
* generation next generation(not published yet)
|
|
|
|
* ____v_____________v
|
|
|
|
* ////|//////^ |
|
|
|
|
* ^ middle point
|
|
|
|
* next generation user want
|
|
|
|
*/
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
return delta >= user->state.interval -
|
|
|
|
(upper->state.min_interval >> 1);
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sensor_catch_up(FAR struct sensor_upperhalf_s *upper,
|
|
|
|
FAR struct sensor_user_s *user)
|
|
|
|
{
|
|
|
|
unsigned long generation;
|
|
|
|
long delta;
|
|
|
|
|
|
|
|
circbuf_peek(&upper->timing, &generation, TIMING_BUF_ESIZE);
|
2022-06-29 11:34:55 +02:00
|
|
|
delta = generation - user->state.generation;
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
if (delta > 0)
|
|
|
|
{
|
|
|
|
user->bufferpos = upper->timing.tail / TIMING_BUF_ESIZE;
|
2022-06-29 11:34:55 +02:00
|
|
|
if (user->state.interval == ULONG_MAX)
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.generation = generation - 1;
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
delta -= upper->state.min_interval >> 1;
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.generation += ROUND_DOWN(delta,
|
|
|
|
user->state.interval);
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t sensor_do_samples(FAR struct sensor_upperhalf_s *upper,
|
|
|
|
FAR struct sensor_user_s *user,
|
|
|
|
FAR char *buffer, size_t len)
|
|
|
|
{
|
|
|
|
unsigned long generation;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
size_t nums;
|
|
|
|
size_t pos;
|
|
|
|
size_t end;
|
|
|
|
|
|
|
|
sensor_catch_up(upper, user);
|
|
|
|
nums = upper->timing.head / TIMING_BUF_ESIZE - user->bufferpos;
|
|
|
|
if (len < nums * upper->state.esize)
|
|
|
|
{
|
|
|
|
nums = len / upper->state.esize;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = nums * upper->state.esize;
|
|
|
|
|
|
|
|
/* Take samples continuously */
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
if (user->state.interval == ULONG_MAX)
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
{
|
|
|
|
ret = circbuf_peekat(&upper->buffer,
|
|
|
|
user->bufferpos * upper->state.esize,
|
|
|
|
buffer, len);
|
|
|
|
user->bufferpos += nums;
|
|
|
|
circbuf_peekat(&upper->timing,
|
|
|
|
(user->bufferpos - 1) * TIMING_BUF_ESIZE,
|
2022-06-29 11:34:55 +02:00
|
|
|
&user->state.generation, TIMING_BUF_ESIZE);
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Take samples one-bye-one, to determine whether a sample needed:
|
|
|
|
*
|
|
|
|
* If user's next generation is on the left side of middle point,
|
|
|
|
* we should copy this sample for user.
|
|
|
|
* next_generation(or end)
|
|
|
|
* ________________v____
|
|
|
|
* timing buffer: //|//////. |
|
|
|
|
* ^ middle
|
|
|
|
* generation
|
|
|
|
* next sample(or end)
|
|
|
|
* ________________v____
|
|
|
|
* data buffer: | |
|
|
|
|
* ^
|
|
|
|
* sample
|
|
|
|
*/
|
|
|
|
|
|
|
|
pos = user->bufferpos;
|
|
|
|
end = upper->timing.head / TIMING_BUF_ESIZE;
|
|
|
|
circbuf_peekat(&upper->timing, pos * TIMING_BUF_ESIZE,
|
|
|
|
&generation, TIMING_BUF_ESIZE);
|
|
|
|
while (pos++ != end)
|
|
|
|
{
|
|
|
|
unsigned long next_generation;
|
|
|
|
long delta;
|
|
|
|
|
|
|
|
if (pos * TIMING_BUF_ESIZE == upper->timing.head)
|
|
|
|
{
|
|
|
|
next_generation = upper->state.generation +
|
|
|
|
upper->state.min_interval;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
circbuf_peekat(&upper->timing, pos * TIMING_BUF_ESIZE,
|
|
|
|
&next_generation, TIMING_BUF_ESIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
delta = next_generation + generation -
|
2022-06-29 11:34:55 +02:00
|
|
|
((user->state.generation + user->state.interval) << 1);
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
if (delta >= 0)
|
|
|
|
{
|
|
|
|
ret += circbuf_peekat(&upper->buffer,
|
|
|
|
(pos - 1) * upper->state.esize,
|
|
|
|
buffer + ret, upper->state.esize);
|
|
|
|
user->bufferpos = pos;
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.generation += user->state.interval;
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
if (ret >= len)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
generation = next_generation;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
static void sensor_pollnotify_one(FAR struct sensor_user_s *user,
|
|
|
|
pollevent_t eventset)
|
|
|
|
{
|
|
|
|
if (eventset == POLLPRI)
|
|
|
|
{
|
|
|
|
user->changed = true;
|
|
|
|
}
|
|
|
|
|
2022-09-19 05:08:57 +02:00
|
|
|
poll_notify(&user->fds, 1, eventset);
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sensor_pollnotify(FAR struct sensor_upperhalf_s *upper,
|
|
|
|
pollevent_t eventset)
|
|
|
|
{
|
|
|
|
FAR struct sensor_user_s *user;
|
|
|
|
|
|
|
|
list_for_every_entry(&upper->userlist, user, struct sensor_user_s, node)
|
|
|
|
{
|
|
|
|
sensor_pollnotify_one(user, eventset);
|
|
|
|
}
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sensor_open(FAR struct file *filep)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct sensor_upperhalf_s *upper = inode->i_private;
|
2020-11-12 11:40:37 +01:00
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user;
|
2022-04-29 17:08:59 +02:00
|
|
|
int ret = 0;
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-03-22 08:46:02 +01:00
|
|
|
user = kmm_zalloc(sizeof(struct sensor_user_s));
|
|
|
|
if (user == NULL)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
ret = -ENOMEM;
|
2022-09-06 08:18:45 +02:00
|
|
|
goto errout_with_lock;
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
2020-11-04 14:31:30 +01:00
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
if (lower->ops->open)
|
|
|
|
{
|
|
|
|
ret = lower->ops->open(lower, filep);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
goto errout_with_user;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
if (filep->f_oflags & O_RDOK)
|
|
|
|
{
|
|
|
|
if (upper->state.nsubscribers == 0 && lower->ops->activate)
|
|
|
|
{
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = lower->ops->activate(lower, filep, true);
|
2022-03-22 08:46:02 +01:00
|
|
|
if (ret < 0)
|
|
|
|
{
|
2022-04-13 08:00:08 +02:00
|
|
|
goto errout_with_open;
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
upper->state.nsubscribers++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filep->f_oflags & O_WROK)
|
|
|
|
{
|
|
|
|
upper->state.nadvertisers++;
|
2022-05-21 11:50:29 +02:00
|
|
|
if (filep->f_oflags & SENSOR_PERSIST)
|
|
|
|
{
|
|
|
|
lower->persist = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (upper->state.generation && lower->persist)
|
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.generation = upper->state.generation - 1;
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
user->bufferpos = upper->timing.head / TIMING_BUF_ESIZE - 1;
|
2022-05-21 11:50:29 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.generation = upper->state.generation;
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
user->bufferpos = upper->timing.head / TIMING_BUF_ESIZE;
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
user->state.interval = ULONG_MAX;
|
|
|
|
user->state.esize = upper->state.esize;
|
2022-03-22 08:46:02 +01:00
|
|
|
nxsem_init(&user->buffersem, 0, 0);
|
|
|
|
list_add_tail(&upper->userlist, &user->node);
|
|
|
|
|
|
|
|
/* The new user generation, notify to other users */
|
|
|
|
|
|
|
|
sensor_pollnotify(upper, POLLPRI);
|
|
|
|
|
|
|
|
filep->f_priv = user;
|
2022-09-06 08:18:45 +02:00
|
|
|
goto errout_with_lock;
|
2022-03-22 08:46:02 +01:00
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
errout_with_open:
|
|
|
|
if (lower->ops->close)
|
|
|
|
{
|
|
|
|
lower->ops->close(lower, filep);
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
errout_with_user:
|
|
|
|
kmm_free(user);
|
2022-09-06 08:18:45 +02:00
|
|
|
errout_with_lock:
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sensor_close(FAR struct file *filep)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct sensor_upperhalf_s *upper = inode->i_private;
|
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user = filep->f_priv;
|
2022-04-29 17:08:59 +02:00
|
|
|
int ret = 0;
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-04-13 08:00:08 +02:00
|
|
|
if (lower->ops->close)
|
|
|
|
{
|
|
|
|
ret = lower->ops->close(lower, filep);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2022-04-13 08:00:08 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
if (filep->f_oflags & O_RDOK)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
upper->state.nsubscribers--;
|
|
|
|
if (upper->state.nsubscribers == 0 && lower->ops->activate)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-04-13 08:00:08 +02:00
|
|
|
lower->ops->activate(lower, filep, false);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
if (filep->f_oflags & O_WROK)
|
|
|
|
{
|
|
|
|
upper->state.nadvertisers--;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_delete(&user->node);
|
2022-04-13 08:00:08 +02:00
|
|
|
sensor_update_latency(filep, upper, user, ULONG_MAX);
|
|
|
|
sensor_update_interval(filep, upper, user, ULONG_MAX);
|
2022-03-22 08:46:02 +01:00
|
|
|
nxsem_destroy(&user->buffersem);
|
|
|
|
|
|
|
|
/* The user is closed, notify to other users */
|
|
|
|
|
|
|
|
sensor_pollnotify(upper, POLLPRI);
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2022-03-22 08:46:02 +01:00
|
|
|
|
|
|
|
kmm_free(user);
|
2020-10-19 15:24:13 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t sensor_read(FAR struct file *filep, FAR char *buffer,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct sensor_upperhalf_s *upper = inode->i_private;
|
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user = filep->f_priv;
|
2020-10-19 15:24:13 +02:00
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
if (!buffer || !len)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2020-11-04 04:23:39 +01:00
|
|
|
if (lower->ops->fetch)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2020-11-04 04:23:39 +01:00
|
|
|
if (!(filep->f_oflags & O_NONBLOCK))
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2022-03-22 08:46:02 +01:00
|
|
|
ret = nxsem_wait_uninterruptible(&user->buffersem);
|
2020-11-04 04:23:39 +01:00
|
|
|
if (ret < 0)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
2022-03-22 08:46:02 +01:00
|
|
|
else if (!upper->state.nsubscribers)
|
2021-02-07 10:13:31 +01:00
|
|
|
{
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
2020-11-04 04:23:39 +01:00
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = lower->ops->fetch(lower, filep, buffer, len);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
else if (circbuf_is_empty(&upper->buffer))
|
2020-11-04 04:23:39 +01:00
|
|
|
{
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
ret = -ENODATA;
|
|
|
|
}
|
|
|
|
else if (sensor_is_updated(upper, user))
|
|
|
|
{
|
|
|
|
ret = sensor_do_samples(upper, user, buffer, len);
|
|
|
|
}
|
|
|
|
else if (lower->persist)
|
|
|
|
{
|
|
|
|
/* Persistent device can get latest old data if not updated. */
|
2022-03-22 08:46:02 +01:00
|
|
|
|
2022-03-23 10:09:46 +01:00
|
|
|
ret = circbuf_peekat(&upper->buffer,
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
(user->bufferpos - 1) * upper->state.esize,
|
|
|
|
buffer, upper->state.esize);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ENODATA;
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
2021-02-07 10:13:31 +01:00
|
|
|
out:
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-11 10:05:47 +01:00
|
|
|
static ssize_t sensor_write(FAR struct file *filep, FAR const char *buffer,
|
|
|
|
size_t buflen)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct sensor_upperhalf_s *upper = inode->i_private;
|
2022-04-08 16:46:29 +02:00
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
2022-03-11 10:05:47 +01:00
|
|
|
|
2022-04-08 16:46:29 +02:00
|
|
|
return lower->push_event(lower->priv, buffer, buflen);
|
2022-03-11 10:05:47 +01:00
|
|
|
}
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
static int sensor_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct sensor_upperhalf_s *upper = inode->i_private;
|
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user = filep->f_priv;
|
2022-04-29 17:08:59 +02:00
|
|
|
int ret = 0;
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2020-11-24 23:12:02 +01:00
|
|
|
sninfo("cmd=%x arg=%08lx\n", cmd, arg);
|
2020-10-19 15:24:13 +02:00
|
|
|
|
|
|
|
switch (cmd)
|
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
case SNIOC_GET_STATE:
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-03-22 08:46:02 +01:00
|
|
|
memcpy((FAR void *)(uintptr_t)arg,
|
|
|
|
&upper->state, sizeof(upper->state));
|
|
|
|
user->changed = false;
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2022-06-29 11:34:55 +02:00
|
|
|
case SNIOC_GET_USTATE:
|
|
|
|
{
|
|
|
|
nxrmutex_lock(&upper->lock);
|
|
|
|
memcpy((FAR void *)(uintptr_t)arg,
|
|
|
|
&user->state, sizeof(user->state));
|
|
|
|
nxrmutex_unlock(&upper->lock);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
case SNIOC_SET_INTERVAL:
|
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-06-15 15:26:09 +02:00
|
|
|
ret = sensor_update_interval(filep, upper, user,
|
|
|
|
arg ? arg : ULONG_MAX);
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNIOC_BATCH:
|
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = sensor_update_latency(filep, upper, user, arg);
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2021-09-27 14:16:15 +02:00
|
|
|
case SNIOC_SELFTEST:
|
|
|
|
{
|
|
|
|
if (lower->ops->selftest == NULL)
|
|
|
|
{
|
|
|
|
ret = -ENOTSUP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = lower->ops->selftest(lower, filep, arg);
|
2021-09-27 14:16:15 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2021-11-09 13:37:27 +01:00
|
|
|
case SNIOC_SET_CALIBVALUE:
|
|
|
|
{
|
|
|
|
if (lower->ops->set_calibvalue == NULL)
|
|
|
|
{
|
|
|
|
ret = -ENOTSUP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = lower->ops->set_calibvalue(lower, filep, arg);
|
2021-11-09 13:37:27 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2022-07-21 04:47:12 +02:00
|
|
|
case SNIOC_CALIBRATE:
|
|
|
|
{
|
|
|
|
if (lower->ops->calibrate == NULL)
|
|
|
|
{
|
|
|
|
ret = -ENOTSUP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = lower->ops->calibrate(lower, filep, arg);
|
2022-07-21 04:47:12 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2022-03-23 10:09:46 +01:00
|
|
|
case SNIOC_SET_USERPRIV:
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-03-23 10:09:46 +01:00
|
|
|
upper->state.priv = (FAR void *)(uintptr_t)arg;
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-11-04 14:31:30 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2021-02-08 09:26:25 +01:00
|
|
|
case SNIOC_SET_BUFFER_NUMBER:
|
2020-11-04 14:31:30 +01:00
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-07-21 04:32:29 +02:00
|
|
|
if (!circbuf_is_init(&upper->buffer))
|
2020-11-04 14:31:30 +01:00
|
|
|
{
|
2022-03-23 10:09:46 +01:00
|
|
|
if (arg >= lower->nbuffer)
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
2022-03-23 10:09:46 +01:00
|
|
|
lower->nbuffer = arg;
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ERANGE;
|
|
|
|
}
|
2022-07-21 04:32:29 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -EBUSY;
|
2020-11-04 14:31:30 +01:00
|
|
|
}
|
2022-04-29 17:08:59 +02:00
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2022-06-28 09:50:37 +02:00
|
|
|
case SNIOC_UPDATED:
|
2022-04-26 08:01:11 +02:00
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
*(FAR bool *)(uintptr_t)arg = sensor_is_updated(upper, user);
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2022-04-26 08:01:11 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
default:
|
2020-11-04 14:31:30 +01:00
|
|
|
|
|
|
|
/* Lowerhalf driver process other cmd. */
|
|
|
|
|
|
|
|
if (lower->ops->control)
|
|
|
|
{
|
2022-04-13 08:00:08 +02:00
|
|
|
ret = lower->ops->control(lower, filep, cmd, arg);
|
2020-11-04 14:31:30 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -ENOTTY;
|
|
|
|
}
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sensor_poll(FAR struct file *filep,
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct pollfd *fds, bool setup)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
|
|
|
FAR struct inode *inode = filep->f_inode;
|
|
|
|
FAR struct sensor_upperhalf_s *upper = inode->i_private;
|
2020-11-04 04:23:39 +01:00
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user = filep->f_priv;
|
2020-10-19 15:24:13 +02:00
|
|
|
pollevent_t eventset = 0;
|
2020-11-04 04:23:39 +01:00
|
|
|
int semcount;
|
2022-04-29 17:08:59 +02:00
|
|
|
int ret = 0;
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
if (setup)
|
|
|
|
{
|
2020-11-04 14:31:30 +01:00
|
|
|
/* Don't have enough space to store fds */
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
if (user->fds)
|
2020-11-04 14:31:30 +01:00
|
|
|
{
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto errout;
|
|
|
|
}
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
user->fds = fds;
|
|
|
|
fds->priv = filep;
|
2020-11-04 04:23:39 +01:00
|
|
|
if (lower->ops->fetch)
|
|
|
|
{
|
|
|
|
/* Always return POLLIN for fetch data directly(non-block) */
|
|
|
|
|
|
|
|
if (filep->f_oflags & O_NONBLOCK)
|
|
|
|
{
|
2022-09-19 05:08:57 +02:00
|
|
|
eventset |= POLLIN;
|
2020-11-04 04:23:39 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
nxsem_get_value(&user->buffersem, &semcount);
|
2020-11-04 04:23:39 +01:00
|
|
|
if (semcount > 0)
|
|
|
|
{
|
2022-09-19 05:08:57 +02:00
|
|
|
eventset |= POLLIN;
|
2020-11-04 04:23:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
else if (sensor_is_updated(upper, user))
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-09-19 05:08:57 +02:00
|
|
|
eventset |= POLLIN;
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
if (user->changed)
|
|
|
|
{
|
2022-09-19 05:08:57 +02:00
|
|
|
eventset |= POLLPRI;
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
|
|
|
|
2022-09-19 05:08:57 +02:00
|
|
|
sensor_pollnotify_one(user, eventset);
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
2022-03-22 08:46:02 +01:00
|
|
|
else
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
user->fds = NULL;
|
|
|
|
fds->priv = NULL;
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
errout:
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-11 10:05:47 +01:00
|
|
|
static ssize_t sensor_push_event(FAR void *priv, FAR const void *data,
|
|
|
|
size_t bytes)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
|
|
|
FAR struct sensor_upperhalf_s *upper = priv;
|
2022-07-21 04:32:29 +02:00
|
|
|
FAR struct sensor_lowerhalf_s *lower = upper->lower;
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user;
|
2022-03-23 10:09:46 +01:00
|
|
|
unsigned long envcount;
|
2020-10-19 15:24:13 +02:00
|
|
|
int semcount;
|
2022-03-11 10:05:47 +01:00
|
|
|
int ret;
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-03-23 10:09:46 +01:00
|
|
|
envcount = bytes / upper->state.esize;
|
|
|
|
if (!envcount || bytes != envcount * upper->state.esize)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-11 10:05:47 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-07-21 04:32:29 +02:00
|
|
|
if (!circbuf_is_init(&upper->buffer))
|
|
|
|
{
|
|
|
|
/* Initialize sensor buffer when data is first generated */
|
|
|
|
|
2022-03-23 10:09:46 +01:00
|
|
|
ret = circbuf_init(&upper->buffer, NULL, lower->nbuffer *
|
|
|
|
upper->state.esize);
|
2022-07-21 04:32:29 +02:00
|
|
|
if (ret < 0)
|
|
|
|
{
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2022-07-21 04:32:29 +02:00
|
|
|
return ret;
|
|
|
|
}
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
|
|
|
|
ret = circbuf_init(&upper->timing, NULL, lower->nbuffer *
|
|
|
|
TIMING_BUF_ESIZE);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
circbuf_uninit(&upper->buffer);
|
|
|
|
nxrmutex_unlock(&upper->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
2022-07-21 04:32:29 +02:00
|
|
|
}
|
|
|
|
|
2020-11-12 11:40:37 +01:00
|
|
|
circbuf_overwrite(&upper->buffer, data, bytes);
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
sensor_generate_timing(upper, envcount);
|
2022-03-22 08:46:02 +01:00
|
|
|
list_for_every_entry(&upper->userlist, user, struct sensor_user_s, node)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
if (sensor_is_updated(upper, user))
|
2022-03-22 08:46:02 +01:00
|
|
|
{
|
|
|
|
nxsem_get_value(&user->buffersem, &semcount);
|
|
|
|
if (semcount < 1)
|
|
|
|
{
|
|
|
|
nxsem_post(&user->buffersem);
|
|
|
|
}
|
|
|
|
|
|
|
|
sensor_pollnotify_one(user, POLLIN);
|
|
|
|
}
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2022-03-11 10:05:47 +01:00
|
|
|
return bytes;
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
2020-11-04 04:23:39 +01:00
|
|
|
static void sensor_notify_event(FAR void *priv)
|
|
|
|
{
|
|
|
|
FAR struct sensor_upperhalf_s *upper = priv;
|
2022-03-22 08:46:02 +01:00
|
|
|
FAR struct sensor_user_s *user;
|
2020-11-04 04:23:39 +01:00
|
|
|
int semcount;
|
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_lock(&upper->lock);
|
2022-03-22 08:46:02 +01:00
|
|
|
list_for_every_entry(&upper->userlist, user, struct sensor_user_s, node)
|
2020-11-04 04:23:39 +01:00
|
|
|
{
|
2022-03-22 08:46:02 +01:00
|
|
|
nxsem_get_value(&user->buffersem, &semcount);
|
|
|
|
if (semcount < 1)
|
|
|
|
{
|
|
|
|
nxsem_post(&user->buffersem);
|
|
|
|
}
|
|
|
|
|
|
|
|
sensor_pollnotify_one(user, POLLIN);
|
2020-11-04 04:23:39 +01:00
|
|
|
}
|
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_unlock(&upper->lock);
|
2020-11-04 04:23:39 +01:00
|
|
|
}
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: sensor_register
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function binds an instance of a "lower half" Sensor driver with the
|
|
|
|
* "upper half" Sensor device and registers that device so that can be used
|
|
|
|
* by application code.
|
|
|
|
*
|
|
|
|
* We will register the chararter device by node name format based on the
|
|
|
|
* type of sensor. Multiple types of the same type are distinguished by
|
|
|
|
* numbers. eg: accel0, accel1
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
2020-11-02 11:02:04 +01:00
|
|
|
* dev - A pointer to an instance of lower half sensor driver. This
|
|
|
|
* instance is bound to the sensor driver and must persists as long
|
|
|
|
* as the driver persists.
|
|
|
|
* devno - The user specifies which device of this type, from 0. If the
|
|
|
|
* devno alerady exists, -EEXIST will be returned.
|
2020-10-19 15:24:13 +02:00
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* OK if the driver was successfully register; A negated errno value is
|
|
|
|
* returned on any failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-11-02 11:02:04 +01:00
|
|
|
int sensor_register(FAR struct sensor_lowerhalf_s *lower, int devno)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-29 05:39:44 +02:00
|
|
|
char path[PATH_MAX];
|
2020-11-22 09:04:37 +01:00
|
|
|
|
|
|
|
DEBUGASSERT(lower != NULL);
|
|
|
|
|
2022-03-29 05:39:44 +02:00
|
|
|
snprintf(path, PATH_MAX, DEVNAME_FMT,
|
2020-11-22 09:04:37 +01:00
|
|
|
g_sensor_info[lower->type].name,
|
|
|
|
lower->uncalibrated ? DEVNAME_UNCAL : "",
|
|
|
|
devno);
|
|
|
|
return sensor_custom_register(lower, path,
|
|
|
|
g_sensor_info[lower->type].esize);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: sensor_custom_register
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function binds an instance of a "lower half" Sensor driver with the
|
|
|
|
* "upper half" Sensor device and registers that device so that can be used
|
|
|
|
* by application code.
|
|
|
|
*
|
|
|
|
* You can register the character device type by specific path and esize.
|
|
|
|
* This API corresponds to the sensor_custom_unregister.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* dev - A pointer to an instance of lower half sensor driver. This
|
|
|
|
* instance is bound to the sensor driver and must persists as long
|
|
|
|
* as the driver persists.
|
2022-08-08 07:42:03 +02:00
|
|
|
* path - The user specifies path of device. ex: /dev/uorb/xxx.
|
2020-11-22 09:04:37 +01:00
|
|
|
* esize - The element size of intermediate circular buffer.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* OK if the driver was successfully register; A negated errno value is
|
|
|
|
* returned on any failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int sensor_custom_register(FAR struct sensor_lowerhalf_s *lower,
|
2022-03-23 10:09:46 +01:00
|
|
|
FAR const char *path, unsigned long esize)
|
2020-11-22 09:04:37 +01:00
|
|
|
{
|
|
|
|
FAR struct sensor_upperhalf_s *upper;
|
2020-10-19 15:24:13 +02:00
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
DEBUGASSERT(lower != NULL);
|
|
|
|
|
2020-11-22 09:04:37 +01:00
|
|
|
if (lower->type >= SENSOR_TYPE_COUNT || !esize)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2020-11-22 09:04:37 +01:00
|
|
|
snerr("ERROR: type is invalid\n");
|
2020-10-19 15:24:13 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate the upper-half data structure */
|
|
|
|
|
|
|
|
upper = kmm_zalloc(sizeof(struct sensor_upperhalf_s));
|
|
|
|
if (!upper)
|
|
|
|
{
|
|
|
|
snerr("ERROR: Allocation failed\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the upper-half data structure */
|
|
|
|
|
2022-03-22 08:46:02 +01:00
|
|
|
list_initialize(&upper->userlist);
|
2022-03-23 10:09:46 +01:00
|
|
|
upper->state.esize = esize;
|
2022-03-22 08:46:02 +01:00
|
|
|
upper->state.min_interval = ULONG_MAX;
|
|
|
|
if (lower->ops->activate)
|
|
|
|
{
|
|
|
|
upper->state.nadvertisers = 1;
|
|
|
|
}
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_init(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
|
|
|
|
/* Bind the lower half data structure member */
|
|
|
|
|
2022-06-23 06:13:56 +02:00
|
|
|
lower->priv = upper;
|
|
|
|
lower->sensor_lock = sensor_lock;
|
|
|
|
lower->sensor_unlock = sensor_unlock;
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2020-11-04 04:23:39 +01:00
|
|
|
if (!lower->ops->fetch)
|
|
|
|
{
|
2022-03-23 10:09:46 +01:00
|
|
|
if (!lower->nbuffer)
|
2020-11-22 09:04:37 +01:00
|
|
|
{
|
2022-03-23 10:09:46 +01:00
|
|
|
lower->nbuffer = 1;
|
2020-11-04 04:23:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
lower->push_event = sensor_push_event;
|
|
|
|
}
|
|
|
|
else
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2020-11-04 04:23:39 +01:00
|
|
|
lower->notify_event = sensor_notify_event;
|
2022-03-23 10:09:46 +01:00
|
|
|
lower->nbuffer = 0;
|
2020-10-19 15:24:13 +02:00
|
|
|
}
|
|
|
|
|
2022-04-08 16:46:29 +02:00
|
|
|
#ifdef CONFIG_SENSORS_RPMSG
|
|
|
|
lower = sensor_rpmsg_register(lower, path);
|
|
|
|
if (lower == NULL)
|
|
|
|
{
|
|
|
|
ret = -EIO;
|
|
|
|
goto drv_err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-06-14 05:44:24 +02:00
|
|
|
upper->state.nbuffer = lower->nbuffer;
|
2022-04-08 16:46:29 +02:00
|
|
|
upper->lower = lower;
|
2022-06-14 05:44:24 +02:00
|
|
|
sninfo("Registering %s\n", path);
|
|
|
|
ret = register_driver(path, &g_sensor_fops, 0666, upper);
|
|
|
|
if (ret)
|
|
|
|
{
|
|
|
|
goto drv_err;
|
|
|
|
}
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
drv_err:
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_destroy(&upper->lock);
|
2020-10-19 15:24:13 +02:00
|
|
|
|
|
|
|
kmm_free(upper);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: sensor_unregister
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function unregister character node and release all resource about
|
|
|
|
* upper half driver.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
2020-11-02 11:02:04 +01:00
|
|
|
* dev - A pointer to an instance of lower half sensor driver. This
|
|
|
|
* instance is bound to the sensor driver and must persists as long
|
|
|
|
* as the driver persists.
|
|
|
|
* devno - The user specifies which device of this type, from 0.
|
2020-10-19 15:24:13 +02:00
|
|
|
****************************************************************************/
|
|
|
|
|
2020-11-02 11:02:04 +01:00
|
|
|
void sensor_unregister(FAR struct sensor_lowerhalf_s *lower, int devno)
|
2020-10-19 15:24:13 +02:00
|
|
|
{
|
2022-03-29 05:39:44 +02:00
|
|
|
char path[PATH_MAX];
|
2020-10-19 15:24:13 +02:00
|
|
|
|
2022-03-29 05:39:44 +02:00
|
|
|
snprintf(path, PATH_MAX, DEVNAME_FMT,
|
2020-11-22 09:04:37 +01:00
|
|
|
g_sensor_info[lower->type].name,
|
|
|
|
lower->uncalibrated ? DEVNAME_UNCAL : "",
|
|
|
|
devno);
|
|
|
|
sensor_custom_unregister(lower, path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: sensor_custom_unregister
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function unregister character node and release all resource about
|
|
|
|
* upper half driver. This API corresponds to the sensor_custom_register.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* dev - A pointer to an instance of lower half sensor driver. This
|
|
|
|
* instance is bound to the sensor driver and must persists as long
|
|
|
|
* as the driver persists.
|
2022-08-08 07:42:03 +02:00
|
|
|
* path - The user specifies path of device, ex: /dev/uorb/xxx
|
2020-11-22 09:04:37 +01:00
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
void sensor_custom_unregister(FAR struct sensor_lowerhalf_s *lower,
|
|
|
|
FAR const char *path)
|
|
|
|
{
|
|
|
|
FAR struct sensor_upperhalf_s *upper;
|
|
|
|
|
2020-10-19 15:24:13 +02:00
|
|
|
DEBUGASSERT(lower != NULL);
|
|
|
|
DEBUGASSERT(lower->priv != NULL);
|
|
|
|
|
|
|
|
upper = lower->priv;
|
|
|
|
|
|
|
|
sninfo("UnRegistering %s\n", path);
|
|
|
|
unregister_driver(path);
|
|
|
|
|
2022-04-08 16:46:29 +02:00
|
|
|
#ifdef CONFIG_SENSORS_RPMSG
|
|
|
|
sensor_rpmsg_unregister(lower);
|
|
|
|
#endif
|
|
|
|
|
2022-06-14 05:33:13 +02:00
|
|
|
nxrmutex_destroy(&upper->lock);
|
2022-03-22 08:46:02 +01:00
|
|
|
if (circbuf_is_init(&upper->buffer))
|
|
|
|
{
|
|
|
|
circbuf_uninit(&upper->buffer);
|
nuttx/dirvers/sensor: down-sampling 2.0
1. about interval:
If interval is not set, generation is increased by 1 along with
publish and copy, multi-copy is continuous.
If interval is set, pick proper samples from buffer based on
mainline/user generation, multi-copy is one-by-one.
2. about bufferpos:
user->bufferpos always point to next position to check.
data user last read
----------v--------------------------
| | | |
-------------------^-----------------
bufferpos
If buffer is full, bufferpos point to buffer.head
Examples:
If a buffer contains 4 samples, newest generatoin is 40.
-------------------------------------
|10 |20 |30 |40
------------------------------^------
|
if user's next generation is 42, notify user to copy No.40 sample,
because 42 is closer to 40 than 50.
-------------------------------------
|10 |20 |30 |40
----------------------------------^--
|
if user's next generation is 48, do not notify user,
because 48 is closer to 50, which is next mainline sample.
Signed-off-by: jihandong <jihandong@xiaomi.com>
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
2022-05-11 07:49:39 +02:00
|
|
|
circbuf_uninit(&upper->timing);
|
2022-03-22 08:46:02 +01:00
|
|
|
}
|
2020-10-19 15:24:13 +02:00
|
|
|
|
|
|
|
kmm_free(upper);
|
|
|
|
}
|