system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-11-05 18:23:50 +00:00
Code Issues Projects Releases Packages Wiki Activity

media: v4l2-core: cleanup coding style at V4L2 async/fwnode

Browse source 
There are several coding style issues at those definitions,
and the previous patchset added even more.

Address the trivial ones by first calling:

	./scripts/checkpatch.pl --strict --fix-inline include/media/v4l2-async.h include/media/v4l2-fwnode.h include/media/v4l2-mediabus.h drivers/media/v4l2-core/v4l2-async.c drivers/media/v4l2-core/v4l2-fwnode.c

and then manually adjusting the style where needed.

Acked-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
This commit is contained in:
Mauro Carvalho Chehab 2018-10-04 17:10:46 -04:00
parent cac0223c46
commit 6087b21533
5 changed files with 179 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
drivers/media/v4l2-core/v4l2-async.c
View file

@ -57,6 +57,7 @@ static bool match_i2c(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd)
{ {
#if IS_ENABLED(CONFIG_I2C) #if IS_ENABLED(CONFIG_I2C)
struct i2c_client *client = i2c_verify_client(sd->dev); struct i2c_client *client = i2c_verify_client(sd->dev);
return client && return client &&
asd->match.i2c.adapter_id == client->adapter->nr && asd->match.i2c.adapter_id == client->adapter->nr &&
asd->match.i2c.address == client->addr; asd->match.i2c.address == client->addr;
@ -89,10 +90,11 @@ static LIST_HEAD(subdev_list);
static LIST_HEAD(notifier_list); static LIST_HEAD(notifier_list);
static DEFINE_MUTEX(list_lock); static DEFINE_MUTEX(list_lock);
static struct v4l2_async_subdev *v4l2_async_find_match( static struct v4l2_async_subdev *
struct v4l2_async_notifier *notifier, struct v4l2_subdev *sd) v4l2_async_find_match(struct v4l2_async_notifier *notifier,
struct v4l2_subdev *sd)
{ {
bool (*match)(struct v4l2_subdev *, struct v4l2_async_subdev *); bool (*match)(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd);
struct v4l2_async_subdev *asd; struct v4l2_async_subdev *asd;
list_for_each_entry(asd, &notifier->waiting, list) { list_for_each_entry(asd, &notifier->waiting, list) {
@ -150,8 +152,8 @@ static bool asd_equal(struct v4l2_async_subdev *asd_x,
} }
/* Find the sub-device notifier registered by a sub-device driver. */ /* Find the sub-device notifier registered by a sub-device driver. */
static struct v4l2_async_notifier *v4l2_async_find_subdev_notifier( static struct v4l2_async_notifier *
struct v4l2_subdev *sd) v4l2_async_find_subdev_notifier(struct v4l2_subdev *sd)
{ {
struct v4l2_async_notifier *n; struct v4l2_async_notifier *n;
@ -163,8 +165,8 @@ static struct v4l2_async_notifier *v4l2_async_find_subdev_notifier(
} }
/* Get v4l2_device related to the notifier if one can be found. */ /* Get v4l2_device related to the notifier if one can be found. */
static struct v4l2_device *v4l2_async_notifier_find_v4l2_dev( static struct v4l2_device *
struct v4l2_async_notifier *notifier) v4l2_async_notifier_find_v4l2_dev(struct v4l2_async_notifier *notifier)
{ {
while (notifier->parent) while (notifier->parent)
notifier = notifier->parent; notifier = notifier->parent;
@ -175,8 +177,8 @@ static struct v4l2_device *v4l2_async_notifier_find_v4l2_dev(
/* /*
* Return true if all child sub-device notifiers are complete, false otherwise. * Return true if all child sub-device notifiers are complete, false otherwise.
*/ */
static bool v4l2_async_notifier_can_complete( static bool
struct v4l2_async_notifier *notifier) v4l2_async_notifier_can_complete(struct v4l2_async_notifier *notifier)
{ {
struct v4l2_subdev *sd; struct v4l2_subdev *sd;
@ -199,8 +201,8 @@ static bool v4l2_async_notifier_can_complete(
* Complete the master notifier if possible. This is done when all async * Complete the master notifier if possible. This is done when all async
* sub-devices have been bound; v4l2_device is also available then. * sub-devices have been bound; v4l2_device is also available then.
*/ */
static int v4l2_async_notifier_try_complete( static int
struct v4l2_async_notifier *notifier) v4l2_async_notifier_try_complete(struct v4l2_async_notifier *notifier)
{ {
/* Quick check whether there are still more sub-devices here. */ /* Quick check whether there are still more sub-devices here. */
if (!list_empty(&notifier->waiting)) if (!list_empty(&notifier->waiting))
@ -221,8 +223,8 @@ static int v4l2_async_notifier_try_complete(
return v4l2_async_notifier_call_complete(notifier); return v4l2_async_notifier_call_complete(notifier);
} }
static int v4l2_async_notifier_try_all_subdevs( static int
struct v4l2_async_notifier *notifier); v4l2_async_notifier_try_all_subdevs(struct v4l2_async_notifier *notifier);
static int v4l2_async_match_notify(struct v4l2_async_notifier *notifier, static int v4l2_async_match_notify(struct v4l2_async_notifier *notifier,
struct v4l2_device *v4l2_dev, struct v4l2_device *v4l2_dev,
@ -268,8 +270,8 @@ static int v4l2_async_match_notify(struct v4l2_async_notifier *notifier,
} }
/* Test all async sub-devices in a notifier for a match. */ /* Test all async sub-devices in a notifier for a match. */
static int v4l2_async_notifier_try_all_subdevs( static int
struct v4l2_async_notifier *notifier) v4l2_async_notifier_try_all_subdevs(struct v4l2_async_notifier *notifier)
{ {
struct v4l2_device *v4l2_dev = struct v4l2_device *v4l2_dev =
v4l2_async_notifier_find_v4l2_dev(notifier); v4l2_async_notifier_find_v4l2_dev(notifier);
@ -306,14 +308,17 @@ static int v4l2_async_notifier_try_all_subdevs(
static void v4l2_async_cleanup(struct v4l2_subdev *sd) static void v4l2_async_cleanup(struct v4l2_subdev *sd)
{ {
v4l2_device_unregister_subdev(sd); v4l2_device_unregister_subdev(sd);
/* Subdevice driver will reprobe and put the subdev back onto the list */ /*
* Subdevice driver will reprobe and put the subdev back
* onto the list
*/
list_del_init(&sd->async_list); list_del_init(&sd->async_list);
sd->asd = NULL; sd->asd = NULL;
} }
/* Unbind all sub-devices in the notifier tree. */ /* Unbind all sub-devices in the notifier tree. */
static void v4l2_async_notifier_unbind_all_subdevs( static void
struct v4l2_async_notifier *notifier) v4l2_async_notifier_unbind_all_subdevs(struct v4l2_async_notifier *notifier)
{ {
struct v4l2_subdev *sd, *tmp; struct v4l2_subdev *sd, *tmp;
@ -508,8 +513,8 @@ int v4l2_async_subdev_notifier_register(struct v4l2_subdev *sd,
} }
EXPORT_SYMBOL(v4l2_async_subdev_notifier_register); EXPORT_SYMBOL(v4l2_async_subdev_notifier_register);
static void __v4l2_async_notifier_unregister( static void
struct v4l2_async_notifier *notifier) __v4l2_async_notifier_unregister(struct v4l2_async_notifier *notifier)
{ {
if (!notifier || (!notifier->v4l2_dev && !notifier->sd)) if (!notifier || (!notifier->v4l2_dev && !notifier->sd))
return; return;

185
drivers/media/v4l2-core/v4l2-fwnode.c
View file

@ -211,7 +211,7 @@ static int v4l2_fwnode_endpoint_parse_csi2_bus(struct fwnode_handle *fwnode,
if (lanes_used & BIT(clock_lane)) { if (lanes_used & BIT(clock_lane)) {
if (have_clk_lane || !use_default_lane_mapping) if (have_clk_lane || !use_default_lane_mapping)
pr_warn("duplicated lane %u in clock-lanes, using defaults\n", pr_warn("duplicated lane %u in clock-lanes, using defaults\n",
v); v);
use_default_lane_mapping = true; use_default_lane_mapping = true;
} }
@ -265,9 +265,10 @@ static int v4l2_fwnode_endpoint_parse_csi2_bus(struct fwnode_handle *fwnode,
V4L2_MBUS_FIELD_EVEN_HIGH | \ V4L2_MBUS_FIELD_EVEN_HIGH | \
V4L2_MBUS_FIELD_EVEN_LOW) V4L2_MBUS_FIELD_EVEN_LOW)
static void v4l2_fwnode_endpoint_parse_parallel_bus( static void
struct fwnode_handle *fwnode, struct v4l2_fwnode_endpoint *vep, v4l2_fwnode_endpoint_parse_parallel_bus(struct fwnode_handle *fwnode,
enum v4l2_mbus_type bus_type) struct v4l2_fwnode_endpoint *vep,
enum v4l2_mbus_type bus_type)
{ {
struct v4l2_fwnode_bus_parallel *bus = &vep->bus.parallel; struct v4l2_fwnode_bus_parallel *bus = &vep->bus.parallel;
unsigned int flags = 0; unsigned int flags = 0;
@ -436,8 +437,7 @@ static int __v4l2_fwnode_endpoint_parse(struct fwnode_handle *fwnode,
if (mbus_type != V4L2_MBUS_UNKNOWN && if (mbus_type != V4L2_MBUS_UNKNOWN &&
vep->bus_type != mbus_type) { vep->bus_type != mbus_type) {
pr_debug("expecting bus type %s\n", pr_debug("expecting bus type %s\n",
v4l2_fwnode_mbus_type_to_string( v4l2_fwnode_mbus_type_to_string(vep->bus_type));
vep->bus_type));
return -ENXIO; return -ENXIO;
} }
} else { } else {
@ -452,8 +452,8 @@ static int __v4l2_fwnode_endpoint_parse(struct fwnode_handle *fwnode,
return rval; return rval;
if (vep->bus_type == V4L2_MBUS_UNKNOWN) if (vep->bus_type == V4L2_MBUS_UNKNOWN)
v4l2_fwnode_endpoint_parse_parallel_bus( v4l2_fwnode_endpoint_parse_parallel_bus(fwnode, vep,
fwnode, vep, V4L2_MBUS_UNKNOWN); V4L2_MBUS_UNKNOWN);
pr_debug("assuming media bus type %s (%u)\n", pr_debug("assuming media bus type %s (%u)\n",
v4l2_fwnode_mbus_type_to_string(vep->bus_type), v4l2_fwnode_mbus_type_to_string(vep->bus_type),
@ -511,8 +511,8 @@ void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep)
} }
EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_free); EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_free);
int v4l2_fwnode_endpoint_alloc_parse( int v4l2_fwnode_endpoint_alloc_parse(struct fwnode_handle *fwnode,
struct fwnode_handle *fwnode, struct v4l2_fwnode_endpoint *vep) struct v4l2_fwnode_endpoint *vep)
{ {
int rval; int rval;
@ -533,9 +533,10 @@ int v4l2_fwnode_endpoint_alloc_parse(
vep->nr_of_link_frequencies = rval; vep->nr_of_link_frequencies = rval;
rval = fwnode_property_read_u64_array( rval = fwnode_property_read_u64_array(fwnode,
fwnode, "link-frequencies", vep->link_frequencies, "link-frequencies",
vep->nr_of_link_frequencies); vep->link_frequencies,
vep->nr_of_link_frequencies);
if (rval < 0) { if (rval < 0) {
v4l2_fwnode_endpoint_free(vep); v4l2_fwnode_endpoint_free(vep);
return rval; return rval;
@ -593,12 +594,14 @@ void v4l2_fwnode_put_link(struct v4l2_fwnode_link *link)
} }
EXPORT_SYMBOL_GPL(v4l2_fwnode_put_link); EXPORT_SYMBOL_GPL(v4l2_fwnode_put_link);
static int v4l2_async_notifier_fwnode_parse_endpoint( static int
struct device *dev, struct v4l2_async_notifier *notifier, v4l2_async_notifier_fwnode_parse_endpoint(struct device *dev,
struct fwnode_handle *endpoint, unsigned int asd_struct_size, struct v4l2_async_notifier *notifier,
int (*parse_endpoint)(struct device *dev, struct fwnode_handle *endpoint,
struct v4l2_fwnode_endpoint *vep, unsigned int asd_struct_size,
struct v4l2_async_subdev *asd)) int (*parse_endpoint)(struct device *dev,
struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd))
{ {
struct v4l2_fwnode_endpoint vep = { .bus_type = 0 }; struct v4l2_fwnode_endpoint vep = { .bus_type = 0 };
struct v4l2_async_subdev *asd; struct v4l2_async_subdev *asd;
@ -653,12 +656,14 @@ static int v4l2_async_notifier_fwnode_parse_endpoint(
return ret == -ENOTCONN ? 0 : ret; return ret == -ENOTCONN ? 0 : ret;
} }
static int __v4l2_async_notifier_parse_fwnode_endpoints( static int
struct device *dev, struct v4l2_async_notifier *notifier, __v4l2_async_notifier_parse_fwnode_endpoints(struct device *dev,
size_t asd_struct_size, unsigned int port, bool has_port, struct v4l2_async_notifier *notifier,
int (*parse_endpoint)(struct device *dev, size_t asd_struct_size,
struct v4l2_fwnode_endpoint *vep, unsigned int port, bool has_port,
struct v4l2_async_subdev *asd)) int (*parse_endpoint)(struct device *dev,
struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd))
{ {
struct fwnode_handle *fwnode; struct fwnode_handle *fwnode;
int ret = 0; int ret = 0;
@ -687,8 +692,11 @@ static int __v4l2_async_notifier_parse_fwnode_endpoints(
continue; continue;
} }
ret = v4l2_async_notifier_fwnode_parse_endpoint( ret = v4l2_async_notifier_fwnode_parse_endpoint(dev,
dev, notifier, fwnode, asd_struct_size, parse_endpoint); notifier,
fwnode,
asd_struct_size,
parse_endpoint);
if (ret < 0) if (ret < 0)
break; break;
} }
@ -698,27 +706,33 @@ static int __v4l2_async_notifier_parse_fwnode_endpoints(
return ret; return ret;
} }
int v4l2_async_notifier_parse_fwnode_endpoints( int
struct device *dev, struct v4l2_async_notifier *notifier, v4l2_async_notifier_parse_fwnode_endpoints(struct device *dev,
size_t asd_struct_size, struct v4l2_async_notifier *notifier,
int (*parse_endpoint)(struct device *dev, size_t asd_struct_size,
struct v4l2_fwnode_endpoint *vep, int (*parse_endpoint)(struct device *dev,
struct v4l2_async_subdev *asd)) struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd))
{ {
return __v4l2_async_notifier_parse_fwnode_endpoints( return __v4l2_async_notifier_parse_fwnode_endpoints(dev, notifier,
dev, notifier, asd_struct_size, 0, false, parse_endpoint); asd_struct_size, 0,
false,
parse_endpoint);
} }
EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints); EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints);
int v4l2_async_notifier_parse_fwnode_endpoints_by_port( int
struct device *dev, struct v4l2_async_notifier *notifier, v4l2_async_notifier_parse_fwnode_endpoints_by_port(struct device *dev,
size_t asd_struct_size, unsigned int port, struct v4l2_async_notifier *notifier,
int (*parse_endpoint)(struct device *dev, size_t asd_struct_size, unsigned int port,
struct v4l2_fwnode_endpoint *vep, int (*parse_endpoint)(struct device *dev,
struct v4l2_async_subdev *asd)) struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd))
{ {
return __v4l2_async_notifier_parse_fwnode_endpoints( return __v4l2_async_notifier_parse_fwnode_endpoints(dev, notifier,
dev, notifier, asd_struct_size, port, true, parse_endpoint); asd_struct_size,
port, true,
parse_endpoint);
} }
EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints_by_port); EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints_by_port);
@ -733,17 +747,18 @@ EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints_by_port);
* -ENOMEM if memory allocation failed * -ENOMEM if memory allocation failed
* -EINVAL if property parsing failed * -EINVAL if property parsing failed
*/ */
static int v4l2_fwnode_reference_parse( static int v4l2_fwnode_reference_parse(struct device *dev,
struct device *dev, struct v4l2_async_notifier *notifier, struct v4l2_async_notifier *notifier,
const char *prop) const char *prop)
{ {
struct fwnode_reference_args args; struct fwnode_reference_args args;
unsigned int index; unsigned int index;
int ret; int ret;
for (index = 0; for (index = 0;
!(ret = fwnode_property_get_reference_args( !(ret = fwnode_property_get_reference_args(dev_fwnode(dev),
dev_fwnode(dev), prop, NULL, 0, index, &args)); prop, NULL, 0,
index, &args));
index++) index++)
fwnode_handle_put(args.fwnode); fwnode_handle_put(args.fwnode);
@ -757,13 +772,15 @@ static int v4l2_fwnode_reference_parse(
if (ret != -ENOENT && ret != -ENODATA) if (ret != -ENOENT && ret != -ENODATA)
return ret; return ret;
for (index = 0; !fwnode_property_get_reference_args( for (index = 0;
dev_fwnode(dev), prop, NULL, 0, index, &args); !fwnode_property_get_reference_args(dev_fwnode(dev), prop, NULL,
0, index, &args);
index++) { index++) {
struct v4l2_async_subdev *asd; struct v4l2_async_subdev *asd;
asd = v4l2_async_notifier_add_fwnode_subdev( asd = v4l2_async_notifier_add_fwnode_subdev(notifier,
notifier, args.fwnode, sizeof(*asd)); args.fwnode,
sizeof(*asd));
if (IS_ERR(asd)) { if (IS_ERR(asd)) {
ret = PTR_ERR(asd); ret = PTR_ERR(asd);
/* not an error if asd already exists */ /* not an error if asd already exists */
@ -939,9 +956,12 @@ static int v4l2_fwnode_reference_parse(
* -EINVAL if property parsing otherwise failed * -EINVAL if property parsing otherwise failed
* -ENOMEM if memory allocation failed * -ENOMEM if memory allocation failed
*/ */
static struct fwnode_handle *v4l2_fwnode_reference_get_int_prop( static struct fwnode_handle *
struct fwnode_handle *fwnode, const char *prop, unsigned int index, v4l2_fwnode_reference_get_int_prop(struct fwnode_handle *fwnode,
const char * const *props, unsigned int nprops) const char *prop,
unsigned int index,
const char * const *props,
unsigned int nprops)
{ {
struct fwnode_reference_args fwnode_args; struct fwnode_reference_args fwnode_args;
u64 *args = fwnode_args.args; u64 *args = fwnode_args.args;
@ -1016,9 +1036,12 @@ static struct fwnode_handle *v4l2_fwnode_reference_get_int_prop(
* -EINVAL if property parsing otherwisefailed * -EINVAL if property parsing otherwisefailed
* -ENOMEM if memory allocation failed * -ENOMEM if memory allocation failed
*/ */
static int v4l2_fwnode_reference_parse_int_props( static int
struct device *dev, struct v4l2_async_notifier *notifier, v4l2_fwnode_reference_parse_int_props(struct device *dev,
const char *prop, const char * const *props, unsigned int nprops) struct v4l2_async_notifier *notifier,
const char *prop,
const char * const *props,
unsigned int nprops)
{ {
struct fwnode_handle *fwnode; struct fwnode_handle *fwnode;
unsigned int index; unsigned int index;
@ -1044,9 +1067,12 @@ static int v4l2_fwnode_reference_parse_int_props(
index++; index++;
} while (1); } while (1);
for (index = 0; !IS_ERR((fwnode = v4l2_fwnode_reference_get_int_prop( for (index = 0;
dev_fwnode(dev), prop, index, props, !IS_ERR((fwnode = v4l2_fwnode_reference_get_int_prop(dev_fwnode(dev),
nprops))); index++) { prop, index,
props,
nprops)));
index++) {
struct v4l2_async_subdev *asd; struct v4l2_async_subdev *asd;
asd = v4l2_async_notifier_add_fwnode_subdev(notifier, fwnode, asd = v4l2_async_notifier_add_fwnode_subdev(notifier, fwnode,
@ -1070,8 +1096,8 @@ static int v4l2_fwnode_reference_parse_int_props(
return ret; return ret;
} }
int v4l2_async_notifier_parse_fwnode_sensor_common( int v4l2_async_notifier_parse_fwnode_sensor_common(struct device *dev,
struct device *dev, struct v4l2_async_notifier *notifier) struct v4l2_async_notifier *notifier)
{ {
static const char * const led_props[] = { "led" }; static const char * const led_props[] = { "led" };
static const struct { static const struct {
@ -1088,12 +1114,14 @@ int v4l2_async_notifier_parse_fwnode_sensor_common(
int ret; int ret;
if (props[i].props && is_acpi_node(dev_fwnode(dev))) if (props[i].props && is_acpi_node(dev_fwnode(dev)))
ret = v4l2_fwnode_reference_parse_int_props( ret = v4l2_fwnode_reference_parse_int_props(dev,
dev, notifier, props[i].name, notifier,
props[i].props, props[i].nprops); props[i].name,
props[i].props,
props[i].nprops);
else else
ret = v4l2_fwnode_reference_parse( ret = v4l2_fwnode_reference_parse(dev, notifier,
dev, notifier, props[i].name); props[i].name);
if (ret && ret != -ENOENT) { if (ret && ret != -ENOENT) {
dev_warn(dev, "parsing property \"%s\" failed (%d)\n", dev_warn(dev, "parsing property \"%s\" failed (%d)\n",
props[i].name, ret); props[i].name, ret);
@ -1147,12 +1175,12 @@ int v4l2_async_register_subdev_sensor_common(struct v4l2_subdev *sd)
} }
EXPORT_SYMBOL_GPL(v4l2_async_register_subdev_sensor_common); EXPORT_SYMBOL_GPL(v4l2_async_register_subdev_sensor_common);
int v4l2_async_register_fwnode_subdev( int v4l2_async_register_fwnode_subdev(struct v4l2_subdev *sd,
struct v4l2_subdev *sd, size_t asd_struct_size, size_t asd_struct_size,
unsigned int *ports, unsigned int num_ports, unsigned int *ports, unsigned int num_ports,
int (*parse_endpoint)(struct device *dev, int (*parse_endpoint)(struct device *dev,
struct v4l2_fwnode_endpoint *vep, struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd)) struct v4l2_async_subdev *asd))
{ {
struct v4l2_async_notifier *notifier; struct v4l2_async_notifier *notifier;
struct device *dev = sd->dev; struct device *dev = sd->dev;
@ -1173,17 +1201,16 @@ int v4l2_async_register_fwnode_subdev(
v4l2_async_notifier_init(notifier); v4l2_async_notifier_init(notifier);
if (!ports) { if (!ports) {
ret = v4l2_async_notifier_parse_fwnode_endpoints( ret = v4l2_async_notifier_parse_fwnode_endpoints(dev, notifier,
dev, notifier, asd_struct_size, parse_endpoint); asd_struct_size,
parse_endpoint);
if (ret < 0) if (ret < 0)
goto out_cleanup; goto out_cleanup;
} else { } else {
unsigned int i; unsigned int i;
for (i = 0; i < num_ports; i++) { for (i = 0; i < num_ports; i++) {
ret = v4l2_async_notifier_parse_fwnode_endpoints_by_port( ret = v4l2_async_notifier_parse_fwnode_endpoints_by_port(dev, notifier, asd_struct_size, ports[i], parse_endpoint);
dev, notifier, asd_struct_size,
ports[i], parse_endpoint);
if (ret < 0) if (ret < 0)
goto out_cleanup; goto out_cleanup;
} }

12
include/media/v4l2-async.h
View file

@ -89,8 +89,8 @@ struct v4l2_async_subdev {
unsigned short address; unsigned short address;
} i2c; } i2c;
struct { struct {
bool (*match)(struct device *, bool (*match)(struct device *dev,
struct v4l2_async_subdev *); struct v4l2_async_subdev *sd);
void *priv; void *priv;
} custom; } custom;
} match; } match;
@ -222,7 +222,6 @@ v4l2_async_notifier_add_devname_subdev(struct v4l2_async_notifier *notifier,
const char *device_name, const char *device_name,
unsigned int asd_struct_size); unsigned int asd_struct_size);
/** /**
* v4l2_async_notifier_register - registers a subdevice asynchronous notifier * v4l2_async_notifier_register - registers a subdevice asynchronous notifier
* *
@ -243,7 +242,8 @@ int v4l2_async_subdev_notifier_register(struct v4l2_subdev *sd,
struct v4l2_async_notifier *notifier); struct v4l2_async_notifier *notifier);
/** /**
* v4l2_async_notifier_unregister - unregisters a subdevice asynchronous notifier * v4l2_async_notifier_unregister - unregisters a subdevice
* asynchronous notifier
* *
* @notifier: pointer to &struct v4l2_async_notifier * @notifier: pointer to &struct v4l2_async_notifier
*/ */
@ -294,8 +294,8 @@ int v4l2_async_register_subdev(struct v4l2_subdev *sd);
* An error is returned if the module is no longer loaded on any attempts * An error is returned if the module is no longer loaded on any attempts
* to register it. * to register it.
*/ */
int __must_check v4l2_async_register_subdev_sensor_common( int __must_check
struct v4l2_subdev *sd); v4l2_async_register_subdev_sensor_common(struct v4l2_subdev *sd);
/** /**
* v4l2_async_unregister_subdev - unregisters a sub-device to the asynchronous * v4l2_async_unregister_subdev - unregisters a sub-device to the asynchronous

46
include/media/v4l2-fwnode.h
View file

@ -71,8 +71,8 @@ struct v4l2_fwnode_bus_parallel {
* @clock_lane: the number of the clock lane * @clock_lane: the number of the clock lane
*/ */
struct v4l2_fwnode_bus_mipi_csi1 { struct v4l2_fwnode_bus_mipi_csi1 {
bool clock_inv; unsigned char clock_inv:1;
bool strobe; unsigned char strobe:1;
bool lane_polarity[2]; bool lane_polarity[2];
unsigned char data_lane; unsigned char data_lane;
unsigned char clock_lane; unsigned char clock_lane;
@ -203,8 +203,8 @@ void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep);
* %-EINVAL on parsing failure * %-EINVAL on parsing failure
* %-ENXIO on mismatching bus types * %-ENXIO on mismatching bus types
*/ */
int v4l2_fwnode_endpoint_alloc_parse( int v4l2_fwnode_endpoint_alloc_parse(struct fwnode_handle *fwnode,
struct fwnode_handle *fwnode, struct v4l2_fwnode_endpoint *vep); struct v4l2_fwnode_endpoint *vep);
/** /**
* v4l2_fwnode_parse_link() - parse a link between two endpoints * v4l2_fwnode_parse_link() - parse a link between two endpoints
@ -236,7 +236,6 @@ int v4l2_fwnode_parse_link(struct fwnode_handle *fwnode,
*/ */
void v4l2_fwnode_put_link(struct v4l2_fwnode_link *link); void v4l2_fwnode_put_link(struct v4l2_fwnode_link *link);
/** /**
* typedef parse_endpoint_func - Driver's callback function to be called on * typedef parse_endpoint_func - Driver's callback function to be called on
* each V4L2 fwnode endpoint. * each V4L2 fwnode endpoint.
@ -255,7 +254,6 @@ typedef int (*parse_endpoint_func)(struct device *dev,
struct v4l2_fwnode_endpoint *vep, struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd); struct v4l2_async_subdev *asd);
/** /**
* v4l2_async_notifier_parse_fwnode_endpoints - Parse V4L2 fwnode endpoints in a * v4l2_async_notifier_parse_fwnode_endpoints - Parse V4L2 fwnode endpoints in a
* device node * device node
@ -294,10 +292,11 @@ typedef int (*parse_endpoint_func)(struct device *dev,
* %-EINVAL if graph or endpoint parsing failed * %-EINVAL if graph or endpoint parsing failed
* Other error codes as returned by @parse_endpoint * Other error codes as returned by @parse_endpoint
*/ */
int v4l2_async_notifier_parse_fwnode_endpoints( int
struct device *dev, struct v4l2_async_notifier *notifier, v4l2_async_notifier_parse_fwnode_endpoints(struct device *dev,
size_t asd_struct_size, struct v4l2_async_notifier *notifier,
parse_endpoint_func parse_endpoint); size_t asd_struct_size,
parse_endpoint_func parse_endpoint);
/** /**
* v4l2_async_notifier_parse_fwnode_endpoints_by_port - Parse V4L2 fwnode * v4l2_async_notifier_parse_fwnode_endpoints_by_port - Parse V4L2 fwnode
@ -345,10 +344,11 @@ int v4l2_async_notifier_parse_fwnode_endpoints(
* %-EINVAL if graph or endpoint parsing failed * %-EINVAL if graph or endpoint parsing failed
* Other error codes as returned by @parse_endpoint * Other error codes as returned by @parse_endpoint
*/ */
int v4l2_async_notifier_parse_fwnode_endpoints_by_port( int
struct device *dev, struct v4l2_async_notifier *notifier, v4l2_async_notifier_parse_fwnode_endpoints_by_port(struct device *dev,
size_t asd_struct_size, unsigned int port, struct v4l2_async_notifier *notifier,
parse_endpoint_func parse_endpoint); size_t asd_struct_size, unsigned int port,
parse_endpoint_func parse_endpoint);
/** /**
* v4l2_fwnode_reference_parse_sensor_common - parse common references on * v4l2_fwnode_reference_parse_sensor_common - parse common references on
@ -368,8 +368,8 @@ int v4l2_async_notifier_parse_fwnode_endpoints_by_port(
* -ENOMEM if memory allocation failed * -ENOMEM if memory allocation failed
* -EINVAL if property parsing failed * -EINVAL if property parsing failed
*/ */
int v4l2_async_notifier_parse_fwnode_sensor_common( int v4l2_async_notifier_parse_fwnode_sensor_common(struct device *dev,
struct device *dev, struct v4l2_async_notifier *notifier); struct v4l2_async_notifier *notifier);
/** /**
* v4l2_async_register_fwnode_subdev - registers a sub-device to the * v4l2_async_register_fwnode_subdev - registers a sub-device to the
@ -401,11 +401,13 @@ int v4l2_async_notifier_parse_fwnode_sensor_common(
* An error is returned if the module is no longer loaded on any attempts * An error is returned if the module is no longer loaded on any attempts
* to register it. * to register it.
*/ */
int v4l2_async_register_fwnode_subdev( int
struct v4l2_subdev *sd, size_t asd_struct_size, v4l2_async_register_fwnode_subdev(struct v4l2_subdev *sd,
unsigned int *ports, unsigned int num_ports, size_t asd_struct_size,
int (*parse_endpoint)(struct device *dev, unsigned int *ports,
struct v4l2_fwnode_endpoint *vep, unsigned int num_ports,
struct v4l2_async_subdev *asd)); int (*parse_endpoint)(struct device *dev,
struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd));
#endif /* _V4L2_FWNODE_H */ #endif /* _V4L2_FWNODE_H */

32
include/media/v4l2-mediabus.h
View file

@ -14,7 +14,6 @@
#include <linux/v4l2-mediabus.h> #include <linux/v4l2-mediabus.h>
#include <linux/bitops.h> #include <linux/bitops.h>
/* Parallel flags */ /* Parallel flags */
/* /*
* Can the client run in master or in slave mode. By "Master mode" an operation * Can the client run in master or in slave mode. By "Master mode" an operation
@ -63,10 +62,14 @@
#define V4L2_MBUS_CSI2_CONTINUOUS_CLOCK BIT(8) #define V4L2_MBUS_CSI2_CONTINUOUS_CLOCK BIT(8)
#define V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK BIT(9) #define V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK BIT(9)
#define V4L2_MBUS_CSI2_LANES (V4L2_MBUS_CSI2_1_LANE | V4L2_MBUS_CSI2_2_LANE | \ #define V4L2_MBUS_CSI2_LANES (V4L2_MBUS_CSI2_1_LANE | \
V4L2_MBUS_CSI2_3_LANE | V4L2_MBUS_CSI2_4_LANE) V4L2_MBUS_CSI2_2_LANE | \
#define V4L2_MBUS_CSI2_CHANNELS (V4L2_MBUS_CSI2_CHANNEL_0 | V4L2_MBUS_CSI2_CHANNEL_1 | \ V4L2_MBUS_CSI2_3_LANE | \
V4L2_MBUS_CSI2_CHANNEL_2 | V4L2_MBUS_CSI2_CHANNEL_3) V4L2_MBUS_CSI2_4_LANE)
#define V4L2_MBUS_CSI2_CHANNELS (V4L2_MBUS_CSI2_CHANNEL_0 | \
V4L2_MBUS_CSI2_CHANNEL_1 | \
V4L2_MBUS_CSI2_CHANNEL_2 | \
V4L2_MBUS_CSI2_CHANNEL_3)
/** /**
* enum v4l2_mbus_type - media bus type * enum v4l2_mbus_type - media bus type
@ -106,8 +109,9 @@ struct v4l2_mbus_config {
* @pix_fmt: pointer to &struct v4l2_pix_format to be filled * @pix_fmt: pointer to &struct v4l2_pix_format to be filled
* @mbus_fmt: pointer to &struct v4l2_mbus_framefmt to be used as model * @mbus_fmt: pointer to &struct v4l2_mbus_framefmt to be used as model
*/ */
static inline void v4l2_fill_pix_format(struct v4l2_pix_format *pix_fmt, static inline void
const struct v4l2_mbus_framefmt *mbus_fmt) v4l2_fill_pix_format(struct v4l2_pix_format *pix_fmt,
const struct v4l2_mbus_framefmt *mbus_fmt)
{ {
pix_fmt->width = mbus_fmt->width; pix_fmt->width = mbus_fmt->width;
pix_fmt->height = mbus_fmt->height; pix_fmt->height = mbus_fmt->height;
@ -128,7 +132,7 @@ static inline void v4l2_fill_pix_format(struct v4l2_pix_format *pix_fmt,
* @code: data format code (from &enum v4l2_mbus_pixelcode) * @code: data format code (from &enum v4l2_mbus_pixelcode)
*/ */
static inline void v4l2_fill_mbus_format(struct v4l2_mbus_framefmt *mbus_fmt, static inline void v4l2_fill_mbus_format(struct v4l2_mbus_framefmt *mbus_fmt,
const struct v4l2_pix_format *pix_fmt, const struct v4l2_pix_format *pix_fmt,
u32 code) u32 code)
{ {
mbus_fmt->width = pix_fmt->width; mbus_fmt->width = pix_fmt->width;
@ -148,9 +152,9 @@ static inline void v4l2_fill_mbus_format(struct v4l2_mbus_framefmt *mbus_fmt,
* @pix_mp_fmt: pointer to &struct v4l2_pix_format_mplane to be filled * @pix_mp_fmt: pointer to &struct v4l2_pix_format_mplane to be filled
* @mbus_fmt: pointer to &struct v4l2_mbus_framefmt to be used as model * @mbus_fmt: pointer to &struct v4l2_mbus_framefmt to be used as model
*/ */
static inline void v4l2_fill_pix_format_mplane( static inline void
struct v4l2_pix_format_mplane *pix_mp_fmt, v4l2_fill_pix_format_mplane(struct v4l2_pix_format_mplane *pix_mp_fmt,
const struct v4l2_mbus_framefmt *mbus_fmt) const struct v4l2_mbus_framefmt *mbus_fmt)
{ {
pix_mp_fmt->width = mbus_fmt->width; pix_mp_fmt->width = mbus_fmt->width;
pix_mp_fmt->height = mbus_fmt->height; pix_mp_fmt->height = mbus_fmt->height;
@ -168,9 +172,9 @@ static inline void v4l2_fill_pix_format_mplane(
* @mbus_fmt: pointer to &struct v4l2_mbus_framefmt to be filled * @mbus_fmt: pointer to &struct v4l2_mbus_framefmt to be filled
* @pix_mp_fmt: pointer to &struct v4l2_pix_format_mplane to be used as model * @pix_mp_fmt: pointer to &struct v4l2_pix_format_mplane to be used as model
*/ */
static inline void v4l2_fill_mbus_format_mplane( static inline void
struct v4l2_mbus_framefmt *mbus_fmt, v4l2_fill_mbus_format_mplane(struct v4l2_mbus_framefmt *mbus_fmt,
const struct v4l2_pix_format_mplane *pix_mp_fmt) const struct v4l2_pix_format_mplane *pix_mp_fmt)
{ {
mbus_fmt->width = pix_mp_fmt->width; mbus_fmt->width = pix_mp_fmt->width;
mbus_fmt->height = pix_mp_fmt->height; mbus_fmt->height = pix_mp_fmt->height;