Mirrors_Framework/nuttx
1
0
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2026-06-04 23:03:27 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

drivers/camera: Support the private data for imgsensor and imgdata

Browse Source 
Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com>
This commit is contained in:
Xiang Xiao
2023-01-24 20:22:31 +08:00
committed by Alin Jerpelea
parent 372fee9412
commit 55679aec5f
7 changed files with 914 additions and 778 deletions
Download Patch File Download Diff File Expand all files Collapse all files
arch/arm/src/cxd56xx/cxd56_cisif.c
+31 -18
View File
@@ -204,22 +204,26 @@ static int cisif_intc_handler(int irq, void *context, void *arg);
/* video image data operations */ /* video image data operations */
static int cxd56_cisif_init(void); static int cxd56_cisif_init(struct imgdata_s *data);
static int cxd56_cisif_uninit(void); static int cxd56_cisif_uninit(struct imgdata_s *data);
static int cxd56_cisif_validate_frame_setting static int cxd56_cisif_validate_frame_setting
(uint8_t nr_datafmt, (struct imgdata_s *data,
uint8_t nr_datafmt,
imgdata_format_t *datafmt, imgdata_format_t *datafmt,
imgdata_interval_t *interval); imgdata_interval_t *interval);
static int cxd56_cisif_start_capture static int cxd56_cisif_start_capture
(uint8_t nr_datafmt, (struct imgdata_s *data,
uint8_t nr_datafmt,
imgdata_format_t *datafmt, imgdata_format_t *datafmt,
imgdata_interval_t *interval, imgdata_interval_t *interval,
imgdata_capture_t callback); imgdata_capture_t callback);
static int cxd56_cisif_stop_capture(void); static int cxd56_cisif_stop_capture(struct imgdata_s *data);
static int cxd56_cisif_validate_buf(uint8_t *addr, uint32_t size); static int cxd56_cisif_validate_buf(struct imgdata_s *data,
static int cxd56_cisif_set_buf(uint8_t *addr, uint32_t size); uint8_t *addr, uint32_t size);
static int cxd56_cisif_set_buf(struct imgdata_s *data,
uint8_t *addr, uint32_t size);
const intc_func_table g_intcomp_func[] = static const intc_func_table g_intcomp_func[] =
{ {
cisif_vs_int, /* VS_INT */ cisif_vs_int, /* VS_INT */
NULL, /* EOY_INT */ NULL, /* EOY_INT */
@@ -252,7 +256,7 @@ const intc_func_table g_intcomp_func[] =
cisif_jpg_err_int, /* JPG_ERR_STATUS_INT */ cisif_jpg_err_int, /* JPG_ERR_STATUS_INT */
}; };
const struct imgdata_ops_s g_cxd56_cisif_ops = static const struct imgdata_ops_s g_cxd56_cisif_ops =
{ {
.init = cxd56_cisif_init, .init = cxd56_cisif_init,
.uninit = cxd56_cisif_uninit, .uninit = cxd56_cisif_uninit,
@@ -262,6 +266,11 @@ const struct imgdata_ops_s g_cxd56_cisif_ops =
.stop_capture = cxd56_cisif_stop_capture, .stop_capture = cxd56_cisif_stop_capture,
}; };
static struct imgdata_s g_cxd56_cisif =
{
&g_cxd56_cisif_ops
};
/**************************************************************************** /****************************************************************************
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/
@@ -764,7 +773,7 @@ static int cisif_chk_yuvfrmsize(int w, int h)
* cxd56_cisif_init * cxd56_cisif_init
****************************************************************************/ ****************************************************************************/
static int cxd56_cisif_init(void) static int cxd56_cisif_init(struct imgdata_s *data)
{ {
if (g_state != STATE_STANDBY) if (g_state != STATE_STANDBY)
{ {
@@ -802,7 +811,7 @@ static int cxd56_cisif_init(void)
* cxd56_cisif_uninit * cxd56_cisif_uninit
****************************************************************************/ ****************************************************************************/
static int cxd56_cisif_uninit(void) static int cxd56_cisif_uninit(struct imgdata_s *data)
{ {
if (g_state != STATE_READY) if (g_state != STATE_READY)
{ {
@@ -837,7 +846,8 @@ static int cxd56_cisif_uninit(void)
****************************************************************************/ ****************************************************************************/
static int cxd56_cisif_start_capture static int cxd56_cisif_start_capture
(uint8_t nr_fmt, (struct imgdata_s *data,
uint8_t nr_fmt,
imgdata_format_t *fmt, imgdata_format_t *fmt,
imgdata_interval_t *interval, imgdata_interval_t *interval,
imgdata_capture_t callback) imgdata_capture_t callback)
@@ -936,7 +946,7 @@ static int cxd56_cisif_start_capture
return OK; return OK;
} }
static int cxd56_cisif_stop_capture(void) static int cxd56_cisif_stop_capture(struct imgdata_s *data)
{ {
g_state = STATE_READY; g_state = STATE_READY;
cisif_reg_write(CISIF_DIN_ENABLE, 0); cisif_reg_write(CISIF_DIN_ENABLE, 0);
@@ -946,7 +956,8 @@ static int cxd56_cisif_stop_capture(void)
return OK; return OK;
} }
static int cxd56_cisif_validate_buf(uint8_t *addr, uint32_t size) static int cxd56_cisif_validate_buf(struct imgdata_s *data,
uint8_t *addr, uint32_t size)
{ {
if (ILLEGAL_BUFADDR_ALIGNMENT(addr) || if (ILLEGAL_BUFADDR_ALIGNMENT(addr) ||
size == 0) size == 0)
@@ -957,7 +968,8 @@ static int cxd56_cisif_validate_buf(uint8_t *addr, uint32_t size)
return OK; return OK;
} }
static int cxd56_cisif_set_buf(uint8_t *addr, uint32_t size) static int cxd56_cisif_set_buf(struct imgdata_s *data,
uint8_t *addr, uint32_t size)
{ {
int ret; int ret;
uint32_t mode; uint32_t mode;
@@ -965,7 +977,7 @@ static int cxd56_cisif_set_buf(uint8_t *addr, uint32_t size)
uint16_t w; uint16_t w;
uint16_t h; uint16_t h;
ret = cxd56_cisif_validate_buf(addr, size); ret = cxd56_cisif_validate_buf(data, addr, size);
if (ret != OK) if (ret != OK)
{ {
return ret; return ret;
@@ -1009,7 +1021,8 @@ static int cxd56_cisif_set_buf(uint8_t *addr, uint32_t size)
} }
static int cxd56_cisif_validate_frame_setting static int cxd56_cisif_validate_frame_setting
(uint8_t nr_datafmt, (struct imgdata_s *data,
uint8_t nr_datafmt,
imgdata_format_t *datafmt, imgdata_format_t *datafmt,
imgdata_interval_t *interval) imgdata_interval_t *interval)
{ {
@@ -1079,7 +1092,7 @@ static int cxd56_cisif_validate_frame_setting
int cxd56_cisif_initialize(void) int cxd56_cisif_initialize(void)
{ {
imgdata_register(&g_cxd56_cisif_ops); imgdata_register(&g_cxd56_cisif);
return OK; return OK;
} }
arch/sim/src/sim/sim_video.c
+184 -153
View File
@@ -41,6 +41,8 @@
typedef struct typedef struct
{ {
struct imgdata_s data;
struct imgsensor_s sensor;
imgdata_capture_t capture_cb; imgdata_capture_t capture_cb;
uint32_t buf_size; uint32_t buf_size;
uint8_t *next_buf; uint8_t *next_buf;
@@ -53,36 +55,39 @@ typedef struct
/* Video image sensor operations */ /* Video image sensor operations */
static bool sim_video_is_available(void); static bool sim_video_is_available(struct imgsensor_s *sensor);
static int sim_video_init(void); static int sim_video_init(struct imgsensor_s *sensor);
static int sim_video_uninit(void); static int sim_video_uninit(struct imgsensor_s *sensor);
static const char *sim_video_get_driver_name(void); static const char *sim_video_get_driver_name(struct imgsensor_s *sensor);
static int sim_video_validate_frame_setting(imgsensor_stream_type_t type, static int sim_video_validate_frame_setting(struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_datafmt, uint8_t nr_datafmt,
imgsensor_format_t *datafmts, imgsensor_format_t *datafmts,
imgsensor_interval_t *interval); imgsensor_interval_t *interval);
static int sim_video_start_capture(imgsensor_stream_type_t type, static int sim_video_start_capture(struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_datafmt, uint8_t nr_datafmt,
imgsensor_format_t *datafmts, imgsensor_format_t *datafmts,
imgsensor_interval_t *interval); imgsensor_interval_t *interval);
static int sim_video_stop_capture(imgsensor_stream_type_t type); static int sim_video_stop_capture(struct imgsensor_s *sensor,
imgsensor_stream_type_t type);
/* Video image data operations */ /* Video image data operations */
static int sim_video_data_init(void); static int sim_video_data_init(struct imgdata_s *data);
static int sim_video_data_uninit(void); static int sim_video_data_uninit(struct imgdata_s *data);
static int sim_video_data_validate_frame_setting(uint8_t nr_datafmt, static int sim_video_data_validate_frame_setting(struct imgdata_s *data,
uint8_t nr_datafmt,
imgdata_format_t *datafmt, imgdata_format_t *datafmt,
imgdata_interval_t *interv); imgdata_interval_t *interv);
static int sim_video_data_start_capture(uint8_t nr_datafmt, static int sim_video_data_start_capture(struct imgdata_s *data,
uint8_t nr_datafmt,
imgdata_format_t *datafmt, imgdata_format_t *datafmt,
imgdata_interval_t *interval, imgdata_interval_t *interval,
imgdata_capture_t callback); imgdata_capture_t callback);
static int sim_video_data_stop_capture(void); static int sim_video_data_stop_capture(struct imgdata_s *data);
static int sim_video_data_validate_buf(uint8_t *addr, uint32_t size); static int sim_video_data_set_buf(struct imgdata_s *data,
static int sim_video_data_set_buf(uint8_t *addr, uint32_t size); uint8_t *addr, uint32_t size);
static uint32_t imgdata_fmt_to_v4l2(uint32_t pixelformat);
/**************************************************************************** /****************************************************************************
* Private Data * Private Data
@@ -109,141 +114,22 @@ static const struct imgdata_ops_s g_sim_video_data_ops =
.stop_capture = sim_video_data_stop_capture, .stop_capture = sim_video_data_stop_capture,
}; };
static sim_video_priv_t g_sim_video_priv; static sim_video_priv_t g_sim_video_priv =
{
.data =
{
&g_sim_video_data_ops
},
.sensor =
{
&g_sim_video_ops
}
};
/**************************************************************************** /****************************************************************************
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/
/* Sensor op functions are mostly dummy */
static bool sim_video_is_available(void)
{
return host_video_is_available(CONFIG_HOST_VIDEO_DEV_PATH);
}
static int sim_video_init(void)
{
return 0;
}
static int sim_video_uninit(void)
{
return 0;
}
static const char *sim_video_get_driver_name(void)
{
return "V4L2 NuttX Sim Driver";
}
static int sim_video_validate_frame_setting(imgsensor_stream_type_t type,
uint8_t nr_fmt,
imgsensor_format_t *fmt,
imgsensor_interval_t *interval)
{
return 0;
}
static int sim_video_start_capture(imgsensor_stream_type_t type,
uint8_t nr_fmt,
imgsensor_format_t *fmt,
imgsensor_interval_t *interval)
{
return 0;
}
static int sim_video_stop_capture(imgsensor_stream_type_t type)
{
return 0;
}
/* Data op functions do all the real work */
static int sim_video_data_init(void)
{
memset(&g_sim_video_priv, 0, sizeof(g_sim_video_priv));
g_sim_video_priv.vdev = host_video_init(CONFIG_HOST_VIDEO_DEV_PATH);
if (g_sim_video_priv.vdev == NULL)
{
return -ENODEV;
}
return 0;
}
static int sim_video_data_uninit(void)
{
return host_video_uninit(g_sim_video_priv.vdev);
}
static int sim_video_data_validate_buf(uint8_t *addr, uint32_t size)
{
if (!addr || ((uintptr_t)(addr) & 0x1f))
{
return -EINVAL;
}
return 0;
}
static int sim_video_data_set_buf(uint8_t *addr, uint32_t size)
{
if (sim_video_data_validate_buf(addr, size) < 0)
{
return -EINVAL;
}
g_sim_video_priv.next_buf = addr;
g_sim_video_priv.buf_size = size;
return 0;
}
static int sim_video_data_validate_frame_setting(uint8_t nr_datafmt,
imgdata_format_t *datafmt,
imgdata_interval_t *interv)
{
uint32_t v4l2_fmt;
if (nr_datafmt > 1)
{
return -ENOTSUP;
}
v4l2_fmt = imgdata_fmt_to_v4l2(datafmt->pixelformat);
return host_video_try_fmt(g_sim_video_priv.vdev, datafmt->width,
datafmt->height, v4l2_fmt, interv->denominator,
interv->numerator);
}
static int sim_video_data_start_capture(uint8_t nr_datafmt,
imgdata_format_t *datafmt,
imgdata_interval_t *interval,
imgdata_capture_t callback)
{
int ret;
ret = host_video_set_fmt(g_sim_video_priv.vdev,
datafmt[IMGDATA_FMT_MAIN].width,
datafmt[IMGDATA_FMT_MAIN].height,
imgdata_fmt_to_v4l2(
datafmt[IMGDATA_FMT_MAIN].pixelformat),
interval->denominator, interval->numerator);
if (ret < 0 && ret != -EBUSY)
{
return ret;
}
g_sim_video_priv.capture_cb = callback;
return host_video_start_capture(g_sim_video_priv.vdev);
}
static int sim_video_data_stop_capture(void)
{
g_sim_video_priv.next_buf = NULL;
return host_video_stop_capture(g_sim_video_priv.vdev);
}
/* Helper functions */ /* Helper functions */
static uint32_t imgdata_fmt_to_v4l2(uint32_t pixelformat) static uint32_t imgdata_fmt_to_v4l2(uint32_t pixelformat)
@@ -285,14 +171,160 @@ static uint32_t imgdata_fmt_to_v4l2(uint32_t pixelformat)
return fourcc; return fourcc;
} }
/* Sensor op functions are mostly dummy */
static bool sim_video_is_available(struct imgsensor_s *sensor)
{
return host_video_is_available(CONFIG_HOST_VIDEO_DEV_PATH);
}
static int sim_video_init(struct imgsensor_s *sensor)
{
return 0;
}
static int sim_video_uninit(struct imgsensor_s *sensor)
{
return 0;
}
static const char *sim_video_get_driver_name(struct imgsensor_s *sensor)
{
return "V4L2 NuttX Sim Driver";
}
static int sim_video_validate_frame_setting(struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_fmt,
imgsensor_format_t *fmt,
imgsensor_interval_t *interval)
{
return 0;
}
static int sim_video_start_capture(struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_fmt,
imgsensor_format_t *fmt,
imgsensor_interval_t *interval)
{
return 0;
}
static int sim_video_stop_capture(struct imgsensor_s *sensor,
imgsensor_stream_type_t type)
{
return 0;
}
/* Data op functions do all the real work */
static int sim_video_data_init(struct imgdata_s *data)
{
sim_video_priv_t *priv = (sim_video_priv_t *)data;
priv->vdev = host_video_init(CONFIG_HOST_VIDEO_DEV_PATH);
if (priv->vdev == NULL)
{
return -ENODEV;
}
return 0;
}
static int sim_video_data_uninit(struct imgdata_s *data)
{
sim_video_priv_t *priv = (sim_video_priv_t *)data;
return host_video_uninit(priv->vdev);
}
static int sim_video_data_validate_buf(uint8_t *addr, uint32_t size)
{
if (!addr || ((uintptr_t)(addr) & 0x1f))
{
return -EINVAL;
}
return 0;
}
static int sim_video_data_set_buf(struct imgdata_s *data,
uint8_t *addr, uint32_t size)
{
sim_video_priv_t *priv = (sim_video_priv_t *)data;
if (sim_video_data_validate_buf(addr, size) < 0)
{
return -EINVAL;
}
priv->next_buf = addr;
priv->buf_size = size;
return 0;
}
static int sim_video_data_validate_frame_setting(struct imgdata_s *data,
uint8_t nr_datafmt,
imgdata_format_t *datafmt,
imgdata_interval_t *interv)
{
sim_video_priv_t *priv = (sim_video_priv_t *)data;
uint32_t v4l2_fmt;
if (nr_datafmt > 1)
{
return -ENOTSUP;
}
v4l2_fmt = imgdata_fmt_to_v4l2(datafmt->pixelformat);
return host_video_try_fmt(priv->vdev, datafmt->width,
datafmt->height, v4l2_fmt, interv->denominator,
interv->numerator);
}
static int sim_video_data_start_capture(struct imgdata_s *data,
uint8_t nr_datafmt,
imgdata_format_t *datafmt,
imgdata_interval_t *interval,
imgdata_capture_t callback)
{
sim_video_priv_t *priv = (sim_video_priv_t *)data;
int ret;
ret = host_video_set_fmt(priv->vdev,
datafmt[IMGDATA_FMT_MAIN].width,
datafmt[IMGDATA_FMT_MAIN].height,
imgdata_fmt_to_v4l2(
datafmt[IMGDATA_FMT_MAIN].pixelformat),
interval->denominator, interval->numerator);
if (ret < 0 && ret != -EBUSY)
{
return ret;
}
priv->capture_cb = callback;
return host_video_start_capture(priv->vdev);
}
static int sim_video_data_stop_capture(struct imgdata_s *data)
{
sim_video_priv_t *priv = (sim_video_priv_t *)data;
priv->next_buf = NULL;
return host_video_stop_capture(priv->vdev);
}
/**************************************************************************** /****************************************************************************
* Public Functions * Public Functions
****************************************************************************/ ****************************************************************************/
int sim_video_initialize(void) int sim_video_initialize(void)
{ {
imgsensor_register(&g_sim_video_ops); sim_video_priv_t *priv = &g_sim_video_priv;
imgdata_register(&g_sim_video_data_ops);
imgsensor_register(&priv->sensor);
imgdata_register(&priv->data);
return 0; return 0;
} }
@@ -303,16 +335,15 @@ int sim_video_uninitialize(void)
void sim_video_loop(void) void sim_video_loop(void)
{ {
sim_video_priv_t *priv = &g_sim_video_priv;
int ret; int ret;
if (g_sim_video_priv.next_buf) if (priv->next_buf)
{ {
ret = host_video_dqbuf(g_sim_video_priv.vdev, ret = host_video_dqbuf(priv->vdev, priv->next_buf, priv->buf_size);
g_sim_video_priv.next_buf,
g_sim_video_priv.buf_size);
if (ret > 0) if (ret > 0)
{ {
g_sim_video_priv.capture_cb(0, ret); priv->capture_cb(0, ret);
} }
} }
} }
drivers/video/isx012.c
+73 -64
View File
@@ -187,6 +187,7 @@ typedef struct isx012_rect_s isx012_rect_t;
struct isx012_dev_s struct isx012_dev_s
{ {
struct imgsensor_s sensor;
mutex_t i2c_lock; mutex_t i2c_lock;
FAR struct i2c_master_s *i2c; /* I2C interface */ FAR struct i2c_master_s *i2c; /* I2C interface */
uint8_t i2c_addr; /* I2C address */ uint8_t i2c_addr; /* I2C address */
@@ -230,43 +231,41 @@ static int isx012_change_device_state(FAR isx012_dev_t *priv,
isx012_state_t state); isx012_state_t state);
static int isx012_replace_frameinterval_to_regval static int isx012_replace_frameinterval_to_regval
(FAR imgsensor_interval_t *interval); (FAR imgsensor_interval_t *interval);
static int8_t isx012_get_maximum_fps static int8_t isx012_get_maximum_fps(uint8_t nr_datafmt,
(uint8_t nr_datafmt,
FAR imgsensor_format_t *datafmt); FAR imgsensor_format_t *datafmt);
static int isx012_set_shd(FAR isx012_dev_t *priv); static int isx012_set_shd(FAR isx012_dev_t *priv);
static bool is_movie_needed(uint8_t fmt, uint8_t fps); static bool is_movie_needed(uint8_t fmt, uint8_t fps);
/* image sensor device operations interface */ /* image sensor device operations interface */
static bool isx012_is_available(void); static bool isx012_is_available(FAR struct imgsensor_s *sensor);
static int isx012_init(void); static int isx012_init(FAR struct imgsensor_s *sensor);
static int isx012_uninit(void); static int isx012_uninit(FAR struct imgsensor_s *sensor);
static FAR const char *isx012_get_driver_name(void); static FAR const char *
static int isx012_validate_frame_setting(imgsensor_stream_type_t type, isx012_get_driver_name(FAR struct imgsensor_s *sensor);
static int isx012_validate_frame_setting(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_datafmt, uint8_t nr_datafmt,
FAR imgsensor_format_t *datafmts, FAR imgsensor_format_t *datafmts,
FAR imgsensor_interval_t *interval); FAR imgsensor_interval_t *interval);
static int isx012_start_capture(imgsensor_stream_type_t type, static int isx012_start_capture(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_datafmt, uint8_t nr_datafmt,
FAR imgsensor_format_t *datafmts, FAR imgsensor_format_t *datafmts,
FAR imgsensor_interval_t *interval); FAR imgsensor_interval_t *interval);
static int isx012_stop_capture(imgsensor_stream_type_t type); static int isx012_stop_capture(FAR struct imgsensor_s *sensor,
static int isx012_get_supported_value imgsensor_stream_type_t type);
(uint32_t id, FAR imgsensor_supported_value_t *value); static int isx012_get_supported_value(FAR struct imgsensor_s *sensor,
static int isx012_get_value uint32_t id, FAR imgsensor_supported_value_t *value);
(uint32_t id, uint32_t size, FAR imgsensor_value_t *value); static int isx012_get_value(FAR struct imgsensor_s *sensor,
static int isx012_set_value uint32_t id, uint32_t size, FAR imgsensor_value_t *value);
(uint32_t id, uint32_t size, imgsensor_value_t value); static int isx012_set_value(FAR struct imgsensor_s *sensor,
uint32_t id, uint32_t size, imgsensor_value_t value);
/**************************************************************************** /****************************************************************************
* Private Data * Private Data
****************************************************************************/ ****************************************************************************/
static isx012_dev_t g_isx012_private =
{
NXMUTEX_INITIALIZER,
};
#ifndef ISX012_NOT_USE_NSTBY #ifndef ISX012_NOT_USE_NSTBY
static const isx012_reg_t g_isx012_presleep[] = static const isx012_reg_t g_isx012_presleep[] =
{ {
@@ -537,7 +536,7 @@ static const isx012_reg_t g_isx012_shd_wb[] =
#define ISX012_SHD_WB_NENTRIES ARRAY_NENTRIES(g_isx012_shd_wb) #define ISX012_SHD_WB_NENTRIES ARRAY_NENTRIES(g_isx012_shd_wb)
static int32_t g_isx012_colorfx_actual[] = static const int32_t g_isx012_colorfx_actual[] =
{ {
IMGSENSOR_COLORFX_NONE, IMGSENSOR_COLORFX_NONE,
IMGSENSOR_COLORFX_BW, IMGSENSOR_COLORFX_BW,
@@ -548,7 +547,7 @@ static int32_t g_isx012_colorfx_actual[] =
IMGSENSOR_COLORFX_PASTEL IMGSENSOR_COLORFX_PASTEL
}; };
static uint8_t g_isx012_colorfx_regval[] = static const uint8_t g_isx012_colorfx_regval[] =
{ {
REGVAL_EFFECT_NONE, REGVAL_EFFECT_NONE,
REGVAL_EFFECT_MONOTONE, REGVAL_EFFECT_MONOTONE,
@@ -559,7 +558,7 @@ static uint8_t g_isx012_colorfx_regval[] =
REGVAL_EFFECT_PASTEL REGVAL_EFFECT_PASTEL
}; };
static int32_t g_isx012_presetwb_actual[] = static const int32_t g_isx012_presetwb_actual[] =
{ {
IMGSENSOR_WHITE_BALANCE_AUTO, IMGSENSOR_WHITE_BALANCE_AUTO,
IMGSENSOR_WHITE_BALANCE_INCANDESCENT, IMGSENSOR_WHITE_BALANCE_INCANDESCENT,
@@ -569,7 +568,7 @@ static int32_t g_isx012_presetwb_actual[] =
IMGSENSOR_WHITE_BALANCE_SHADE IMGSENSOR_WHITE_BALANCE_SHADE
}; };
static uint8_t g_isx012_presetwb_regval[] = static const uint8_t g_isx012_presetwb_regval[] =
{ {
REGVAL_AWB_ATM, REGVAL_AWB_ATM,
REGVAL_AWB_LIGHTBULB, REGVAL_AWB_LIGHTBULB,
@@ -579,7 +578,7 @@ static uint8_t g_isx012_presetwb_regval[] =
REGVAL_AWB_SHADE REGVAL_AWB_SHADE
}; };
static int32_t g_isx012_photometry_actual[] = static const int32_t g_isx012_photometry_actual[] =
{ {
IMGSENSOR_EXPOSURE_METERING_AVERAGE, IMGSENSOR_EXPOSURE_METERING_AVERAGE,
IMGSENSOR_EXPOSURE_METERING_CENTER_WEIGHTED, IMGSENSOR_EXPOSURE_METERING_CENTER_WEIGHTED,
@@ -587,7 +586,7 @@ static int32_t g_isx012_photometry_actual[] =
IMGSENSOR_EXPOSURE_METERING_MATRIX IMGSENSOR_EXPOSURE_METERING_MATRIX
}; };
static uint8_t g_isx012_photometry_regval[] = static const uint8_t g_isx012_photometry_regval[] =
{ {
REGVAL_PHOTOMETRY_AVERAGE, REGVAL_PHOTOMETRY_AVERAGE,
REGVAL_PHOTOMETRY_CENTERWEIGHT, REGVAL_PHOTOMETRY_CENTERWEIGHT,
@@ -595,7 +594,7 @@ static uint8_t g_isx012_photometry_regval[] =
REGVAL_PHOTOMETRY_MULTIPATTERN REGVAL_PHOTOMETRY_MULTIPATTERN
}; };
static int32_t g_isx012_iso_actual[] = static const int32_t g_isx012_iso_actual[] =
{ {
25 * 1000, 25 * 1000,
32 * 1000, 32 * 1000,
@@ -618,7 +617,7 @@ static int32_t g_isx012_iso_actual[] =
1600 * 1000 1600 * 1000
}; };
static uint8_t g_isx012_iso_regval[] = static const uint8_t g_isx012_iso_regval[] =
{ {
REGVAL_ISO_25, REGVAL_ISO_25,
REGVAL_ISO_32, REGVAL_ISO_32,
@@ -641,7 +640,7 @@ static uint8_t g_isx012_iso_regval[] =
REGVAL_ISO_1600 REGVAL_ISO_1600
}; };
static struct imgsensor_ops_s g_isx012_ops = static const struct imgsensor_ops_s g_isx012_ops =
{ {
isx012_is_available, /* is HW available */ isx012_is_available, /* is HW available */
isx012_init, /* init */ isx012_init, /* init */
@@ -656,6 +655,14 @@ static struct imgsensor_ops_s g_isx012_ops =
isx012_set_value /* set_value */ isx012_set_value /* set_value */
}; };
static isx012_dev_t g_isx012_private =
{
{
&g_isx012_ops,
},
NXMUTEX_INITIALIZER,
};
/**************************************************************************** /****************************************************************************
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/
@@ -676,7 +683,7 @@ static uint16_t isx012_getreg(FAR isx012_dev_t *priv,
buffer[0] = regaddr >> 8; buffer[0] = regaddr >> 8;
buffer[1] = regaddr & 0xff; buffer[1] = regaddr & 0xff;
nxmutex_lock(&g_isx012_private.i2c_lock); nxmutex_lock(&priv->i2c_lock);
/* Write the register address */ /* Write the register address */
@@ -696,7 +703,7 @@ static uint16_t isx012_getreg(FAR isx012_dev_t *priv,
} }
} }
nxmutex_unlock(&g_isx012_private.i2c_lock); nxmutex_unlock(&priv->i2c_lock);
if (ret >= 0) if (ret >= 0)
{ {
@@ -726,7 +733,7 @@ static int isx012_putreg(FAR isx012_dev_t *priv,
memcpy((FAR uint8_t *)&buffer[2], (FAR uint8_t *)&regval, regsize); memcpy((FAR uint8_t *)&buffer[2], (FAR uint8_t *)&regval, regsize);
nxmutex_lock(&g_isx012_private.i2c_lock); nxmutex_lock(&priv->i2c_lock);
/* And do it */ /* And do it */
@@ -737,7 +744,7 @@ static int isx012_putreg(FAR isx012_dev_t *priv,
verr("i2c_write failed: %d\n", ret); verr("i2c_write failed: %d\n", ret);
} }
nxmutex_unlock(&g_isx012_private.i2c_lock); nxmutex_unlock(&priv->i2c_lock);
return ret; return ret;
} }
@@ -1320,7 +1327,7 @@ static int isx012_change_device_state(FAR isx012_dev_t *priv,
return OK; return OK;
} }
int init_isx012(FAR struct isx012_dev_s *priv) int init_isx012(FAR isx012_dev_t *priv)
{ {
int ret; int ret;
@@ -1406,26 +1413,27 @@ int init_isx012(FAR struct isx012_dev_s *priv)
return ret; return ret;
} }
static bool isx012_is_available(void) static bool isx012_is_available(FAR struct imgsensor_s *sensor)
{ {
FAR isx012_dev_t *priv = (FAR isx012_dev_t *)sensor;
bool ret; bool ret;
isx012_init(); isx012_init(sensor);
/* Try to access via I2C. /* Try to access via I2C.
* Select DEVICESTS register, which has positive value. * Select DEVICESTS register, which has positive value.
*/ */
ret = (isx012_getreg(&g_isx012_private, DEVICESTS, 1) == DEVICESTS_SLEEP); ret = (isx012_getreg(priv, DEVICESTS, 1) == DEVICESTS_SLEEP);
isx012_uninit(); isx012_uninit(sensor);
return ret; return ret;
} }
static int isx012_init(void) static int isx012_init(FAR struct imgsensor_s *sensor)
{ {
FAR struct isx012_dev_s *priv = &g_isx012_private; FAR isx012_dev_t *priv = (FAR isx012_dev_t *)sensor;
int ret = 0; int ret = 0;
priv->i2c = board_isx012_initialize(); priv->i2c = board_isx012_initialize();
@@ -1451,9 +1459,9 @@ static int isx012_init(void)
return ret; return ret;
} }
static int isx012_uninit(void) static int isx012_uninit(FAR struct imgsensor_s *sensor)
{ {
FAR struct isx012_dev_s *priv = &g_isx012_private; FAR isx012_dev_t *priv = (FAR isx012_dev_t *)sensor;
int ret = 0; int ret = 0;
@@ -1479,7 +1487,7 @@ static int isx012_uninit(void)
return ret; return ret;
} }
static FAR const char *isx012_get_driver_name(void) static FAR const char *isx012_get_driver_name(FAR struct imgsensor_s *sensor)
{ {
return "ISX012"; return "ISX012";
} }
@@ -1665,7 +1673,8 @@ static int isx012_replace_frameinterval_to_regval
} }
} }
static int isx012_validate_frame_setting(imgsensor_stream_type_t type, static int isx012_validate_frame_setting(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_fmt, uint8_t nr_fmt,
FAR imgsensor_format_t *fmt, FAR imgsensor_format_t *fmt,
FAR imgsensor_interval_t *interval) FAR imgsensor_interval_t *interval)
@@ -1704,16 +1713,16 @@ static int isx012_validate_frame_setting(imgsensor_stream_type_t type,
return OK; return OK;
} }
static int isx012_start_capture(imgsensor_stream_type_t type, static int isx012_start_capture(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_fmt, uint8_t nr_fmt,
FAR imgsensor_format_t *fmt, FAR imgsensor_format_t *fmt,
FAR imgsensor_interval_t *interval) FAR imgsensor_interval_t *interval)
{ {
FAR isx012_dev_t *priv = (FAR isx012_dev_t *)sensor;
int ret; int ret;
FAR struct isx012_dev_s *priv = &g_isx012_private; ret = isx012_validate_frame_setting(sensor, type, nr_fmt, fmt, interval);
ret = isx012_validate_frame_setting(type, nr_fmt, fmt, interval);
if (ret != OK) if (ret != OK)
{ {
return ret; return ret;
@@ -1722,13 +1731,14 @@ static int isx012_start_capture(imgsensor_stream_type_t type,
return isx012_set_mode_param(priv, type, nr_fmt, fmt, interval); return isx012_set_mode_param(priv, type, nr_fmt, fmt, interval);
} }
static int isx012_stop_capture(imgsensor_stream_type_t type) static int isx012_stop_capture(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type)
{ {
return OK; return OK;
} }
static int isx012_get_supported_value static int isx012_get_supported_value(FAR struct imgsensor_s *sensor,
(uint32_t id, FAR imgsensor_supported_value_t *value) uint32_t id, FAR imgsensor_supported_value_t *value)
{ {
int ret = OK; int ret = OK;
FAR imgsensor_capability_range_t *range = &value->u.range; FAR imgsensor_capability_range_t *range = &value->u.range;
@@ -1971,11 +1981,11 @@ static int isx012_get_supported_value
return ret; return ret;
} }
static int isx012_get_value(uint32_t id, static int isx012_get_value(FAR struct imgsensor_s *sensor,
uint32_t size, uint32_t id, uint32_t size,
FAR imgsensor_value_t *value) FAR imgsensor_value_t *value)
{ {
FAR struct isx012_dev_s *priv = &g_isx012_private; FAR isx012_dev_t *priv = (FAR isx012_dev_t *)sensor;
uint16_t readvalue; uint16_t readvalue;
uint8_t cnt; uint8_t cnt;
uint8_t threea_enable; uint8_t threea_enable;
@@ -2346,11 +2356,11 @@ static int set_clip(uint32_t size,
return OK; return OK;
} }
static int isx012_set_value(uint32_t id, static int isx012_set_value(FAR struct imgsensor_s *sensor,
uint32_t size, uint32_t id, uint32_t size,
imgsensor_value_t value) imgsensor_value_t value)
{ {
FAR struct isx012_dev_s *priv = &g_isx012_private; FAR isx012_dev_t *priv = (FAR isx012_dev_t *)sensor;
int ret = -EINVAL; int ret = -EINVAL;
uint8_t cnt; uint8_t cnt;
FAR uint16_t *write_src; FAR uint16_t *write_src;
@@ -2783,8 +2793,7 @@ static int isx012_set_value(uint32_t id,
case IMGSENSOR_ID_ISO_SENSITIVITY: case IMGSENSOR_ID_ISO_SENSITIVITY:
for (cnt = 0; cnt < ARRAY_NENTRIES(g_isx012_iso_actual); cnt++) for (cnt = 0; cnt < ARRAY_NENTRIES(g_isx012_iso_actual); cnt++)
{ {
if (g_isx012_iso_actual[cnt] if (g_isx012_iso_actual[cnt] == value.value32)
== value.value32)
{ {
ret = isx012_putreg(priv, ret = isx012_putreg(priv,
ISX012_REG_ISO, ISX012_REG_ISO,
@@ -2833,8 +2842,7 @@ static int isx012_set_value(uint32_t id,
cnt < ARRAY_NENTRIES(g_isx012_photometry_actual); cnt < ARRAY_NENTRIES(g_isx012_photometry_actual);
cnt++) cnt++)
{ {
if (g_isx012_photometry_actual[cnt] if (g_isx012_photometry_actual[cnt] == value.value32)
== value.value32)
{ {
ret = isx012_putreg(priv, ret = isx012_putreg(priv,
ISX012_REG_PHOTOMETRY, ISX012_REG_PHOTOMETRY,
@@ -3144,12 +3152,12 @@ static int isx012_set_shd(FAR isx012_dev_t *priv)
int isx012_initialize(void) int isx012_initialize(void)
{ {
FAR isx012_dev_t *priv = &g_isx012_private;
int ret; int ret;
FAR struct isx012_dev_s *priv = &g_isx012_private;
/* Register image sensor operations variable */ /* Register image sensor operations variable */
ret = imgsensor_register(&g_isx012_ops); ret = imgsensor_register(&priv->sensor);
if (ret != OK) if (ret != OK)
{ {
verr("Failed to register ops to video driver.\n"); verr("Failed to register ops to video driver.\n");
@@ -3172,6 +3180,7 @@ int isx012_uninitialize(void)
#ifdef CONFIG_VIDEO_ISX012_REGDEBUG #ifdef CONFIG_VIDEO_ISX012_REGDEBUG
int isx012_read_register(uint16_t addr, FAR uint8_t *buf, uint8_t size) int isx012_read_register(uint16_t addr, FAR uint8_t *buf, uint8_t size)
{ {
FAR isx012_dev_t *priv = &g_isx012_private;
uint16_t buf16; uint16_t buf16;
if (buf == NULL) if (buf == NULL)
@@ -3184,7 +3193,7 @@ int isx012_read_register(uint16_t addr, FAR uint8_t *buf, uint8_t size)
return -EINVAL; return -EINVAL;
} }
buf16 = isx012_getreg(&g_isx012_private, addr, size); buf16 = isx012_getreg(priv, addr, size);
memcpy(buf, &buf16, size); memcpy(buf, &buf16, size);
return OK; return OK;
} }
drivers/video/isx019.c
+414 -334
View File
File diff suppressed because it is too large Load Diff
drivers/video/video.c
+69 -142
View File
File diff suppressed because it is too large Load Diff
include/nuttx/video/imgdata.h
+38 -7
View File
@@ -45,6 +45,23 @@
#define IMGDATA_PIX_FMT_YUYV (6) #define IMGDATA_PIX_FMT_YUYV (6)
#define IMGDATA_PIX_FMT_YUV420P (7) #define IMGDATA_PIX_FMT_YUV420P (7)
/* Method access helper macros */
#define IMGDATA_INIT(d) \
((d)->ops->init ? (d)->ops->init(d) : -ENOTTY)
#define IMGDATA_UNINIT(d) \
((d)->ops->uninit ? (d)->ops->uninit(d) : -ENOTTY)
#define IMGDATA_SET_BUF(d, a, s) \
((d)->ops->set_buf ? (d)->ops->set_buf(d, a, s) : NULL)
#define IMGDATA_VALIDATE_FRAME_SETTING(d, n, f, i) \
((d)->ops->validate_frame_setting ? \
(d)->ops->validate_frame_setting(d, n, f, i) : -ENOTTY)
#define IMGDATA_START_CAPTURE(d, n, f, i, c) \
((d)->ops->start_capture ? \
(d)->ops->start_capture(d, n, f, i, c) : -ENOTTY)
#define IMGDATA_STOP_CAPTURE(d) \
((d)->ops->stop_capture ? (d)->ops->stop_capture(d) : -ENOTTY)
/**************************************************************************** /****************************************************************************
* Public Types * Public Types
****************************************************************************/ ****************************************************************************/
@@ -68,21 +85,35 @@ typedef int (*imgdata_capture_t)(uint8_t result, uint32_t size);
/* Structure for Data Control I/F */ /* Structure for Data Control I/F */
struct imgdata_s;
struct imgdata_ops_s struct imgdata_ops_s
{ {
CODE int (*init)(void); CODE int (*init)(FAR struct imgdata_s *data);
CODE int (*uninit)(void); CODE int (*uninit)(FAR struct imgdata_s *data);
CODE int (*set_buf)(uint8_t *addr, uint32_t size); CODE int (*set_buf)(FAR struct imgdata_s *data,
uint8_t *addr, uint32_t size);
CODE int (*validate_frame_setting)(uint8_t nr_datafmts, CODE int (*validate_frame_setting)(FAR struct imgdata_s *data,
uint8_t nr_datafmts,
FAR imgdata_format_t *datafmts, FAR imgdata_format_t *datafmts,
FAR imgdata_interval_t *interval); FAR imgdata_interval_t *interval);
CODE int (*start_capture)(uint8_t nr_datafmts, CODE int (*start_capture)(FAR struct imgdata_s *data,
uint8_t nr_datafmts,
FAR imgdata_format_t *datafmts, FAR imgdata_format_t *datafmts,
FAR imgdata_interval_t *interval, FAR imgdata_interval_t *interval,
FAR imgdata_capture_t callback); FAR imgdata_capture_t callback);
CODE int (*stop_capture)(void); CODE int (*stop_capture)(FAR struct imgdata_s *data);
};
/* Image data private data. This structure only defines the initial fields
* of the structure visible to the client. The specific implementation may
* add additional, device specific fields after the vtable.
*/
struct imgdata_s
{
FAR const struct imgdata_ops_s *ops;
}; };
#ifdef __cplusplus #ifdef __cplusplus
@@ -99,7 +130,7 @@ extern "C"
/* Register image data operations. */ /* Register image data operations. */
void imgdata_register(FAR const struct imgdata_ops_s *ops); void imgdata_register(FAR struct imgdata_s *data);
#undef EXTERN #undef EXTERN
#ifdef __cplusplus #ifdef __cplusplus
include/nuttx/video/imgsensor.h
+60 -15
View File
@@ -121,6 +121,35 @@
#define IMGSENSOR_PIX_FMT_YUYV (6) #define IMGSENSOR_PIX_FMT_YUYV (6)
#define IMGSENSOR_PIX_FMT_YUV420P (7) #define IMGSENSOR_PIX_FMT_YUV420P (7)
/* Method access helper macros */
#define IMGSENSOR_IS_AVAILABLE(s) \
((s)->ops->is_available ? (s)->ops->is_available(s) : false)
#define IMGSENSOR_INIT(s) \
((s)->ops->init ? (s)->ops->init(s) : -ENOTTY)
#define IMGSENSOR_UNINIT(s) \
((s)->ops->uninit ? (s)->ops->uninit(s) : -ENOTTY)
#define IMGSENSOR_GET_DRIVER_NAME(s) \
((s)->ops->get_driver_name ? (s)->ops->get_driver_name(s) : NULL)
#define IMGSENSOR_VALIDATE_FRAME_SETTING(s, t, n, f, i) \
((s)->ops->validate_frame_setting ? \
(s)->ops->validate_frame_setting(s, t, n, f, i) : -ENOTTY)
#define IMGSENSOR_START_CAPTURE(s, t, n, f, i) \
((s)->ops->start_capture ? \
(s)->ops->start_capture(s, t, n, f, i) : -ENOTTY)
#define IMGSENSOR_STOP_CAPTURE(s, t) \
((s)->ops->stop_capture ? (s)->ops->stop_capture(s, t) : -ENOTTY)
#define IMGSENSOR_GET_FRAME_INTERVAL(s, t, i) \
((s)->ops->get_frame_interval ? \
(s)->ops->get_frame_interval(s, t, i) : -ENOTTY)
#define IMGSENSOR_GET_SUPPORTED_VALUE(s, i, v) \
((s)->ops->get_supported_value ? \
(s)->ops->get_supported_value(s, i, v) : -ENOTTY)
#define IMGSENSOR_GET_VALUE(s, i, l, v) \
((s)->ops->get_value ? (s)->ops->get_value(s, i, l, v) : -ENOTTY)
#define IMGSENSOR_SET_VALUE(s, i, l, v) \
((s)->ops->set_value ? (s)->ops->set_value(s, i, l, v) : -ENOTTY)
/**************************************************************************** /****************************************************************************
* Public Types * Public Types
****************************************************************************/ ****************************************************************************/
@@ -265,7 +294,7 @@ typedef struct imgsensor_capability_range_s
typedef struct imgsensor_capability_discrete_s typedef struct imgsensor_capability_discrete_s
{ {
int8_t nr_values; int8_t nr_values;
int32_t *values; FAR const int32_t *values;
int32_t default_value; int32_t default_value;
} imgsensor_capability_discrete_t; } imgsensor_capability_discrete_t;
@@ -321,33 +350,49 @@ typedef union imgsensor_value_u
/* Structure for Image Sensor I/F */ /* Structure for Image Sensor I/F */
struct imgsensor_s;
struct imgsensor_ops_s struct imgsensor_ops_s
{ {
CODE bool (*is_available)(void); CODE bool (*is_available)(FAR struct imgsensor_s *sensor);
CODE int (*init)(void); CODE int (*init)(FAR struct imgsensor_s *sensor);
CODE int (*uninit)(void); CODE int (*uninit)(FAR struct imgsensor_s *sensor);
CODE const char * (*get_driver_name)(void); CODE const char * (*get_driver_name)(FAR struct imgsensor_s *sensor);
CODE int (*validate_frame_setting)(imgsensor_stream_type_t type, CODE int (*validate_frame_setting)(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_datafmts, uint8_t nr_datafmts,
FAR imgsensor_format_t *datafmts, FAR imgsensor_format_t *datafmts,
FAR imgsensor_interval_t *interval); FAR imgsensor_interval_t *interval);
CODE int (*start_capture)(imgsensor_stream_type_t type, CODE int (*start_capture)(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
uint8_t nr_datafmts, uint8_t nr_datafmts,
FAR imgsensor_format_t *datafmts, FAR imgsensor_format_t *datafmts,
FAR imgsensor_interval_t *interval); FAR imgsensor_interval_t *interval);
CODE int (*stop_capture)(imgsensor_stream_type_t type); CODE int (*stop_capture)(FAR struct imgsensor_s *sensor,
CODE int (*get_frame_interval)(imgsensor_stream_type_t type, imgsensor_stream_type_t type);
CODE int (*get_frame_interval)(FAR struct imgsensor_s *sensor,
imgsensor_stream_type_t type,
FAR imgsensor_interval_t *interval); FAR imgsensor_interval_t *interval);
CODE int (*get_supported_value)(uint32_t id, CODE int (*get_supported_value)(FAR struct imgsensor_s *sensor,
uint32_t id,
FAR imgsensor_supported_value_t *value); FAR imgsensor_supported_value_t *value);
CODE int (*get_value)(uint32_t id, CODE int (*get_value)(FAR struct imgsensor_s *sensor,
uint32_t size, uint32_t id, uint32_t size,
FAR imgsensor_value_t *value); FAR imgsensor_value_t *value);
CODE int (*set_value)(uint32_t id, CODE int (*set_value)(FAR struct imgsensor_s *sensor,
uint32_t size, uint32_t id, uint32_t size,
imgsensor_value_t value); imgsensor_value_t value);
}; };
/* Image sensor private data. This structure only defines the initial fields
* of the structure visible to the client. The specific implementation may
* add additional, device specific fields after the vtable.
*/
struct imgsensor_s
{
FAR const struct imgsensor_ops_s *ops;
};
#ifdef __cplusplus #ifdef __cplusplus
#define EXTERN extern "C" #define EXTERN extern "C"
extern "C" extern "C"
@@ -362,7 +407,7 @@ extern "C"
/* Register image sensor operations. */ /* Register image sensor operations. */
int imgsensor_register(FAR const struct imgsensor_ops_s *ops); int imgsensor_register(FAR struct imgsensor_s *sensor);
#undef EXTERN #undef EXTERN
#ifdef __cplusplus #ifdef __cplusplus