2019-06-04 16:11:33 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2013-01-08 18:06:31 +08:00
|
|
|
/*
|
|
|
|
* V4L2 asynchronous subdevice registration API
|
|
|
|
*
|
|
|
|
* Copyright (C) 2012-2013, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef V4L2_ASYNC_H
|
|
|
|
#define V4L2_ASYNC_H
|
|
|
|
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
2021-01-09 01:17:28 +08:00
|
|
|
struct dentry;
|
2013-01-08 18:06:31 +08:00
|
|
|
struct device;
|
2013-07-19 23:21:29 +08:00
|
|
|
struct device_node;
|
2013-01-08 18:06:31 +08:00
|
|
|
struct v4l2_device;
|
|
|
|
struct v4l2_subdev;
|
2017-08-31 01:18:04 +08:00
|
|
|
struct v4l2_async_notifier;
|
2013-01-08 18:06:31 +08:00
|
|
|
|
2016-07-21 20:24:55 +08:00
|
|
|
/**
|
|
|
|
* enum v4l2_async_match_type - type of asynchronous subdevice logic to be used
|
|
|
|
* in order to identify a match
|
|
|
|
*
|
2023-05-05 15:09:10 +08:00
|
|
|
* @V4L2_ASYNC_MATCH_TYPE_I2C: Match will check for I2C adapter ID and address
|
|
|
|
* @V4L2_ASYNC_MATCH_TYPE_FWNODE: Match will use firmware node
|
2016-07-21 20:24:55 +08:00
|
|
|
*
|
2023-02-16 21:54:53 +08:00
|
|
|
* This enum is used by the asynchronous connection logic to define the
|
2016-07-21 20:24:55 +08:00
|
|
|
* algorithm that will be used to match an asynchronous device.
|
|
|
|
*/
|
2013-07-19 23:14:46 +08:00
|
|
|
enum v4l2_async_match_type {
|
2023-05-05 15:09:10 +08:00
|
|
|
V4L2_ASYNC_MATCH_TYPE_I2C,
|
|
|
|
V4L2_ASYNC_MATCH_TYPE_FWNODE,
|
2013-01-08 18:06:31 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2023-02-16 21:54:53 +08:00
|
|
|
* struct v4l2_async_match_desc - async connection match information
|
2015-08-22 16:16:24 +08:00
|
|
|
*
|
2023-02-19 20:09:00 +08:00
|
|
|
* @type: type of match that will be used
|
|
|
|
* @fwnode: pointer to &struct fwnode_handle to be matched.
|
2023-05-05 15:09:10 +08:00
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_TYPE_FWNODE.
|
2023-02-19 20:09:00 +08:00
|
|
|
* @i2c: embedded struct with I2C parameters to be matched.
|
2018-01-04 19:47:28 +08:00
|
|
|
* Both @match.i2c.adapter_id and @match.i2c.address
|
2017-09-27 23:43:00 +08:00
|
|
|
* should be matched.
|
2023-05-05 15:09:10 +08:00
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_TYPE_I2C.
|
2023-02-19 20:09:00 +08:00
|
|
|
* @i2c.adapter_id:
|
2017-09-27 23:43:00 +08:00
|
|
|
* I2C adapter ID to be matched.
|
2023-05-05 15:09:10 +08:00
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_TYPE_I2C.
|
2023-02-19 20:09:00 +08:00
|
|
|
* @i2c.address:
|
2017-09-27 23:43:00 +08:00
|
|
|
* I2C address to be matched.
|
2023-05-05 15:09:10 +08:00
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_TYPE_I2C.
|
2023-02-19 20:09:00 +08:00
|
|
|
*/
|
|
|
|
struct v4l2_async_match_desc {
|
|
|
|
enum v4l2_async_match_type type;
|
|
|
|
union {
|
|
|
|
struct fwnode_handle *fwnode;
|
|
|
|
struct {
|
|
|
|
int adapter_id;
|
|
|
|
unsigned short address;
|
|
|
|
} i2c;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2023-05-19 19:44:03 +08:00
|
|
|
* struct v4l2_async_connection - sub-device connection descriptor, as known to
|
|
|
|
* a bridge
|
2023-02-19 20:09:00 +08:00
|
|
|
*
|
|
|
|
* @match: struct of match type and per-bus type matching data sets
|
2023-05-19 19:44:03 +08:00
|
|
|
* @notifier: the async notifier the connection is related to
|
2023-02-16 21:54:53 +08:00
|
|
|
* @asc_entry: used to add struct v4l2_async_connection objects to the
|
2023-04-18 20:00:54 +08:00
|
|
|
* notifier @waiting_list or @done_list
|
2023-05-19 19:44:03 +08:00
|
|
|
* @asc_subdev_entry: entry in struct v4l2_async_subdev.asc_list list
|
2023-04-18 20:00:54 +08:00
|
|
|
* @sd: the related sub-device
|
2017-08-17 23:28:21 +08:00
|
|
|
*
|
2023-05-19 19:44:03 +08:00
|
|
|
* When this struct is used as a member in a driver specific struct, the driver
|
|
|
|
* specific struct shall contain the &struct v4l2_async_connection as its first
|
|
|
|
* member.
|
2013-01-08 18:06:31 +08:00
|
|
|
*/
|
2023-02-16 21:54:53 +08:00
|
|
|
struct v4l2_async_connection {
|
2023-02-19 20:09:00 +08:00
|
|
|
struct v4l2_async_match_desc match;
|
2023-05-19 19:44:03 +08:00
|
|
|
struct v4l2_async_notifier *notifier;
|
2023-02-16 21:54:53 +08:00
|
|
|
struct list_head asc_entry;
|
2023-05-19 19:44:03 +08:00
|
|
|
struct list_head asc_subdev_entry;
|
2023-04-18 20:00:54 +08:00
|
|
|
struct v4l2_subdev *sd;
|
2013-01-08 18:06:31 +08:00
|
|
|
};
|
|
|
|
|
2017-08-31 01:18:04 +08:00
|
|
|
/**
|
|
|
|
* struct v4l2_async_notifier_operations - Asynchronous V4L2 notifier operations
|
2023-05-19 19:44:03 +08:00
|
|
|
* @bound: a sub-device has been bound by the given connection
|
|
|
|
* @complete: All connections have been bound successfully. The complete
|
2017-09-25 08:54:31 +08:00
|
|
|
* callback is only executed for the root notifier.
|
2017-08-31 01:18:04 +08:00
|
|
|
* @unbind: a subdevice is leaving
|
2023-02-16 21:54:53 +08:00
|
|
|
* @destroy: the asc is about to be freed
|
2017-08-31 01:18:04 +08:00
|
|
|
*/
|
|
|
|
struct v4l2_async_notifier_operations {
|
|
|
|
int (*bound)(struct v4l2_async_notifier *notifier,
|
|
|
|
struct v4l2_subdev *subdev,
|
2023-02-16 21:54:53 +08:00
|
|
|
struct v4l2_async_connection *asc);
|
2017-08-31 01:18:04 +08:00
|
|
|
int (*complete)(struct v4l2_async_notifier *notifier);
|
|
|
|
void (*unbind)(struct v4l2_async_notifier *notifier,
|
|
|
|
struct v4l2_subdev *subdev,
|
2023-02-16 21:54:53 +08:00
|
|
|
struct v4l2_async_connection *asc);
|
|
|
|
void (*destroy)(struct v4l2_async_connection *asc);
|
2017-08-31 01:18:04 +08:00
|
|
|
};
|
|
|
|
|
2013-01-08 18:06:31 +08:00
|
|
|
/**
|
2015-08-22 16:16:24 +08:00
|
|
|
* struct v4l2_async_notifier - v4l2_device notifier data
|
|
|
|
*
|
2017-08-31 01:18:04 +08:00
|
|
|
* @ops: notifier operations
|
2017-09-25 08:54:31 +08:00
|
|
|
* @v4l2_dev: v4l2_device of the root notifier, NULL otherwise
|
|
|
|
* @sd: sub-device that registered the notifier, NULL otherwise
|
|
|
|
* @parent: parent notifier
|
2023-02-16 21:54:53 +08:00
|
|
|
* @waiting_list: list of struct v4l2_async_connection, waiting for their
|
|
|
|
* drivers
|
2023-02-22 19:02:39 +08:00
|
|
|
* @done_list: list of struct v4l2_subdev, already probed
|
|
|
|
* @notifier_entry: member in a global list of notifiers
|
2013-01-08 18:06:31 +08:00
|
|
|
*/
|
|
|
|
struct v4l2_async_notifier {
|
2017-08-31 01:18:04 +08:00
|
|
|
const struct v4l2_async_notifier_operations *ops;
|
2013-01-08 18:06:31 +08:00
|
|
|
struct v4l2_device *v4l2_dev;
|
2017-09-25 08:54:31 +08:00
|
|
|
struct v4l2_subdev *sd;
|
|
|
|
struct v4l2_async_notifier *parent;
|
2023-02-22 19:02:39 +08:00
|
|
|
struct list_head waiting_list;
|
|
|
|
struct list_head done_list;
|
|
|
|
struct list_head notifier_entry;
|
2013-01-08 18:06:31 +08:00
|
|
|
};
|
|
|
|
|
2023-04-28 21:58:42 +08:00
|
|
|
/**
|
|
|
|
* struct v4l2_async_subdev_endpoint - Entry in sub-device's fwnode list
|
|
|
|
*
|
|
|
|
* @async_subdev_endpoint_entry: An entry in async_subdev_endpoint_list of
|
|
|
|
* &struct v4l2_subdev
|
|
|
|
* @endpoint: Endpoint fwnode agains which to match the sub-device
|
|
|
|
*/
|
|
|
|
struct v4l2_async_subdev_endpoint {
|
|
|
|
struct list_head async_subdev_endpoint_entry;
|
|
|
|
struct fwnode_handle *endpoint;
|
|
|
|
};
|
|
|
|
|
2021-01-09 01:17:28 +08:00
|
|
|
/**
|
|
|
|
* v4l2_async_debug_init - Initialize debugging tools.
|
|
|
|
*
|
|
|
|
* @debugfs_dir: pointer to the parent debugfs &struct dentry
|
|
|
|
*/
|
|
|
|
void v4l2_async_debug_init(struct dentry *debugfs_dir);
|
|
|
|
|
media: v4l2: async: Add v4l2_async_notifier_add_subdev
v4l2_async_notifier_add_subdev() adds an asd to the notifier. It checks
that no other equivalent asd's have already been added to this notifier's
asd list, or to other registered notifier's waiting or done lists, and
increments num_subdevs.
v4l2_async_notifier_add_subdev() does not make use of the notifier subdevs
array, otherwise it would have to re-allocate the array every time the
function was called. In place of the subdevs array, the function adds
the newly allocated asd to a new master asd_list. The function will
return error with a WARN() if it is ever called with the subdevs array
allocated.
Drivers are now required to call a v4l2_async_notifier_init(), before the
first call to v4l2_async_notifier_add_subdev(), in order to initialize
the asd_list.
In v4l2_async_notifier_has_async_subdev(), __v4l2_async_notifier_register(),
and v4l2_async_notifier_cleanup(), maintain backward compatibility with
the subdevs array, by alternatively operate on the subdevs array or a
non-empty notifier->asd_list.
Signed-off-by: Steve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
2018-09-30 03:54:06 +08:00
|
|
|
/**
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_init - Initialize a notifier.
|
media: v4l2: async: Add v4l2_async_notifier_add_subdev
v4l2_async_notifier_add_subdev() adds an asd to the notifier. It checks
that no other equivalent asd's have already been added to this notifier's
asd list, or to other registered notifier's waiting or done lists, and
increments num_subdevs.
v4l2_async_notifier_add_subdev() does not make use of the notifier subdevs
array, otherwise it would have to re-allocate the array every time the
function was called. In place of the subdevs array, the function adds
the newly allocated asd to a new master asd_list. The function will
return error with a WARN() if it is ever called with the subdevs array
allocated.
Drivers are now required to call a v4l2_async_notifier_init(), before the
first call to v4l2_async_notifier_add_subdev(), in order to initialize
the asd_list.
In v4l2_async_notifier_has_async_subdev(), __v4l2_async_notifier_register(),
and v4l2_async_notifier_cleanup(), maintain backward compatibility with
the subdevs array, by alternatively operate on the subdevs array or a
non-empty notifier->asd_list.
Signed-off-by: Steve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
2018-09-30 03:54:06 +08:00
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
2023-02-23 23:24:48 +08:00
|
|
|
* @v4l2_dev: pointer to &struct v4l2_device
|
|
|
|
*
|
|
|
|
* This function initializes the notifier @asc_entry. It must be called
|
|
|
|
* before adding a subdevice to a notifier, using one of:
|
|
|
|
* v4l2_async_nf_add_fwnode_remote(),
|
|
|
|
* v4l2_async_nf_add_fwnode() or
|
|
|
|
* v4l2_async_nf_add_i2c().
|
|
|
|
*/
|
|
|
|
void v4l2_async_nf_init(struct v4l2_async_notifier *notifier,
|
|
|
|
struct v4l2_device *v4l2_dev);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v4l2_async_subdev_nf_init - Initialize a sub-device notifier.
|
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
* @sd: pointer to &struct v4l2_subdev
|
media: v4l2: async: Add v4l2_async_notifier_add_subdev
v4l2_async_notifier_add_subdev() adds an asd to the notifier. It checks
that no other equivalent asd's have already been added to this notifier's
asd list, or to other registered notifier's waiting or done lists, and
increments num_subdevs.
v4l2_async_notifier_add_subdev() does not make use of the notifier subdevs
array, otherwise it would have to re-allocate the array every time the
function was called. In place of the subdevs array, the function adds
the newly allocated asd to a new master asd_list. The function will
return error with a WARN() if it is ever called with the subdevs array
allocated.
Drivers are now required to call a v4l2_async_notifier_init(), before the
first call to v4l2_async_notifier_add_subdev(), in order to initialize
the asd_list.
In v4l2_async_notifier_has_async_subdev(), __v4l2_async_notifier_register(),
and v4l2_async_notifier_cleanup(), maintain backward compatibility with
the subdevs array, by alternatively operate on the subdevs array or a
non-empty notifier->asd_list.
Signed-off-by: Steve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
2018-09-30 03:54:06 +08:00
|
|
|
*
|
2023-02-16 21:54:53 +08:00
|
|
|
* This function initializes the notifier @asc_list. It must be called
|
2021-01-18 09:52:55 +08:00
|
|
|
* before adding a subdevice to a notifier, using one of:
|
2023-04-18 17:52:07 +08:00
|
|
|
* v4l2_async_nf_add_fwnode_remote(), v4l2_async_nf_add_fwnode() or
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_add_i2c().
|
media: v4l2: async: Add v4l2_async_notifier_add_subdev
v4l2_async_notifier_add_subdev() adds an asd to the notifier. It checks
that no other equivalent asd's have already been added to this notifier's
asd list, or to other registered notifier's waiting or done lists, and
increments num_subdevs.
v4l2_async_notifier_add_subdev() does not make use of the notifier subdevs
array, otherwise it would have to re-allocate the array every time the
function was called. In place of the subdevs array, the function adds
the newly allocated asd to a new master asd_list. The function will
return error with a WARN() if it is ever called with the subdevs array
allocated.
Drivers are now required to call a v4l2_async_notifier_init(), before the
first call to v4l2_async_notifier_add_subdev(), in order to initialize
the asd_list.
In v4l2_async_notifier_has_async_subdev(), __v4l2_async_notifier_register(),
and v4l2_async_notifier_cleanup(), maintain backward compatibility with
the subdevs array, by alternatively operate on the subdevs array or a
non-empty notifier->asd_list.
Signed-off-by: Steve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
2018-09-30 03:54:06 +08:00
|
|
|
*/
|
2023-02-23 23:24:48 +08:00
|
|
|
void v4l2_async_subdev_nf_init(struct v4l2_async_notifier *notifier,
|
|
|
|
struct v4l2_subdev *sd);
|
media: v4l2: async: Add v4l2_async_notifier_add_subdev
v4l2_async_notifier_add_subdev() adds an asd to the notifier. It checks
that no other equivalent asd's have already been added to this notifier's
asd list, or to other registered notifier's waiting or done lists, and
increments num_subdevs.
v4l2_async_notifier_add_subdev() does not make use of the notifier subdevs
array, otherwise it would have to re-allocate the array every time the
function was called. In place of the subdevs array, the function adds
the newly allocated asd to a new master asd_list. The function will
return error with a WARN() if it is ever called with the subdevs array
allocated.
Drivers are now required to call a v4l2_async_notifier_init(), before the
first call to v4l2_async_notifier_add_subdev(), in order to initialize
the asd_list.
In v4l2_async_notifier_has_async_subdev(), __v4l2_async_notifier_register(),
and v4l2_async_notifier_cleanup(), maintain backward compatibility with
the subdevs array, by alternatively operate on the subdevs array or a
non-empty notifier->asd_list.
Signed-off-by: Steve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
2018-09-30 03:54:06 +08:00
|
|
|
|
2023-02-16 21:54:53 +08:00
|
|
|
struct v4l2_async_connection *
|
2021-03-06 01:13:12 +08:00
|
|
|
__v4l2_async_nf_add_fwnode(struct v4l2_async_notifier *notifier,
|
|
|
|
struct fwnode_handle *fwnode,
|
2023-02-16 21:54:53 +08:00
|
|
|
unsigned int asc_struct_size);
|
2018-09-30 03:54:07 +08:00
|
|
|
/**
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_add_fwnode - Allocate and add a fwnode async
|
2023-02-16 21:54:53 +08:00
|
|
|
* subdev to the notifier's master asc_list.
|
2018-09-30 03:54:07 +08:00
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
2021-02-15 20:37:28 +08:00
|
|
|
* @fwnode: fwnode handle of the sub-device to be matched, pointer to
|
|
|
|
* &struct fwnode_handle
|
2023-02-16 21:54:53 +08:00
|
|
|
* @type: Type of the driver's async sub-device or connection struct. The
|
|
|
|
* &struct v4l2_async_connection shall be the first member of the
|
|
|
|
* driver's async struct, i.e. both begin at the same memory address.
|
2018-09-30 03:54:07 +08:00
|
|
|
*
|
2023-02-16 21:54:53 +08:00
|
|
|
* Allocate a fwnode-matched asc of size asc_struct_size, and add it to the
|
|
|
|
* notifiers @asc_list. The function also gets a reference of the fwnode which
|
2019-04-05 07:43:29 +08:00
|
|
|
* is released later at notifier cleanup time.
|
2018-09-30 03:54:07 +08:00
|
|
|
*/
|
2021-03-06 01:13:12 +08:00
|
|
|
#define v4l2_async_nf_add_fwnode(notifier, fwnode, type) \
|
|
|
|
((type *)__v4l2_async_nf_add_fwnode(notifier, fwnode, sizeof(type)))
|
2018-09-30 03:54:07 +08:00
|
|
|
|
2023-02-16 21:54:53 +08:00
|
|
|
struct v4l2_async_connection *
|
2021-03-06 01:13:12 +08:00
|
|
|
__v4l2_async_nf_add_fwnode_remote(struct v4l2_async_notifier *notif,
|
|
|
|
struct fwnode_handle *endpoint,
|
2023-02-16 21:54:53 +08:00
|
|
|
unsigned int asc_struct_size);
|
2019-02-28 21:25:28 +08:00
|
|
|
/**
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_add_fwnode_remote - Allocate and add a fwnode
|
2019-02-28 21:25:28 +08:00
|
|
|
* remote async subdev to the
|
2023-02-16 21:54:53 +08:00
|
|
|
* notifier's master asc_list.
|
2019-02-28 21:25:28 +08:00
|
|
|
*
|
2021-02-15 20:37:28 +08:00
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
2023-02-16 21:54:53 +08:00
|
|
|
* @ep: local endpoint pointing to the remote connection to be matched,
|
2021-02-15 20:37:28 +08:00
|
|
|
* pointer to &struct fwnode_handle
|
2023-02-16 21:54:53 +08:00
|
|
|
* @type: Type of the driver's async connection struct. The &struct
|
|
|
|
* v4l2_async_connection shall be the first member of the driver's async
|
|
|
|
* connection struct, i.e. both begin at the same memory address.
|
2019-02-28 21:25:28 +08:00
|
|
|
*
|
|
|
|
* Gets the remote endpoint of a given local endpoint, set it up for fwnode
|
2023-02-16 21:54:53 +08:00
|
|
|
* matching and adds the async connection to the notifier's @asc_list. The
|
2019-02-28 21:25:28 +08:00
|
|
|
* function also gets a reference of the fwnode which is released later at
|
|
|
|
* notifier cleanup time.
|
|
|
|
*
|
2021-03-06 01:13:12 +08:00
|
|
|
* This is just like v4l2_async_nf_add_fwnode(), but with the
|
2021-01-18 09:52:45 +08:00
|
|
|
* exception that the fwnode refers to a local endpoint, not the remote one.
|
2019-02-28 21:25:28 +08:00
|
|
|
*/
|
2021-03-06 01:13:12 +08:00
|
|
|
#define v4l2_async_nf_add_fwnode_remote(notifier, ep, type) \
|
|
|
|
((type *)__v4l2_async_nf_add_fwnode_remote(notifier, ep, sizeof(type)))
|
2019-02-28 21:25:28 +08:00
|
|
|
|
2023-02-16 21:54:53 +08:00
|
|
|
struct v4l2_async_connection *
|
2021-03-06 01:13:12 +08:00
|
|
|
__v4l2_async_nf_add_i2c(struct v4l2_async_notifier *notifier,
|
|
|
|
int adapter_id, unsigned short address,
|
2023-02-16 21:54:53 +08:00
|
|
|
unsigned int asc_struct_size);
|
2018-09-30 03:54:07 +08:00
|
|
|
/**
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_add_i2c - Allocate and add an i2c async
|
2023-02-16 21:54:53 +08:00
|
|
|
* subdev to the notifier's master asc_list.
|
2018-09-30 03:54:07 +08:00
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
2021-02-15 20:37:28 +08:00
|
|
|
* @adapter: I2C adapter ID to be matched
|
2023-02-16 21:54:53 +08:00
|
|
|
* @address: I2C address of connection to be matched
|
|
|
|
* @type: Type of the driver's async connection struct. The &struct
|
|
|
|
* v4l2_async_connection shall be the first member of the driver's async
|
|
|
|
* connection struct, i.e. both begin at the same memory address.
|
2018-09-30 03:54:07 +08:00
|
|
|
*
|
2021-03-06 01:13:12 +08:00
|
|
|
* Same as v4l2_async_nf_add_fwnode() but for I2C matched
|
2023-02-16 21:54:53 +08:00
|
|
|
* connections.
|
2018-09-30 03:54:07 +08:00
|
|
|
*/
|
2021-03-06 01:13:12 +08:00
|
|
|
#define v4l2_async_nf_add_i2c(notifier, adapter, address, type) \
|
|
|
|
((type *)__v4l2_async_nf_add_i2c(notifier, adapter, address, \
|
|
|
|
sizeof(type)))
|
2018-09-30 03:54:07 +08:00
|
|
|
|
2023-04-28 21:58:42 +08:00
|
|
|
/**
|
|
|
|
* v4l2_async_subdev_endpoint_add - Add an endpoint fwnode to async sub-device
|
|
|
|
* matching list
|
|
|
|
*
|
|
|
|
* @sd: the sub-device
|
|
|
|
* @fwnode: the endpoint fwnode to match
|
|
|
|
*
|
|
|
|
* Add a fwnode to the async sub-device's matching list. This allows registering
|
|
|
|
* multiple async sub-devices from a single device.
|
|
|
|
*
|
|
|
|
* Note that calling v4l2_subdev_cleanup() as part of the sub-device's cleanup
|
|
|
|
* if endpoints have been added to the sub-device's fwnode matching list.
|
|
|
|
*
|
|
|
|
* Returns an error on failure, 0 on success.
|
|
|
|
*/
|
|
|
|
int v4l2_async_subdev_endpoint_add(struct v4l2_subdev *sd,
|
|
|
|
struct fwnode_handle *fwnode);
|
|
|
|
|
2023-05-15 17:06:50 +08:00
|
|
|
/**
|
|
|
|
* v4l2_async_connection_unique - return a unique &struct v4l2_async_connection
|
|
|
|
* for a sub-device
|
|
|
|
* @sd: the sub-device
|
|
|
|
*
|
|
|
|
* Return an async connection for a sub-device, when there is a single
|
|
|
|
* one only.
|
|
|
|
*/
|
|
|
|
struct v4l2_async_connection *
|
|
|
|
v4l2_async_connection_unique(struct v4l2_subdev *sd);
|
|
|
|
|
2016-07-21 20:24:55 +08:00
|
|
|
/**
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_register - registers a subdevice asynchronous notifier
|
2016-07-21 20:24:55 +08:00
|
|
|
*
|
2017-09-25 08:54:31 +08:00
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
*/
|
2023-02-23 23:24:48 +08:00
|
|
|
int v4l2_async_nf_register(struct v4l2_async_notifier *notifier);
|
2017-09-25 08:54:31 +08:00
|
|
|
|
2016-07-21 20:24:55 +08:00
|
|
|
/**
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_unregister - unregisters a subdevice
|
2018-10-05 05:10:46 +08:00
|
|
|
* asynchronous notifier
|
2016-07-21 20:24:55 +08:00
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
*/
|
2021-03-06 01:13:12 +08:00
|
|
|
void v4l2_async_nf_unregister(struct v4l2_async_notifier *notifier);
|
2016-07-21 20:24:55 +08:00
|
|
|
|
2017-08-17 23:28:21 +08:00
|
|
|
/**
|
2021-03-06 01:13:12 +08:00
|
|
|
* v4l2_async_nf_cleanup - clean up notifier resources
|
2017-08-17 23:28:21 +08:00
|
|
|
* @notifier: the notifier the resources of which are to be cleaned up
|
|
|
|
*
|
|
|
|
* Release memory resources related to a notifier, including the async
|
2023-02-16 21:54:53 +08:00
|
|
|
* connections allocated for the purposes of the notifier but not the notifier
|
2017-08-17 23:28:21 +08:00
|
|
|
* itself. The user is responsible for calling this function to clean up the
|
2023-04-18 17:52:07 +08:00
|
|
|
* notifier after calling v4l2_async_nf_add_fwnode_remote(),
|
|
|
|
* v4l2_async_nf_add_fwnode() or v4l2_async_nf_add_i2c().
|
2017-08-17 23:28:21 +08:00
|
|
|
*
|
2021-03-06 01:13:12 +08:00
|
|
|
* There is no harm from calling v4l2_async_nf_cleanup() in other
|
2017-08-17 23:28:21 +08:00
|
|
|
* cases as long as its memory has been zeroed after it has been
|
|
|
|
* allocated.
|
|
|
|
*/
|
2021-03-06 01:13:12 +08:00
|
|
|
void v4l2_async_nf_cleanup(struct v4l2_async_notifier *notifier);
|
2017-08-17 23:28:21 +08:00
|
|
|
|
2016-07-21 20:24:55 +08:00
|
|
|
/**
|
|
|
|
* v4l2_async_register_subdev - registers a sub-device to the asynchronous
|
2018-01-04 19:47:28 +08:00
|
|
|
* subdevice framework
|
2016-07-21 20:24:55 +08:00
|
|
|
*
|
|
|
|
* @sd: pointer to &struct v4l2_subdev
|
|
|
|
*/
|
2013-01-08 18:06:31 +08:00
|
|
|
int v4l2_async_register_subdev(struct v4l2_subdev *sd);
|
2016-07-21 20:24:55 +08:00
|
|
|
|
2017-09-25 06:47:44 +08:00
|
|
|
/**
|
2021-03-06 00:42:34 +08:00
|
|
|
* v4l2_async_register_subdev_sensor - registers a sensor sub-device to the
|
|
|
|
* asynchronous sub-device framework and
|
|
|
|
* parse set up common sensor related
|
|
|
|
* devices
|
2017-09-25 06:47:44 +08:00
|
|
|
*
|
|
|
|
* @sd: pointer to struct &v4l2_subdev
|
|
|
|
*
|
|
|
|
* This function is just like v4l2_async_register_subdev() with the exception
|
|
|
|
* that calling it will also parse firmware interfaces for remote references
|
2021-03-06 01:13:12 +08:00
|
|
|
* using v4l2_async_nf_parse_fwnode_sensor() and registers the
|
2017-09-25 06:47:44 +08:00
|
|
|
* async sub-devices. The sub-device is similarly unregistered by calling
|
|
|
|
* v4l2_async_unregister_subdev().
|
|
|
|
*
|
|
|
|
* While registered, the subdev module is marked as in-use.
|
|
|
|
*
|
|
|
|
* An error is returned if the module is no longer loaded on any attempts
|
|
|
|
* to register it.
|
|
|
|
*/
|
2018-10-05 05:10:46 +08:00
|
|
|
int __must_check
|
2021-03-06 00:42:34 +08:00
|
|
|
v4l2_async_register_subdev_sensor(struct v4l2_subdev *sd);
|
2017-09-25 06:47:44 +08:00
|
|
|
|
2016-07-21 20:24:55 +08:00
|
|
|
/**
|
|
|
|
* v4l2_async_unregister_subdev - unregisters a sub-device to the asynchronous
|
2018-01-04 19:47:28 +08:00
|
|
|
* subdevice framework
|
2016-07-21 20:24:55 +08:00
|
|
|
*
|
|
|
|
* @sd: pointer to &struct v4l2_subdev
|
|
|
|
*/
|
2013-01-08 18:06:31 +08:00
|
|
|
void v4l2_async_unregister_subdev(struct v4l2_subdev *sd);
|
|
|
|
#endif
|