2019-06-04 08:11:33 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2013-01-08 10:06:31 +00: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-08 17:17:28 +00:00
|
|
|
struct dentry;
|
2013-01-08 10:06:31 +00:00
|
|
|
struct device;
|
2013-07-19 15:21:29 +00:00
|
|
|
struct device_node;
|
2013-01-08 10:06:31 +00:00
|
|
|
struct v4l2_device;
|
|
|
|
struct v4l2_subdev;
|
2017-08-30 17:18:04 +00:00
|
|
|
struct v4l2_async_notifier;
|
2013-01-08 10:06:31 +00:00
|
|
|
|
2016-07-21 12:24:55 +00:00
|
|
|
/**
|
|
|
|
* enum v4l2_async_match_type - type of asynchronous subdevice logic to be used
|
|
|
|
* in order to identify a match
|
|
|
|
*
|
|
|
|
* @V4L2_ASYNC_MATCH_I2C: Match will check for I2C adapter ID and address
|
2016-08-16 09:54:59 +00:00
|
|
|
* @V4L2_ASYNC_MATCH_FWNODE: Match will use firmware node
|
2016-07-21 12:24:55 +00:00
|
|
|
*
|
2020-09-16 10:46:45 +00:00
|
|
|
* This enum is used by the asynchronous sub-device logic to define the
|
2016-07-21 12:24:55 +00:00
|
|
|
* algorithm that will be used to match an asynchronous device.
|
|
|
|
*/
|
2013-07-19 15:14:46 +00:00
|
|
|
enum v4l2_async_match_type {
|
|
|
|
V4L2_ASYNC_MATCH_I2C,
|
2016-08-16 09:54:59 +00:00
|
|
|
V4L2_ASYNC_MATCH_FWNODE,
|
2013-01-08 10:06:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct v4l2_async_subdev - sub-device descriptor, as known to a bridge
|
2015-08-22 08:16:24 +00:00
|
|
|
*
|
|
|
|
* @match_type: type of match that will be used
|
2013-01-08 10:06:31 +00:00
|
|
|
* @match: union of per-bus type matching data sets
|
2017-09-27 15:43:00 +00:00
|
|
|
* @match.fwnode:
|
|
|
|
* pointer to &struct fwnode_handle to be matched.
|
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_FWNODE.
|
|
|
|
* @match.i2c: embedded struct with I2C parameters to be matched.
|
2018-01-04 11:47:28 +00:00
|
|
|
* Both @match.i2c.adapter_id and @match.i2c.address
|
2017-09-27 15:43:00 +00:00
|
|
|
* should be matched.
|
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_I2C.
|
|
|
|
* @match.i2c.adapter_id:
|
|
|
|
* I2C adapter ID to be matched.
|
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_I2C.
|
|
|
|
* @match.i2c.address:
|
|
|
|
* I2C address to be matched.
|
|
|
|
* Used if @match_type is %V4L2_ASYNC_MATCH_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-29 19:54:06 +00:00
|
|
|
* @asd_list: used to add struct v4l2_async_subdev objects to the
|
|
|
|
* master notifier @asd_list
|
2013-01-08 10:06:31 +00:00
|
|
|
* @list: used to link struct v4l2_async_subdev objects, waiting to be
|
|
|
|
* probed, to a notifier->waiting list
|
2017-08-17 15:28:21 +00:00
|
|
|
*
|
|
|
|
* When this struct is used as a member in a driver specific struct,
|
|
|
|
* the driver specific struct shall contain the &struct
|
|
|
|
* v4l2_async_subdev as its first member.
|
2013-01-08 10:06:31 +00:00
|
|
|
*/
|
|
|
|
struct v4l2_async_subdev {
|
2013-07-19 15:14:46 +00:00
|
|
|
enum v4l2_async_match_type match_type;
|
2013-01-08 10:06:31 +00:00
|
|
|
union {
|
2017-09-27 14:12:00 +00:00
|
|
|
struct fwnode_handle *fwnode;
|
2013-01-08 10:06:31 +00:00
|
|
|
struct {
|
|
|
|
int adapter_id;
|
|
|
|
unsigned short address;
|
|
|
|
} i2c;
|
|
|
|
} match;
|
|
|
|
|
|
|
|
/* v4l2-async core private: not to be used by drivers */
|
|
|
|
struct list_head list;
|
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-29 19:54:06 +00:00
|
|
|
struct list_head asd_list;
|
2013-01-08 10:06:31 +00:00
|
|
|
};
|
|
|
|
|
2017-08-30 17:18:04 +00:00
|
|
|
/**
|
|
|
|
* struct v4l2_async_notifier_operations - Asynchronous V4L2 notifier operations
|
|
|
|
* @bound: a subdevice driver has successfully probed one of the subdevices
|
2017-09-25 00:54:31 +00:00
|
|
|
* @complete: All subdevices have been probed successfully. The complete
|
|
|
|
* callback is only executed for the root notifier.
|
2017-08-30 17:18:04 +00:00
|
|
|
* @unbind: a subdevice is leaving
|
|
|
|
*/
|
|
|
|
struct v4l2_async_notifier_operations {
|
|
|
|
int (*bound)(struct v4l2_async_notifier *notifier,
|
|
|
|
struct v4l2_subdev *subdev,
|
|
|
|
struct v4l2_async_subdev *asd);
|
|
|
|
int (*complete)(struct v4l2_async_notifier *notifier);
|
|
|
|
void (*unbind)(struct v4l2_async_notifier *notifier,
|
|
|
|
struct v4l2_subdev *subdev,
|
|
|
|
struct v4l2_async_subdev *asd);
|
|
|
|
};
|
|
|
|
|
2013-01-08 10:06:31 +00:00
|
|
|
/**
|
2015-08-22 08:16:24 +00:00
|
|
|
* struct v4l2_async_notifier - v4l2_device notifier data
|
|
|
|
*
|
2017-08-30 17:18:04 +00:00
|
|
|
* @ops: notifier operations
|
2017-09-25 00:54:31 +00:00
|
|
|
* @v4l2_dev: v4l2_device of the root notifier, NULL otherwise
|
|
|
|
* @sd: sub-device that registered the notifier, NULL otherwise
|
|
|
|
* @parent: parent notifier
|
2018-09-29 19:54:19 +00:00
|
|
|
* @asd_list: master list of struct v4l2_async_subdev
|
2013-01-08 10:06:31 +00:00
|
|
|
* @waiting: list of struct v4l2_async_subdev, waiting for their drivers
|
2013-07-22 11:01:33 +00:00
|
|
|
* @done: list of struct v4l2_subdev, already probed
|
2013-01-08 10:06:31 +00:00
|
|
|
* @list: member in a global list of notifiers
|
|
|
|
*/
|
|
|
|
struct v4l2_async_notifier {
|
2017-08-30 17:18:04 +00:00
|
|
|
const struct v4l2_async_notifier_operations *ops;
|
2013-01-08 10:06:31 +00:00
|
|
|
struct v4l2_device *v4l2_dev;
|
2017-09-25 00:54:31 +00:00
|
|
|
struct v4l2_subdev *sd;
|
|
|
|
struct v4l2_async_notifier *parent;
|
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-29 19:54:06 +00:00
|
|
|
struct list_head asd_list;
|
2013-01-08 10:06:31 +00:00
|
|
|
struct list_head waiting;
|
|
|
|
struct list_head done;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
2021-01-08 17:17:28 +00: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-29 19:54:06 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_notifier_init - Initialize a notifier.
|
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
*
|
|
|
|
* This function initializes the notifier @asd_list. It must be called
|
2021-01-18 01:52:55 +00:00
|
|
|
* before adding a subdevice to a notifier, using one of:
|
|
|
|
* @v4l2_async_notifier_add_fwnode_remote_subdev,
|
|
|
|
* @v4l2_async_notifier_add_fwnode_subdev,
|
|
|
|
* @v4l2_async_notifier_add_i2c_subdev,
|
|
|
|
* @__v4l2_async_notifier_add_subdev or
|
|
|
|
* @v4l2_async_notifier_parse_fwnode_endpoints.
|
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-29 19:54:06 +00:00
|
|
|
*/
|
|
|
|
void v4l2_async_notifier_init(struct v4l2_async_notifier *notifier);
|
|
|
|
|
|
|
|
/**
|
2021-01-18 01:52:57 +00:00
|
|
|
* __v4l2_async_notifier_add_subdev - Add an async subdev to the
|
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-29 19:54:06 +00:00
|
|
|
* notifier's master asd list.
|
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
* @asd: pointer to &struct v4l2_async_subdev
|
|
|
|
*
|
2021-01-18 01:52:57 +00:00
|
|
|
* \warning: Drivers should avoid using this function and instead use one of:
|
|
|
|
* @v4l2_async_notifier_add_fwnode_subdev,
|
|
|
|
* @v4l2_async_notifier_add_fwnode_remote_subdev or
|
|
|
|
* @v4l2_async_notifier_add_i2c_subdev.
|
|
|
|
*
|
2020-08-11 20:59:35 +00:00
|
|
|
* Call this function before registering a notifier to link the provided @asd to
|
|
|
|
* the notifiers master @asd_list. The @asd must be allocated with k*alloc() as
|
|
|
|
* it will be freed by the framework when the notifier is destroyed.
|
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-29 19:54:06 +00:00
|
|
|
*/
|
2021-01-18 01:52:57 +00:00
|
|
|
int __v4l2_async_notifier_add_subdev(struct v4l2_async_notifier *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-29 19:54:06 +00:00
|
|
|
struct v4l2_async_subdev *asd);
|
|
|
|
|
2021-02-15 12:37:28 +00:00
|
|
|
struct v4l2_async_subdev *
|
|
|
|
__v4l2_async_notifier_add_fwnode_subdev(struct v4l2_async_notifier *notifier,
|
|
|
|
struct fwnode_handle *fwnode,
|
|
|
|
unsigned int asd_struct_size);
|
2018-09-29 19:54:07 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_notifier_add_fwnode_subdev - Allocate and add a fwnode async
|
|
|
|
* subdev to the notifier's master asd_list.
|
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
2021-02-15 12:37:28 +00:00
|
|
|
* @fwnode: fwnode handle of the sub-device to be matched, pointer to
|
|
|
|
* &struct fwnode_handle
|
|
|
|
* @type: Type of the driver's async sub-device struct. The &struct
|
|
|
|
* v4l2_async_subdev shall be the first member of the driver's async
|
|
|
|
* sub-device struct, i.e. both begin at the same memory address.
|
2018-09-29 19:54:07 +00:00
|
|
|
*
|
2019-04-04 23:43:29 +00:00
|
|
|
* Allocate a fwnode-matched asd of size asd_struct_size, and add it to the
|
|
|
|
* notifiers @asd_list. The function also gets a reference of the fwnode which
|
|
|
|
* is released later at notifier cleanup time.
|
2018-09-29 19:54:07 +00:00
|
|
|
*/
|
2021-02-15 12:37:28 +00:00
|
|
|
#define v4l2_async_notifier_add_fwnode_subdev(notifier, fwnode, type) \
|
|
|
|
((type *)__v4l2_async_notifier_add_fwnode_subdev(notifier, fwnode, \
|
|
|
|
sizeof(type)))
|
2018-09-29 19:54:07 +00:00
|
|
|
|
2021-02-15 12:37:28 +00:00
|
|
|
struct v4l2_async_subdev *
|
|
|
|
__v4l2_async_notifier_add_fwnode_remote_subdev(struct v4l2_async_notifier *notif,
|
|
|
|
struct fwnode_handle *endpoint,
|
|
|
|
unsigned int asd_struct_size);
|
2019-02-28 13:25:28 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_notifier_add_fwnode_remote_subdev - Allocate and add a fwnode
|
|
|
|
* remote async subdev to the
|
|
|
|
* notifier's master asd_list.
|
|
|
|
*
|
2021-02-15 12:37:28 +00:00
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
* @ep: local endpoint pointing to the remote sub-device to be matched,
|
|
|
|
* pointer to &struct fwnode_handle
|
|
|
|
* @type: Type of the driver's async sub-device struct. The &struct
|
|
|
|
* v4l2_async_subdev shall be the first member of the driver's async
|
|
|
|
* sub-device struct, i.e. both begin at the same memory address.
|
2019-02-28 13:25:28 +00:00
|
|
|
*
|
|
|
|
* Gets the remote endpoint of a given local endpoint, set it up for fwnode
|
|
|
|
* matching and adds the async sub-device to the notifier's @asd_list. The
|
|
|
|
* function also gets a reference of the fwnode which is released later at
|
|
|
|
* notifier cleanup time.
|
|
|
|
*
|
|
|
|
* This is just like @v4l2_async_notifier_add_fwnode_subdev, but with the
|
2021-01-18 01:52:45 +00:00
|
|
|
* exception that the fwnode refers to a local endpoint, not the remote one.
|
2019-02-28 13:25:28 +00:00
|
|
|
*/
|
2021-02-15 12:37:28 +00:00
|
|
|
#define v4l2_async_notifier_add_fwnode_remote_subdev(notifier, ep, type) \
|
|
|
|
((type *) \
|
|
|
|
__v4l2_async_notifier_add_fwnode_remote_subdev(notifier, ep, \
|
|
|
|
sizeof(type)))
|
2019-02-28 13:25:28 +00:00
|
|
|
|
2021-02-15 12:37:28 +00:00
|
|
|
struct v4l2_async_subdev *
|
|
|
|
__v4l2_async_notifier_add_i2c_subdev(struct v4l2_async_notifier *notifier,
|
|
|
|
int adapter_id, unsigned short address,
|
|
|
|
unsigned int asd_struct_size);
|
2018-09-29 19:54:07 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_notifier_add_i2c_subdev - Allocate and add an i2c async
|
|
|
|
* subdev to the notifier's master asd_list.
|
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
2021-02-15 12:37:28 +00:00
|
|
|
* @adapter: I2C adapter ID to be matched
|
2018-09-29 19:54:07 +00:00
|
|
|
* @address: I2C address of sub-device to be matched
|
2021-02-15 12:37:28 +00:00
|
|
|
* @type: Type of the driver's async sub-device struct. The &struct
|
|
|
|
* v4l2_async_subdev shall be the first member of the driver's async
|
|
|
|
* sub-device struct, i.e. both begin at the same memory address.
|
2018-09-29 19:54:07 +00:00
|
|
|
*
|
2021-02-15 12:37:28 +00:00
|
|
|
* Same as v4l2_async_notifier_add_fwnode_subdev() but for I2C matched
|
|
|
|
* sub-devices.
|
2018-09-29 19:54:07 +00:00
|
|
|
*/
|
2021-02-15 12:37:28 +00:00
|
|
|
#define v4l2_async_notifier_add_i2c_subdev(notifier, adapter, address, type) \
|
|
|
|
((type *)__v4l2_async_notifier_add_i2c_subdev(notifier, adapter, \
|
|
|
|
address, sizeof(type)))
|
2018-09-29 19:54:07 +00:00
|
|
|
|
2016-07-21 12:24:55 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_notifier_register - registers a subdevice asynchronous notifier
|
|
|
|
*
|
|
|
|
* @v4l2_dev: pointer to &struct v4l2_device
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
*/
|
2013-01-08 10:06:31 +00:00
|
|
|
int v4l2_async_notifier_register(struct v4l2_device *v4l2_dev,
|
|
|
|
struct v4l2_async_notifier *notifier);
|
2016-07-21 12:24:55 +00:00
|
|
|
|
2017-09-25 00:54:31 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_subdev_notifier_register - registers a subdevice asynchronous
|
|
|
|
* notifier for a sub-device
|
|
|
|
*
|
|
|
|
* @sd: pointer to &struct v4l2_subdev
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
*/
|
|
|
|
int v4l2_async_subdev_notifier_register(struct v4l2_subdev *sd,
|
|
|
|
struct v4l2_async_notifier *notifier);
|
|
|
|
|
2016-07-21 12:24:55 +00:00
|
|
|
/**
|
2018-10-04 21:10:46 +00:00
|
|
|
* v4l2_async_notifier_unregister - unregisters a subdevice
|
|
|
|
* asynchronous notifier
|
2016-07-21 12:24:55 +00:00
|
|
|
*
|
|
|
|
* @notifier: pointer to &struct v4l2_async_notifier
|
|
|
|
*/
|
2013-01-08 10:06:31 +00:00
|
|
|
void v4l2_async_notifier_unregister(struct v4l2_async_notifier *notifier);
|
2016-07-21 12:24:55 +00:00
|
|
|
|
2017-08-17 15:28:21 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_notifier_cleanup - clean up notifier resources
|
|
|
|
* @notifier: the notifier the resources of which are to be cleaned up
|
|
|
|
*
|
|
|
|
* Release memory resources related to a notifier, including the async
|
|
|
|
* sub-devices allocated for the purposes of the notifier but not the notifier
|
|
|
|
* itself. The user is responsible for calling this function to clean up the
|
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-29 19:54:06 +00:00
|
|
|
* notifier after calling
|
2021-01-18 01:52:55 +00:00
|
|
|
* @v4l2_async_notifier_add_fwnode_remote_subdev,
|
|
|
|
* @v4l2_async_notifier_add_fwnode_subdev,
|
|
|
|
* @v4l2_async_notifier_add_i2c_subdev,
|
|
|
|
* @__v4l2_async_notifier_add_subdev or
|
|
|
|
* @v4l2_async_notifier_parse_fwnode_endpoints.
|
2017-08-17 15:28:21 +00:00
|
|
|
*
|
|
|
|
* There is no harm from calling v4l2_async_notifier_cleanup in other
|
|
|
|
* cases as long as its memory has been zeroed after it has been
|
|
|
|
* allocated.
|
|
|
|
*/
|
|
|
|
void v4l2_async_notifier_cleanup(struct v4l2_async_notifier *notifier);
|
|
|
|
|
2016-07-21 12:24:55 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_register_subdev - registers a sub-device to the asynchronous
|
2018-01-04 11:47:28 +00:00
|
|
|
* subdevice framework
|
2016-07-21 12:24:55 +00:00
|
|
|
*
|
|
|
|
* @sd: pointer to &struct v4l2_subdev
|
|
|
|
*/
|
2013-01-08 10:06:31 +00:00
|
|
|
int v4l2_async_register_subdev(struct v4l2_subdev *sd);
|
2016-07-21 12:24:55 +00:00
|
|
|
|
2017-09-24 22:47:44 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_register_subdev_sensor_common - registers a sensor sub-device to
|
|
|
|
* the asynchronous sub-device
|
|
|
|
* framework and parse set up common
|
|
|
|
* sensor related devices
|
|
|
|
*
|
|
|
|
* @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
|
|
|
|
* using v4l2_async_notifier_parse_fwnode_sensor_common() and registers the
|
|
|
|
* 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-04 21:10:46 +00:00
|
|
|
int __must_check
|
|
|
|
v4l2_async_register_subdev_sensor_common(struct v4l2_subdev *sd);
|
2017-09-24 22:47:44 +00:00
|
|
|
|
2016-07-21 12:24:55 +00:00
|
|
|
/**
|
|
|
|
* v4l2_async_unregister_subdev - unregisters a sub-device to the asynchronous
|
2018-01-04 11:47:28 +00:00
|
|
|
* subdevice framework
|
2016-07-21 12:24:55 +00:00
|
|
|
*
|
|
|
|
* @sd: pointer to &struct v4l2_subdev
|
|
|
|
*/
|
2013-01-08 10:06:31 +00:00
|
|
|
void v4l2_async_unregister_subdev(struct v4l2_subdev *sd);
|
|
|
|
#endif
|