Commit d079f94c authored by Steve Longerbeam's avatar Steve Longerbeam Committed by Mauro Carvalho Chehab

media: platform: Switch to v4l2_async_notifier_add_subdev

Switch all media platform drivers to call v4l2_async_notifier_add_subdev()
to add asd's to a notifier, in place of referencing the notifier->subdevs[]
array. These drivers also must now call v4l2_async_notifier_init() before
adding asd's to their notifiers.

There may still be cases where a platform driver maintains a list of
asd's that is a duplicate of the notifier asd_list, in which case its
possible the platform driver list can be removed, and can reference the
notifier asd_list instead. One example of where a duplicate list has
been removed in this patch is xilinx-vipp.c. If there are such cases
remaining, those drivers should be optimized to remove the duplicate
platform driver asd lists.

None of the changes to the platform drivers in this patch have been
tested. Verify that the async subdevices needed by the platform are
bound at load time, and that the driver unloads and reloads correctly
with no memory leaking of asd objects.
Suggested-by: default avatarSakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: default avatarSteve Longerbeam <slongerbeam@gmail.com>
Signed-off-by: default avatarSakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab+samsung@kernel.org>
parent d5099f81
...@@ -1506,7 +1506,7 @@ static int cio2_notifier_init(struct cio2_device *cio2) ...@@ -1506,7 +1506,7 @@ static int cio2_notifier_init(struct cio2_device *cio2)
if (ret < 0) if (ret < 0)
return ret; return ret;
if (!cio2->notifier.num_subdevs) if (list_empty(&cio2->notifier.asd_list))
return -ENODEV; /* no endpoint */ return -ENODEV; /* no endpoint */
cio2->notifier.ops = &cio2_async_ops; cio2->notifier.ops = &cio2_async_ops;
......
...@@ -2423,30 +2423,32 @@ static const struct v4l2_async_notifier_operations vpfe_async_ops = { ...@@ -2423,30 +2423,32 @@ static const struct v4l2_async_notifier_operations vpfe_async_ops = {
}; };
static struct vpfe_config * static struct vpfe_config *
vpfe_get_pdata(struct platform_device *pdev) vpfe_get_pdata(struct vpfe_device *vpfe)
{ {
struct device_node *endpoint = NULL; struct device_node *endpoint = NULL;
struct v4l2_fwnode_endpoint bus_cfg; struct v4l2_fwnode_endpoint bus_cfg;
struct device *dev = vpfe->pdev;
struct vpfe_subdev_info *sdinfo; struct vpfe_subdev_info *sdinfo;
struct vpfe_config *pdata; struct vpfe_config *pdata;
unsigned int flags; unsigned int flags;
unsigned int i; unsigned int i;
int err; int err;
dev_dbg(&pdev->dev, "vpfe_get_pdata\n"); dev_dbg(dev, "vpfe_get_pdata\n");
if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node) v4l2_async_notifier_init(&vpfe->notifier);
return pdev->dev.platform_data;
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!IS_ENABLED(CONFIG_OF) || !dev->of_node)
return dev->platform_data;
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata) if (!pdata)
return NULL; return NULL;
for (i = 0; ; i++) { for (i = 0; ; i++) {
struct device_node *rem; struct device_node *rem;
endpoint = of_graph_get_next_endpoint(pdev->dev.of_node, endpoint = of_graph_get_next_endpoint(dev->of_node, endpoint);
endpoint);
if (!endpoint) if (!endpoint)
break; break;
...@@ -2474,16 +2476,16 @@ vpfe_get_pdata(struct platform_device *pdev) ...@@ -2474,16 +2476,16 @@ vpfe_get_pdata(struct platform_device *pdev)
err = v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint), err = v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint),
&bus_cfg); &bus_cfg);
if (err) { if (err) {
dev_err(&pdev->dev, "Could not parse the endpoint\n"); dev_err(dev, "Could not parse the endpoint\n");
goto done; goto cleanup;
} }
sdinfo->vpfe_param.bus_width = bus_cfg.bus.parallel.bus_width; sdinfo->vpfe_param.bus_width = bus_cfg.bus.parallel.bus_width;
if (sdinfo->vpfe_param.bus_width < 8 || if (sdinfo->vpfe_param.bus_width < 8 ||
sdinfo->vpfe_param.bus_width > 16) { sdinfo->vpfe_param.bus_width > 16) {
dev_err(&pdev->dev, "Invalid bus width.\n"); dev_err(dev, "Invalid bus width.\n");
goto done; goto cleanup;
} }
flags = bus_cfg.bus.parallel.flags; flags = bus_cfg.bus.parallel.flags;
...@@ -2496,29 +2498,25 @@ vpfe_get_pdata(struct platform_device *pdev) ...@@ -2496,29 +2498,25 @@ vpfe_get_pdata(struct platform_device *pdev)
rem = of_graph_get_remote_port_parent(endpoint); rem = of_graph_get_remote_port_parent(endpoint);
if (!rem) { if (!rem) {
dev_err(&pdev->dev, "Remote device at %pOF not found\n", dev_err(dev, "Remote device at %pOF not found\n",
endpoint); endpoint);
goto done; goto cleanup;
} }
pdata->asd[i] = devm_kzalloc(&pdev->dev, pdata->asd[i] = v4l2_async_notifier_add_fwnode_subdev(
sizeof(struct v4l2_async_subdev), &vpfe->notifier, of_fwnode_handle(rem),
GFP_KERNEL); sizeof(struct v4l2_async_subdev));
if (!pdata->asd[i]) { if (IS_ERR(pdata->asd[i])) {
of_node_put(rem); of_node_put(rem);
pdata = NULL; goto cleanup;
goto done;
} }
pdata->asd[i]->match_type = V4L2_ASYNC_MATCH_FWNODE;
pdata->asd[i]->match.fwnode = of_fwnode_handle(rem);
of_node_put(rem);
} }
of_node_put(endpoint); of_node_put(endpoint);
return pdata; return pdata;
done: cleanup:
v4l2_async_notifier_cleanup(&vpfe->notifier);
of_node_put(endpoint); of_node_put(endpoint);
return NULL; return NULL;
} }
...@@ -2530,34 +2528,39 @@ vpfe_get_pdata(struct platform_device *pdev) ...@@ -2530,34 +2528,39 @@ vpfe_get_pdata(struct platform_device *pdev)
*/ */
static int vpfe_probe(struct platform_device *pdev) static int vpfe_probe(struct platform_device *pdev)
{ {
struct vpfe_config *vpfe_cfg = vpfe_get_pdata(pdev); struct vpfe_config *vpfe_cfg;
struct vpfe_device *vpfe; struct vpfe_device *vpfe;
struct vpfe_ccdc *ccdc; struct vpfe_ccdc *ccdc;
struct resource *res; struct resource *res;
int ret; int ret;
if (!vpfe_cfg) {
dev_err(&pdev->dev, "No platform data\n");
return -EINVAL;
}
vpfe = devm_kzalloc(&pdev->dev, sizeof(*vpfe), GFP_KERNEL); vpfe = devm_kzalloc(&pdev->dev, sizeof(*vpfe), GFP_KERNEL);
if (!vpfe) if (!vpfe)
return -ENOMEM; return -ENOMEM;
vpfe->pdev = &pdev->dev; vpfe->pdev = &pdev->dev;
vpfe_cfg = vpfe_get_pdata(vpfe);
if (!vpfe_cfg) {
dev_err(&pdev->dev, "No platform data\n");
return -EINVAL;
}
vpfe->cfg = vpfe_cfg; vpfe->cfg = vpfe_cfg;
ccdc = &vpfe->ccdc; ccdc = &vpfe->ccdc;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0); res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
ccdc->ccdc_cfg.base_addr = devm_ioremap_resource(&pdev->dev, res); ccdc->ccdc_cfg.base_addr = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(ccdc->ccdc_cfg.base_addr)) if (IS_ERR(ccdc->ccdc_cfg.base_addr)) {
return PTR_ERR(ccdc->ccdc_cfg.base_addr); ret = PTR_ERR(ccdc->ccdc_cfg.base_addr);
goto probe_out_cleanup;
}
ret = platform_get_irq(pdev, 0); ret = platform_get_irq(pdev, 0);
if (ret <= 0) { if (ret <= 0) {
dev_err(&pdev->dev, "No IRQ resource\n"); dev_err(&pdev->dev, "No IRQ resource\n");
return -ENODEV; ret = -ENODEV;
goto probe_out_cleanup;
} }
vpfe->irq = ret; vpfe->irq = ret;
...@@ -2565,14 +2568,15 @@ static int vpfe_probe(struct platform_device *pdev) ...@@ -2565,14 +2568,15 @@ static int vpfe_probe(struct platform_device *pdev)
"vpfe_capture0", vpfe); "vpfe_capture0", vpfe);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Unable to request interrupt\n"); dev_err(&pdev->dev, "Unable to request interrupt\n");
return -EINVAL; ret = -EINVAL;
goto probe_out_cleanup;
} }
ret = v4l2_device_register(&pdev->dev, &vpfe->v4l2_dev); ret = v4l2_device_register(&pdev->dev, &vpfe->v4l2_dev);
if (ret) { if (ret) {
vpfe_err(vpfe, vpfe_err(vpfe,
"Unable to register v4l2 device.\n"); "Unable to register v4l2 device.\n");
return ret; goto probe_out_cleanup;
} }
/* set the driver data in platform device */ /* set the driver data in platform device */
...@@ -2596,11 +2600,8 @@ static int vpfe_probe(struct platform_device *pdev) ...@@ -2596,11 +2600,8 @@ static int vpfe_probe(struct platform_device *pdev)
goto probe_out_v4l2_unregister; goto probe_out_v4l2_unregister;
} }
vpfe->notifier.subdevs = vpfe->cfg->asd;
vpfe->notifier.num_subdevs = ARRAY_SIZE(vpfe->cfg->asd);
vpfe->notifier.ops = &vpfe_async_ops; vpfe->notifier.ops = &vpfe_async_ops;
ret = v4l2_async_notifier_register(&vpfe->v4l2_dev, ret = v4l2_async_notifier_register(&vpfe->v4l2_dev, &vpfe->notifier);
&vpfe->notifier);
if (ret) { if (ret) {
vpfe_err(vpfe, "Error registering async notifier\n"); vpfe_err(vpfe, "Error registering async notifier\n");
ret = -EINVAL; ret = -EINVAL;
...@@ -2611,6 +2612,8 @@ static int vpfe_probe(struct platform_device *pdev) ...@@ -2611,6 +2612,8 @@ static int vpfe_probe(struct platform_device *pdev)
probe_out_v4l2_unregister: probe_out_v4l2_unregister:
v4l2_device_unregister(&vpfe->v4l2_dev); v4l2_device_unregister(&vpfe->v4l2_dev);
probe_out_cleanup:
v4l2_async_notifier_cleanup(&vpfe->notifier);
return ret; return ret;
} }
...@@ -2626,6 +2629,7 @@ static int vpfe_remove(struct platform_device *pdev) ...@@ -2626,6 +2629,7 @@ static int vpfe_remove(struct platform_device *pdev)
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
v4l2_async_notifier_unregister(&vpfe->notifier); v4l2_async_notifier_unregister(&vpfe->notifier);
v4l2_async_notifier_cleanup(&vpfe->notifier);
v4l2_device_unregister(&vpfe->v4l2_dev); v4l2_device_unregister(&vpfe->v4l2_dev);
video_unregister_device(&vpfe->video_dev); video_unregister_device(&vpfe->video_dev);
......
...@@ -1983,8 +1983,10 @@ static void isc_subdev_cleanup(struct isc_device *isc) ...@@ -1983,8 +1983,10 @@ static void isc_subdev_cleanup(struct isc_device *isc)
{ {
struct isc_subdev_entity *subdev_entity; struct isc_subdev_entity *subdev_entity;
list_for_each_entry(subdev_entity, &isc->subdev_entities, list) list_for_each_entry(subdev_entity, &isc->subdev_entities, list) {
v4l2_async_notifier_unregister(&subdev_entity->notifier); v4l2_async_notifier_unregister(&subdev_entity->notifier);
v4l2_async_notifier_cleanup(&subdev_entity->notifier);
}
INIT_LIST_HEAD(&isc->subdev_entities); INIT_LIST_HEAD(&isc->subdev_entities);
} }
...@@ -2201,8 +2203,15 @@ static int atmel_isc_probe(struct platform_device *pdev) ...@@ -2201,8 +2203,15 @@ static int atmel_isc_probe(struct platform_device *pdev)
} }
list_for_each_entry(subdev_entity, &isc->subdev_entities, list) { list_for_each_entry(subdev_entity, &isc->subdev_entities, list) {
subdev_entity->notifier.subdevs = &subdev_entity->asd; v4l2_async_notifier_init(&subdev_entity->notifier);
subdev_entity->notifier.num_subdevs = 1;
ret = v4l2_async_notifier_add_subdev(&subdev_entity->notifier,
subdev_entity->asd);
if (ret) {
fwnode_handle_put(subdev_entity->asd->match.fwnode);
goto cleanup_subdev;
}
subdev_entity->notifier.ops = &isc_async_ops; subdev_entity->notifier.ops = &isc_async_ops;
ret = v4l2_async_notifier_register(&isc->v4l2_dev, ret = v4l2_async_notifier_register(&isc->v4l2_dev,
......
...@@ -1124,7 +1124,6 @@ static int isi_graph_parse(struct atmel_isi *isi, struct device_node *node) ...@@ -1124,7 +1124,6 @@ static int isi_graph_parse(struct atmel_isi *isi, struct device_node *node)
static int isi_graph_init(struct atmel_isi *isi) static int isi_graph_init(struct atmel_isi *isi)
{ {
struct v4l2_async_subdev **subdevs = NULL;
int ret; int ret;
/* Parse the graph to extract a list of subdevice DT nodes. */ /* Parse the graph to extract a list of subdevice DT nodes. */
...@@ -1134,23 +1133,20 @@ static int isi_graph_init(struct atmel_isi *isi) ...@@ -1134,23 +1133,20 @@ static int isi_graph_init(struct atmel_isi *isi)
return ret; return ret;
} }
/* Register the subdevices notifier. */ v4l2_async_notifier_init(&isi->notifier);
subdevs = devm_kzalloc(isi->dev, sizeof(*subdevs), GFP_KERNEL);
if (!subdevs) { ret = v4l2_async_notifier_add_subdev(&isi->notifier, &isi->entity.asd);
if (ret) {
of_node_put(isi->entity.node); of_node_put(isi->entity.node);
return -ENOMEM; return ret;
} }
subdevs[0] = &isi->entity.asd;
isi->notifier.subdevs = subdevs;
isi->notifier.num_subdevs = 1;
isi->notifier.ops = &isi_graph_notify_ops; isi->notifier.ops = &isi_graph_notify_ops;
ret = v4l2_async_notifier_register(&isi->v4l2_dev, &isi->notifier); ret = v4l2_async_notifier_register(&isi->v4l2_dev, &isi->notifier);
if (ret < 0) { if (ret < 0) {
dev_err(isi->dev, "Notifier registration failed\n"); dev_err(isi->dev, "Notifier registration failed\n");
of_node_put(isi->entity.node); v4l2_async_notifier_cleanup(&isi->notifier);
return ret; return ret;
} }
...@@ -1303,6 +1299,7 @@ static int atmel_isi_remove(struct platform_device *pdev) ...@@ -1303,6 +1299,7 @@ static int atmel_isi_remove(struct platform_device *pdev)
isi->fb_descriptors_phys); isi->fb_descriptors_phys);
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
v4l2_async_notifier_unregister(&isi->notifier); v4l2_async_notifier_unregister(&isi->notifier);
v4l2_async_notifier_cleanup(&isi->notifier);
v4l2_device_unregister(&isi->v4l2_dev); v4l2_device_unregister(&isi->v4l2_dev);
return 0; return 0;
......
...@@ -399,18 +399,22 @@ static int csi2rx_parse_dt(struct csi2rx_priv *csi2rx) ...@@ -399,18 +399,22 @@ static int csi2rx_parse_dt(struct csi2rx_priv *csi2rx)
csi2rx->asd.match_type = V4L2_ASYNC_MATCH_FWNODE; csi2rx->asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
of_node_put(ep); of_node_put(ep);
csi2rx->notifier.subdevs = devm_kzalloc(csi2rx->dev, v4l2_async_notifier_init(&csi2rx->notifier);
sizeof(*csi2rx->notifier.subdevs),
GFP_KERNEL); ret = v4l2_async_notifier_add_subdev(&csi2rx->notifier, &csi2rx->asd);
if (!csi2rx->notifier.subdevs) if (ret) {
return -ENOMEM; fwnode_handle_put(csi2rx->asd.match.fwnode);
return ret;
}
csi2rx->notifier.subdevs[0] = &csi2rx->asd;
csi2rx->notifier.num_subdevs = 1;
csi2rx->notifier.ops = &csi2rx_notifier_ops; csi2rx->notifier.ops = &csi2rx_notifier_ops;
return v4l2_async_subdev_notifier_register(&csi2rx->subdev, ret = v4l2_async_subdev_notifier_register(&csi2rx->subdev,
&csi2rx->notifier); &csi2rx->notifier);
if (ret)
v4l2_async_notifier_cleanup(&csi2rx->notifier);
return ret;
} }
static int csi2rx_probe(struct platform_device *pdev) static int csi2rx_probe(struct platform_device *pdev)
...@@ -450,11 +454,11 @@ static int csi2rx_probe(struct platform_device *pdev) ...@@ -450,11 +454,11 @@ static int csi2rx_probe(struct platform_device *pdev)
ret = media_entity_pads_init(&csi2rx->subdev.entity, CSI2RX_PAD_MAX, ret = media_entity_pads_init(&csi2rx->subdev.entity, CSI2RX_PAD_MAX,
csi2rx->pads); csi2rx->pads);
if (ret) if (ret)
goto err_free_priv; goto err_cleanup;
ret = v4l2_async_register_subdev(&csi2rx->subdev); ret = v4l2_async_register_subdev(&csi2rx->subdev);
if (ret < 0) if (ret < 0)
goto err_free_priv; goto err_cleanup;
dev_info(&pdev->dev, dev_info(&pdev->dev,
"Probed CSI2RX with %u/%u lanes, %u streams, %s D-PHY\n", "Probed CSI2RX with %u/%u lanes, %u streams, %s D-PHY\n",
...@@ -463,6 +467,8 @@ static int csi2rx_probe(struct platform_device *pdev) ...@@ -463,6 +467,8 @@ static int csi2rx_probe(struct platform_device *pdev)
return 0; return 0;
err_cleanup:
v4l2_async_notifier_cleanup(&csi2rx->notifier);
err_free_priv: err_free_priv:
kfree(csi2rx); kfree(csi2rx);
return ret; return ret;
......
...@@ -1517,6 +1517,8 @@ vpif_capture_get_pdata(struct platform_device *pdev) ...@@ -1517,6 +1517,8 @@ vpif_capture_get_pdata(struct platform_device *pdev)
struct vpif_capture_chan_config *chan; struct vpif_capture_chan_config *chan;
unsigned int i; unsigned int i;
v4l2_async_notifier_init(&vpif_obj.notifier);
/* /*
* DT boot: OF node from parent device contains * DT boot: OF node from parent device contains
* video ports & endpoints data. * video ports & endpoints data.
...@@ -1548,14 +1550,25 @@ vpif_capture_get_pdata(struct platform_device *pdev) ...@@ -1548,14 +1550,25 @@ vpif_capture_get_pdata(struct platform_device *pdev)
if (!endpoint) if (!endpoint)
break; break;
rem = of_graph_get_remote_port_parent(endpoint);
if (!rem) {
dev_dbg(&pdev->dev, "Remote device at %pOF not found\n",
endpoint);
of_node_put(endpoint);
goto done;
}
sdinfo = &pdata->subdev_info[i]; sdinfo = &pdata->subdev_info[i];
chan = &pdata->chan_config[i]; chan = &pdata->chan_config[i];
chan->inputs = devm_kcalloc(&pdev->dev, chan->inputs = devm_kcalloc(&pdev->dev,
VPIF_CAPTURE_NUM_CHANNELS, VPIF_CAPTURE_NUM_CHANNELS,
sizeof(*chan->inputs), sizeof(*chan->inputs),
GFP_KERNEL); GFP_KERNEL);
if (!chan->inputs) if (!chan->inputs) {
return NULL; of_node_put(rem);
of_node_put(endpoint);
goto err_cleanup;
}
chan->input_count++; chan->input_count++;
chan->inputs[i].input.type = V4L2_INPUT_TYPE_CAMERA; chan->inputs[i].input.type = V4L2_INPUT_TYPE_CAMERA;
...@@ -1564,12 +1577,16 @@ vpif_capture_get_pdata(struct platform_device *pdev) ...@@ -1564,12 +1577,16 @@ vpif_capture_get_pdata(struct platform_device *pdev)
err = v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint), err = v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint),
&bus_cfg); &bus_cfg);
of_node_put(endpoint);
if (err) { if (err) {
dev_err(&pdev->dev, "Could not parse the endpoint\n"); dev_err(&pdev->dev, "Could not parse the endpoint\n");
of_node_put(rem);
goto done; goto done;
} }
dev_dbg(&pdev->dev, "Endpoint %pOF, bus_width = %d\n", dev_dbg(&pdev->dev, "Endpoint %pOF, bus_width = %d\n",
endpoint, bus_cfg.bus.parallel.bus_width); endpoint, bus_cfg.bus.parallel.bus_width);
flags = bus_cfg.bus.parallel.flags; flags = bus_cfg.bus.parallel.flags;
if (flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH) if (flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH)
...@@ -1578,38 +1595,29 @@ vpif_capture_get_pdata(struct platform_device *pdev) ...@@ -1578,38 +1595,29 @@ vpif_capture_get_pdata(struct platform_device *pdev)
if (flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH) if (flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH)
chan->vpif_if.vd_pol = 1; chan->vpif_if.vd_pol = 1;
rem = of_graph_get_remote_port_parent(endpoint);
if (!rem) {
dev_dbg(&pdev->dev, "Remote device at %pOF not found\n",
endpoint);
goto done;
}
dev_dbg(&pdev->dev, "Remote device %pOF found\n", rem); dev_dbg(&pdev->dev, "Remote device %pOF found\n", rem);
sdinfo->name = rem->full_name; sdinfo->name = rem->full_name;
pdata->asd[i] = devm_kzalloc(&pdev->dev, pdata->asd[i] = v4l2_async_notifier_add_fwnode_subdev(
sizeof(struct v4l2_async_subdev), &vpif_obj.notifier, of_fwnode_handle(rem),
GFP_KERNEL); sizeof(struct v4l2_async_subdev));
if (!pdata->asd[i]) { if (IS_ERR(pdata->asd[i])) {
of_node_put(rem); of_node_put(rem);
pdata = NULL; goto err_cleanup;
goto done;
} }
pdata->asd[i]->match_type = V4L2_ASYNC_MATCH_FWNODE;
pdata->asd[i]->match.fwnode = of_fwnode_handle(rem);
of_node_put(rem);
} }
done: done:
if (pdata) { pdata->asd_sizes[0] = i;
pdata->asd_sizes[0] = i; pdata->subdev_count = i;
pdata->subdev_count = i; pdata->card_name = "DA850/OMAP-L138 Video Capture";
pdata->card_name = "DA850/OMAP-L138 Video Capture";
}
return pdata; return pdata;
err_cleanup:
v4l2_async_notifier_cleanup(&vpif_obj.notifier);
return NULL;
} }
/** /**
...@@ -1634,23 +1642,18 @@ static __init int vpif_probe(struct platform_device *pdev) ...@@ -1634,23 +1642,18 @@ static __init int vpif_probe(struct platform_device *pdev)
return -EINVAL; return -EINVAL;
} }
if (!pdev->dev.platform_data) {
dev_warn(&pdev->dev, "Missing platform data. Giving up.\n");
return -EINVAL;
}
vpif_dev = &pdev->dev; vpif_dev = &pdev->dev;
err = initialize_vpif(); err = initialize_vpif();
if (err) { if (err) {
v4l2_err(vpif_dev->driver, "Error initializing vpif\n"); v4l2_err(vpif_dev->driver, "Error initializing vpif\n");
return err; goto cleanup;
} }
err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev); err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
if (err) { if (err) {
v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n"); v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
return err; goto cleanup;
} }
while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, res_idx))) { while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, res_idx))) {
...@@ -1699,8 +1702,6 @@ static __init int vpif_probe(struct platform_device *pdev) ...@@ -1699,8 +1702,6 @@ static __init int vpif_probe(struct platform_device *pdev)
} }
vpif_probe_complete(); vpif_probe_complete();
} else { } else {
vpif_obj.notifier.subdevs = vpif_obj.config->asd;
vpif_obj.notifier.num_subdevs = vpif_obj.config->asd_sizes[0];
vpif_obj.notifier.ops = &vpif_async_ops; vpif_obj.notifier.ops = &vpif_async_ops;
err = v4l2_async_notifier_register(&vpif_obj.v4l2_dev, err = v4l2_async_notifier_register(&vpif_obj.v4l2_dev,
&vpif_obj.notifier); &vpif_obj.notifier);
...@@ -1718,6 +1719,8 @@ static __init int vpif_probe(struct platform_device *pdev) ...@@ -1718,6 +1719,8 @@ static __init int vpif_probe(struct platform_device *pdev)
kfree(vpif_obj.sd); kfree(vpif_obj.sd);
vpif_unregister: vpif_unregister:
v4l2_device_unregister(&vpif_obj.v4l2_dev); v4l2_device_unregister(&vpif_obj.v4l2_dev);
cleanup:
v4l2_async_notifier_cleanup(&vpif_obj.notifier);
return err; return err;
} }
...@@ -1733,6 +1736,8 @@ static int vpif_remove(struct platform_device *device) ...@@ -1733,6 +1736,8 @@ static int vpif_remove(struct platform_device *device)
struct channel_obj *ch; struct channel_obj *ch;
int i; int i;
v4l2_async_notifier_unregister(&vpif_obj.notifier);
v4l2_async_notifier_cleanup(&vpif_obj.notifier);
v4l2_device_unregister(&vpif_obj.v4l2_dev); v4l2_device_unregister(&vpif_obj.v4l2_dev);
kfree(vpif_obj.sd); kfree(vpif_obj.sd);
......
...@@ -1300,6 +1300,8 @@ static __init int vpif_probe(struct platform_device *pdev) ...@@ -1300,6 +1300,8 @@ static __init int vpif_probe(struct platform_device *pdev)
goto vpif_unregister; goto vpif_unregister;
} }
v4l2_async_notifier_init(&vpif_obj.notifier);
if (!vpif_obj.config->asd_sizes) { if (!vpif_obj.config->asd_sizes) {
i2c_adap = i2c_get_adapter(vpif_obj.config->i2c_adapter_id); i2c_adap = i2c_get_adapter(vpif_obj.config->i2c_adapter_id);
for (i = 0; i < subdev_count; i++) { for (i = 0; i < subdev_count; i++) {
...@@ -1323,20 +1325,27 @@ static __init int vpif_probe(struct platform_device *pdev) ...@@ -1323,20 +1325,27 @@ static __init int vpif_probe(struct platform_device *pdev)
goto probe_subdev_out; goto probe_subdev_out;
} }
} else { } else {
vpif_obj.notifier.subdevs = vpif_obj.config->asd; for (i = 0; i < vpif_obj.config->asd_sizes[0]; i++) {
vpif_obj.notifier.num_subdevs = vpif_obj.config->asd_sizes[0]; err = v4l2_async_notifier_add_subdev(
&vpif_obj.notifier, vpif_obj.config->asd[i]);
if (err)
goto probe_cleanup;
}
vpif_obj.notifier.ops = &vpif_async_ops; vpif_obj.notifier.ops = &vpif_async_ops;
err = v4l2_async_notifier_register(&vpif_obj.v4l2_dev, err = v4l2_async_notifier_register(&vpif_obj.v4l2_dev,
&vpif_obj.notifier); &vpif_obj.notifier);
if (err) { if (err) {
vpif_err("Error registering async notifier\n"); vpif_err("Error registering async notifier\n");
err = -EINVAL; err = -EINVAL;
goto probe_subdev_out; goto probe_cleanup;
} }
} }
return 0; return 0;
probe_cleanup:
v4l2_async_notifier_cleanup(&vpif_obj.notifier);
probe_subdev_out: probe_subdev_out:
kfree(vpif_obj.sd); kfree(vpif_obj.sd);
vpif_unregister: vpif_unregister:
...@@ -1355,6 +1364,11 @@ static int vpif_remove(struct platform_device *device) ...@@ -1355,6 +1364,11 @@ static int vpif_remove(struct platform_device *device)
struct channel_obj *ch; struct channel_obj *ch;
int i; int i;
if (vpif_obj.config->asd_sizes) {
v4l2_async_notifier_unregister(&vpif_obj.notifier);
v4l2_async_notifier_cleanup(&vpif_obj.notifier);
}
v4l2_device_unregister(&vpif_obj.v4l2_dev); v4l2_device_unregister(&vpif_obj.v4l2_dev);
kfree(vpif_obj.sd); kfree(vpif_obj.sd);
......
...@@ -457,11 +457,16 @@ static int fimc_md_parse_port_node(struct fimc_md *fmd, ...@@ -457,11 +457,16 @@ static int fimc_md_parse_port_node(struct fimc_md *fmd,
fmd->sensor[index].asd.match_type = V4L2_ASYNC_MATCH_FWNODE; fmd->sensor[index].asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
fmd->sensor[index].asd.match.fwnode = of_fwnode_handle(rem); fmd->sensor[index].asd.match.fwnode = of_fwnode_handle(rem);
fmd->async_subdevs[index] = &fmd->sensor[index].asd;
ret = v4l2_async_notifier_add_subdev(&fmd->subdev_notifier,
&fmd->sensor[index].asd);
if (ret) {
of_node_put(rem);
return ret;
}
fmd->num_sensors++; fmd->num_sensors++;
of_node_put(rem);
return 0; return 0;
} }
...@@ -500,7 +505,7 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd) ...@@ -500,7 +505,7 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
ret = fimc_md_parse_port_node(fmd, port, index); ret = fimc_md_parse_port_node(fmd, port, index);
if (ret < 0) { if (ret < 0) {
of_node_put(node); of_node_put(node);
goto rpm_put; goto cleanup;
} }
index++; index++;
} }
...@@ -514,11 +519,17 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd) ...@@ -514,11 +519,17 @@ static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
ret = fimc_md_parse_port_node(fmd, node, index); ret = fimc_md_parse_port_node(fmd, node, index);
if (ret < 0) { if (ret < 0) {
of_node_put(node); of_node_put(node);
break; goto cleanup;
} }
index++; index++;
} }
rpm_put: rpm_put:
pm_runtime_put(fmd->pmf);
return 0;
cleanup:
v4l2_async_notifier_cleanup(&fmd->subdev_notifier);
pm_runtime_put(fmd->pmf); pm_runtime_put(fmd->pmf);
return ret; return ret;
} }
...@@ -1460,6 +1471,8 @@ static int fimc_md_probe(struct platform_device *pdev) ...@@ -1460,6 +1471,8 @@ static int fimc_md_probe(struct platform_device *pdev)
platform_set_drvdata(pdev, fmd); platform_set_drvdata(pdev, fmd);
v4l2_async_notifier_init(&fmd->subdev_notifier);
ret = fimc_md_register_platform_entities(fmd, dev->of_node); ret = fimc_md_register_platform_entities(fmd, dev->of_node);
if (ret) if (ret)
goto err_clk; goto err_clk;
...@@ -1470,7 +1483,7 @@ static int fimc_md_probe(struct platform_device *pdev) ...@@ -1470,7 +1483,7 @@ static int fimc_md_probe(struct platform_device *pdev)
ret = device_create_file(&pdev->dev, &dev_attr_subdev_conf_mode); ret = device_create_file(&pdev->dev, &dev_attr_subdev_conf_mode);
if (ret) if (ret)
goto err_m_ent; goto err_cleanup;
/* /*
* FIMC platform devices need to be registered before the sclk_cam * FIMC platform devices need to be registered before the sclk_cam
* clocks provider, as one of these devices needs to be activated * clocks provider, as one of these devices needs to be activated
...@@ -1483,8 +1496,6 @@ static int fimc_md_probe(struct platform_device *pdev) ...@@ -1483,8 +1496,6 @@ static int fimc_md_probe(struct platform_device *pdev)
} }
if (fmd->num_sensors > 0) { if (fmd->num_sensors > 0) {
fmd->subdev_notifier.subdevs = fmd->async_subdevs;
fmd->subdev_notifier.num_subdevs = fmd->num_sensors;
fmd->subdev_notifier.ops = &subdev_notifier_ops; fmd->subdev_notifier.ops = &subdev_notifier_ops;
fmd->num_sensors = 0; fmd->num_sensors = 0;
...@@ -1500,10 +1511,12 @@ static int fimc_md_probe(struct platform_device *pdev) ...@@ -1500,10 +1511,12 @@ static int fimc_md_probe(struct platform_device *pdev)
fimc_md_unregister_clk_provider(fmd); fimc_md_unregister_clk_provider(fmd);
err_attr: err_attr:
device_remove_file(&pdev->dev, &dev_attr_subdev_conf_mode); device_remove_file(&pdev->dev, &dev_attr_subdev_conf_mode);
err_clk: err_cleanup:
fimc_md_put_clocks(fmd); v4l2_async_notifier_cleanup(&fmd->subdev_notifier);
err_m_ent: err_m_ent:
fimc_md_unregister_entities(fmd); fimc_md_unregister_entities(fmd);
err_clk:
fimc_md_put_clocks(fmd);
err_md: err_md:
media_device_cleanup(&fmd->media_dev); media_device_cleanup(&fmd->media_dev);
v4l2_device_unregister(&fmd->v4l2_dev); v4l2_device_unregister(&fmd->v4l2_dev);
...@@ -1519,6 +1532,7 @@ static int fimc_md_remove(struct platform_device *pdev) ...@@ -1519,6 +1532,7 @@ static int fimc_md_remove(struct platform_device *pdev)
fimc_md_unregister_clk_provider(fmd); fimc_md_unregister_clk_provider(fmd);
v4l2_async_notifier_unregister(&fmd->subdev_notifier); v4l2_async_notifier_unregister(&fmd->subdev_notifier);
v4l2_async_notifier_cleanup(&fmd->subdev_notifier);
v4l2_device_unregister(&fmd->v4l2_dev); v4l2_device_unregister(&fmd->v4l2_dev);
device_remove_file(&pdev->dev, &dev_attr_subdev_conf_mode); device_remove_file(&pdev->dev, &dev_attr_subdev_conf_mode);
......
...@@ -149,7 +149,6 @@ struct fimc_md { ...@@ -149,7 +149,6 @@ struct fimc_md {
} clk_provider; } clk_provider;
struct v4l2_async_notifier subdev_notifier; struct v4l2_async_notifier subdev_notifier;
struct v4l2_async_subdev *async_subdevs[FIMC_MAX_SENSORS];
bool user_subdev_api; bool user_subdev_api;
spinlock_t slock; spinlock_t slock;
......
...@@ -697,7 +697,6 @@ struct pxa_camera_dev { ...@@ -697,7 +697,6 @@ struct pxa_camera_dev {
struct v4l2_pix_format current_pix; struct v4l2_pix_format current_pix;
struct v4l2_async_subdev asd; struct v4l2_async_subdev asd;
struct v4l2_async_subdev *asds[1];
/* /*
* PXA27x is only supposed to handle one camera on its Quick Capture * PXA27x is only supposed to handle one camera on its Quick Capture
...@@ -2352,12 +2351,10 @@ static int pxa_camera_pdata_from_dt(struct device *dev, ...@@ -2352,12 +2351,10 @@ static int pxa_camera_pdata_from_dt(struct device *dev,
asd->match_type = V4L2_ASYNC_MATCH_FWNODE; asd->match_type = V4L2_ASYNC_MATCH_FWNODE;
remote = of_graph_get_remote_port(np); remote = of_graph_get_remote_port(np);
if (remote) { if (remote)
asd->match.fwnode = of_fwnode_handle(remote); asd->match.fwnode = of_fwnode_handle(remote);
of_node_put(remote); else
} else {
dev_notice(dev, "no remote for %pOF\n", np); dev_notice(dev, "no remote for %pOF\n", np);
}
out: out:
of_node_put(np); of_node_put(np);
...@@ -2495,9 +2492,14 @@ static int pxa_camera_probe(struct platform_device *pdev) ...@@ -2495,9 +2492,14 @@ static int pxa_camera_probe(struct platform_device *pdev)
if (err) if (err)
goto exit_deactivate; goto exit_deactivate;
pcdev->asds[0] = &pcdev->asd; v4l2_async_notifier_init(&pcdev->notifier);
pcdev->notifier.subdevs = pcdev->asds;
pcdev->notifier.num_subdevs = 1; err = v4l2_async_notifier_add_subdev(&pcdev->notifier, &pcdev->asd);
if (err) {
fwnode_handle_put(pcdev->asd.match.fwnode);
goto exit_free_v4l2dev;
}
pcdev->notifier.ops = &pxa_camera_sensor_ops; pcdev->notifier.ops = &pxa_camera_sensor_ops;
if (!of_have_populated_dt()) if (!of_have_populated_dt())
...@@ -2505,7 +2507,7 @@ static int pxa_camera_probe(struct platform_device *pdev) ...@@ -2505,7 +2507,7 @@ static int pxa_camera_probe(struct platform_device *pdev)
err = pxa_camera_init_videobuf2(pcdev); err = pxa_camera_init_videobuf2(pcdev);
if (err) if (err)
goto exit_free_v4l2dev; goto exit_notifier_cleanup;
if (pcdev->mclk) { if (pcdev->mclk) {
v4l2_clk_name_i2c(clk_name, sizeof(clk_name), v4l2_clk_name_i2c(clk_name, sizeof(clk_name),
...@@ -2516,7 +2518,7 @@ static int pxa_camera_probe(struct platform_device *pdev) ...@@ -2516,7 +2518,7 @@ static int pxa_camera_probe(struct platform_device *pdev)
clk_name, NULL); clk_name, NULL);
if (IS_ERR(pcdev->mclk_clk)) { if (IS_ERR(pcdev->mclk_clk)) {
err = PTR_ERR(pcdev->mclk_clk); err = PTR_ERR(pcdev->mclk_clk);
goto exit_free_v4l2dev; goto exit_notifier_cleanup;
} }
} }
...@@ -2527,6 +2529,8 @@ static int pxa_camera_probe(struct platform_device *pdev) ...@@ -2527,6 +2529,8 @@ static int pxa_camera_probe(struct platform_device *pdev)
return 0; return 0;
exit_free_clk: exit_free_clk:
v4l2_clk_unregister(pcdev->mclk_clk); v4l2_clk_unregister(pcdev->mclk_clk);
exit_notifier_cleanup:
v4l2_async_notifier_cleanup(&pcdev->notifier);
exit_free_v4l2dev: exit_free_v4l2dev:
v4l2_device_unregister(&pcdev->v4l2_dev); v4l2_device_unregister(&pcdev->v4l2_dev);
exit_deactivate: exit_deactivate:
...@@ -2550,6 +2554,7 @@ static int pxa_camera_remove(struct platform_device *pdev) ...@@ -2550,6 +2554,7 @@ static int pxa_camera_remove(struct platform_device *pdev)
dma_release_channel(pcdev->dma_chans[2]); dma_release_channel(pcdev->dma_chans[2]);
v4l2_async_notifier_unregister(&pcdev->notifier); v4l2_async_notifier_unregister(&pcdev->notifier);
v4l2_async_notifier_cleanup(&pcdev->notifier);
if (pcdev->mclk_clk) { if (pcdev->mclk_clk) {
v4l2_clk_unregister(pcdev->mclk_clk); v4l2_clk_unregister(pcdev->mclk_clk);
......
...@@ -462,61 +462,51 @@ static int camss_of_parse_endpoint_node(struct device *dev, ...@@ -462,61 +462,51 @@ static int camss_of_parse_endpoint_node(struct device *dev,
* *
* Return number of "port" nodes found in "ports" node * Return number of "port" nodes found in "ports" node
*/ */
static int camss_of_parse_ports(struct device *dev, static int camss_of_parse_ports(struct camss *camss)
struct v4l2_async_notifier *notifier)
{ {
struct device *dev = camss->dev;
struct device_node *node = NULL; struct device_node *node = NULL;
struct device_node *remote = NULL; struct device_node *remote = NULL;
unsigned int size, i; int ret, num_subdevs = 0;
int ret;
while ((node = of_graph_get_next_endpoint(dev->of_node, node)))
if (of_device_is_available(node))
notifier->num_subdevs++;
of_node_put(node);
size = sizeof(*notifier->subdevs) * notifier->num_subdevs;
notifier->subdevs = devm_kzalloc(dev, size, GFP_KERNEL);
if (!notifier->subdevs) {
dev_err(dev, "Failed to allocate memory\n");
return -ENOMEM;
}
i = 0; for_each_endpoint_of_node(dev->of_node, node) {
while ((node = of_graph_get_next_endpoint(dev->of_node, node))) {
struct camss_async_subdev *csd; struct camss_async_subdev *csd;
struct v4l2_async_subdev *asd;
if (!of_device_is_available(node)) if (!of_device_is_available(node))
continue; continue;
csd = devm_kzalloc(dev, sizeof(*csd), GFP_KERNEL);
if (!csd) {
of_node_put(node);
dev_err(dev, "Failed to allocate memory\n");
return -ENOMEM;
}
notifier->subdevs[i++] = &csd->asd;
ret = camss_of_parse_endpoint_node(dev, node, csd);
if (ret < 0) {
of_node_put(node);
return ret;
}
remote = of_graph_get_remote_port_parent(node); remote = of_graph_get_remote_port_parent(node);
if (!remote) { if (!remote) {
dev_err(dev, "Cannot get remote parent\n"); dev_err(dev, "Cannot get remote parent\n");
of_node_put(node); ret = -EINVAL;
return -EINVAL; goto err_cleanup;
} }
csd->asd.match_type = V4L2_ASYNC_MATCH_FWNODE; asd = v4l2_async_notifier_add_fwnode_subdev(
csd->asd.match.fwnode = of_fwnode_handle(remote); &camss->notifier, of_fwnode_handle(remote),
sizeof(*csd));
if (IS_ERR(asd)) {
ret = PTR_ERR(asd);
of_node_put(remote);
goto err_cleanup;
}
csd = container_of(asd, struct camss_async_subdev, asd);
ret = camss_of_parse_endpoint_node(dev, node, csd);
if (ret < 0)
goto err_cleanup;
num_subdevs++;
} }
of_node_put(node);
return notifier->num_subdevs; return num_subdevs;
err_cleanup:
v4l2_async_notifier_cleanup(&camss->notifier);
of_node_put(node);
return ret;
} }
/* /*
...@@ -823,7 +813,7 @@ static int camss_probe(struct platform_device *pdev) ...@@ -823,7 +813,7 @@ static int camss_probe(struct platform_device *pdev)
{ {
struct device *dev = &pdev->dev; struct device *dev = &pdev->dev;
struct camss *camss; struct camss *camss;
int ret; int num_subdevs, ret;
camss = kzalloc(sizeof(*camss), GFP_KERNEL); camss = kzalloc(sizeof(*camss), GFP_KERNEL);
if (!camss) if (!camss)
...@@ -863,17 +853,19 @@ static int camss_probe(struct platform_device *pdev) ...@@ -863,17 +853,19 @@ static int camss_probe(struct platform_device *pdev)
if (!camss->vfe) if (!camss->vfe)
return -ENOMEM; return -ENOMEM;
ret = camss_of_parse_ports(dev, &camss->notifier); v4l2_async_notifier_init(&camss->notifier);
if (ret < 0)
return ret; num_subdevs = camss_of_parse_ports(camss);
if (num_subdevs < 0)
return num_subdevs;
ret = camss_init_subdevices(camss); ret = camss_init_subdevices(camss);
if (ret < 0) if (ret < 0)
return ret; goto err_cleanup;
ret = dma_set_mask_and_coherent(dev, 0xffffffff); ret = dma_set_mask_and_coherent(dev, 0xffffffff);
if (ret) if (ret)
return ret; goto err_cleanup;
camss->media_dev.dev = camss->dev; camss->media_dev.dev = camss->dev;
strscpy(camss->media_dev.model, "Qualcomm Camera Subsystem", strscpy(camss->media_dev.model, "Qualcomm Camera Subsystem",
...@@ -885,14 +877,14 @@ static int camss_probe(struct platform_device *pdev) ...@@ -885,14 +877,14 @@ static int camss_probe(struct platform_device *pdev)
ret = v4l2_device_register(camss->dev, &camss->v4l2_dev); ret = v4l2_device_register(camss->dev, &camss->v4l2_dev);
if (ret < 0) { if (ret < 0) {
dev_err(dev, "Failed to register V4L2 device: %d\n", ret); dev_err(dev, "Failed to register V4L2 device: %d\n", ret);
return ret; goto err_cleanup;
} }
ret = camss_register_entities(camss); ret = camss_register_entities(camss);
if (ret < 0) if (ret < 0)
goto err_register_entities; goto err_register_entities;
if (camss->notifier.num_subdevs) { if (num_subdevs) {
camss->notifier.ops = &camss_subdev_notifier_ops; camss->notifier.ops = &camss_subdev_notifier_ops;
ret = v4l2_async_notifier_register(&camss->v4l2_dev, ret = v4l2_async_notifier_register(&camss->v4l2_dev,
...@@ -942,6 +934,8 @@ static int camss_probe(struct platform_device *pdev) ...@@ -942,6 +934,8 @@ static int camss_probe(struct platform_device *pdev)
camss_unregister_entities(camss); camss_unregister_entities(camss);
err_register_entities: err_register_entities:
v4l2_device_unregister(&camss->v4l2_dev); v4l2_device_unregister(&camss->v4l2_dev);
err_cleanup:
v4l2_async_notifier_cleanup(&camss->notifier);
return ret; return ret;
} }
...@@ -978,6 +972,7 @@ static int camss_remove(struct platform_device *pdev) ...@@ -978,6 +972,7 @@ static int camss_remove(struct platform_device *pdev)
msm_vfe_stop_streaming(&camss->vfe[i]); msm_vfe_stop_streaming(&camss->vfe[i]);
v4l2_async_notifier_unregister(&camss->notifier); v4l2_async_notifier_unregister(&camss->notifier);
v4l2_async_notifier_cleanup(&camss->notifier);
camss_unregister_entities(camss); camss_unregister_entities(camss);
if (atomic_read(&camss->ref_count) == 0) if (atomic_read(&camss->ref_count) == 0)
......
...@@ -91,8 +91,8 @@ struct camss_camera_interface { ...@@ -91,8 +91,8 @@ struct camss_camera_interface {
}; };
struct camss_async_subdev { struct camss_async_subdev {
struct v4l2_async_subdev asd; /* must be first */
struct camss_camera_interface interface; struct camss_camera_interface interface;
struct v4l2_async_subdev asd;
}; };
struct camss_clock { struct camss_clock {
......
...@@ -827,7 +827,7 @@ static int rvin_mc_parse_of_graph(struct rvin_dev *vin) ...@@ -827,7 +827,7 @@ static int rvin_mc_parse_of_graph(struct rvin_dev *vin)
mutex_unlock(&vin->group->lock); mutex_unlock(&vin->group->lock);
if (!vin->group->notifier.num_subdevs) if (list_empty(&vin->group->notifier.asd_list))
return 0; return 0;
vin->group->notifier.ops = &rvin_group_notify_ops; vin->group->notifier.ops = &rvin_group_notify_ops;
......
...@@ -771,21 +771,25 @@ static int rcsi2_parse_dt(struct rcar_csi2 *priv) ...@@ -771,21 +771,25 @@ static int rcsi2_parse_dt(struct rcar_csi2 *priv)
of_node_put(ep); of_node_put(ep);
priv->notifier.subdevs = devm_kzalloc(priv->dev, v4l2_async_notifier_init(&priv->notifier);
sizeof(*priv->notifier.subdevs),
GFP_KERNEL); ret = v4l2_async_notifier_add_subdev(&priv->notifier, &priv->asd);
if (!priv->notifier.subdevs) if (ret) {
return -ENOMEM; fwnode_handle_put(priv->asd.match.fwnode);
return ret;
}
priv->notifier.num_subdevs = 1;
priv->notifier.subdevs[0] = &priv->asd;
priv->notifier.ops = &rcar_csi2_notify_ops; priv->notifier.ops = &rcar_csi2_notify_ops;
dev_dbg(priv->dev, "Found '%pOF'\n", dev_dbg(priv->dev, "Found '%pOF'\n",
to_of_node(priv->asd.match.fwnode)); to_of_node(priv->asd.match.fwnode));
return v4l2_async_subdev_notifier_register(&priv->subdev, ret = v4l2_async_subdev_notifier_register(&priv->subdev,
&priv->notifier); &priv->notifier);
if (ret)
v4l2_async_notifier_cleanup(&priv->notifier);
return ret;
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
......
...@@ -1213,18 +1213,15 @@ static int rcar_drif_parse_subdevs(struct rcar_drif_sdr *sdr) ...@@ -1213,18 +1213,15 @@ static int rcar_drif_parse_subdevs(struct rcar_drif_sdr *sdr)
{ {
struct v4l2_async_notifier *notifier = &sdr->notifier; struct v4l2_async_notifier *notifier = &sdr->notifier;
struct fwnode_handle *fwnode, *ep; struct fwnode_handle *fwnode, *ep;
int ret;
notifier->subdevs = devm_kzalloc(sdr->dev, sizeof(*notifier->subdevs), v4l2_async_notifier_init(notifier);
GFP_KERNEL);
if (!notifier->subdevs)
return -ENOMEM;
ep = fwnode_graph_get_next_endpoint(of_fwnode_handle(sdr->dev->of_node), ep = fwnode_graph_get_next_endpoint(of_fwnode_handle(sdr->dev->of_node),
NULL); NULL);
if (!ep) if (!ep)
return 0; return 0;
notifier->subdevs[notifier->num_subdevs] = &sdr->ep.asd;
fwnode = fwnode_graph_get_remote_port_parent(ep); fwnode = fwnode_graph_get_remote_port_parent(ep);
if (!fwnode) { if (!fwnode) {
dev_warn(sdr->dev, "bad remote port parent\n"); dev_warn(sdr->dev, "bad remote port parent\n");
...@@ -1234,7 +1231,11 @@ static int rcar_drif_parse_subdevs(struct rcar_drif_sdr *sdr) ...@@ -1234,7 +1231,11 @@ static int rcar_drif_parse_subdevs(struct rcar_drif_sdr *sdr)
sdr->ep.asd.match.fwnode = fwnode; sdr->ep.asd.match.fwnode = fwnode;
sdr->ep.asd.match_type = V4L2_ASYNC_MATCH_FWNODE; sdr->ep.asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
notifier->num_subdevs++; ret = v4l2_async_notifier_add_subdev(notifier, &sdr->ep.asd);
if (ret) {
fwnode_handle_put(fwnode);
return ret;
}
/* Get the endpoint properties */ /* Get the endpoint properties */
rcar_drif_get_ep_properties(sdr, ep); rcar_drif_get_ep_properties(sdr, ep);
...@@ -1356,11 +1357,13 @@ static int rcar_drif_sdr_probe(struct rcar_drif_sdr *sdr) ...@@ -1356,11 +1357,13 @@ static int rcar_drif_sdr_probe(struct rcar_drif_sdr *sdr)
ret = v4l2_async_notifier_register(&sdr->v4l2_dev, &sdr->notifier); ret = v4l2_async_notifier_register(&sdr->v4l2_dev, &sdr->notifier);
if (ret < 0) { if (ret < 0) {
dev_err(sdr->dev, "failed: notifier register ret %d\n", ret); dev_err(sdr->dev, "failed: notifier register ret %d\n", ret);
goto error; goto cleanup;
} }
return ret; return ret;
cleanup:
v4l2_async_notifier_cleanup(&sdr->notifier);
error: error:
v4l2_device_unregister(&sdr->v4l2_dev); v4l2_device_unregister(&sdr->v4l2_dev);
...@@ -1371,6 +1374,7 @@ static int rcar_drif_sdr_probe(struct rcar_drif_sdr *sdr) ...@@ -1371,6 +1374,7 @@ static int rcar_drif_sdr_probe(struct rcar_drif_sdr *sdr)
static void rcar_drif_sdr_remove(struct rcar_drif_sdr *sdr) static void rcar_drif_sdr_remove(struct rcar_drif_sdr *sdr)
{ {
v4l2_async_notifier_unregister(&sdr->notifier); v4l2_async_notifier_unregister(&sdr->notifier);
v4l2_async_notifier_cleanup(&sdr->notifier);
v4l2_device_unregister(&sdr->v4l2_dev); v4l2_device_unregister(&sdr->v4l2_dev);
} }
......
...@@ -189,8 +189,6 @@ struct ceu_device { ...@@ -189,8 +189,6 @@ struct ceu_device {
/* async subdev notification helpers */ /* async subdev notification helpers */
struct v4l2_async_notifier notifier; struct v4l2_async_notifier notifier;
/* pointers to "struct ceu_subdevice -> asd" */
struct v4l2_async_subdev **asds;
/* vb2 queue, capture buffer list and active buffer pointer */ /* vb2 queue, capture buffer list and active buffer pointer */
struct vb2_queue vb2_vq; struct vb2_queue vb2_vq;
...@@ -1482,15 +1480,6 @@ static int ceu_init_async_subdevs(struct ceu_device *ceudev, unsigned int n_sd) ...@@ -1482,15 +1480,6 @@ static int ceu_init_async_subdevs(struct ceu_device *ceudev, unsigned int n_sd)
if (!ceudev->subdevs) if (!ceudev->subdevs)
return -ENOMEM; return -ENOMEM;
/*
* Reserve memory for 'n_sd' pointers to async_subdevices.
* ceudev->asds members will point to &ceu_subdev.asd
*/
ceudev->asds = devm_kcalloc(ceudev->dev, n_sd,
sizeof(*ceudev->asds), GFP_KERNEL);
if (!ceudev->asds)
return -ENOMEM;
ceudev->sd = NULL; ceudev->sd = NULL;
ceudev->sd_index = 0; ceudev->sd_index = 0;
ceudev->num_sd = 0; ceudev->num_sd = 0;
...@@ -1518,6 +1507,7 @@ static int ceu_parse_platform_data(struct ceu_device *ceudev, ...@@ -1518,6 +1507,7 @@ static int ceu_parse_platform_data(struct ceu_device *ceudev,
return ret; return ret;
for (i = 0; i < pdata->num_subdevs; i++) { for (i = 0; i < pdata->num_subdevs; i++) {
/* Setup the ceu subdevice and the async subdevice. */ /* Setup the ceu subdevice and the async subdevice. */
async_sd = &pdata->subdevs[i]; async_sd = &pdata->subdevs[i];
ceu_sd = &ceudev->subdevs[i]; ceu_sd = &ceudev->subdevs[i];
...@@ -1529,7 +1519,12 @@ static int ceu_parse_platform_data(struct ceu_device *ceudev, ...@@ -1529,7 +1519,12 @@ static int ceu_parse_platform_data(struct ceu_device *ceudev,
ceu_sd->asd.match.i2c.adapter_id = async_sd->i2c_adapter_id; ceu_sd->asd.match.i2c.adapter_id = async_sd->i2c_adapter_id;
ceu_sd->asd.match.i2c.address = async_sd->i2c_address; ceu_sd->asd.match.i2c.address = async_sd->i2c_address;
ceudev->asds[i] = &ceu_sd->asd; ret = v4l2_async_notifier_add_subdev(&ceudev->notifier,
&ceu_sd->asd);
if (ret) {
v4l2_async_notifier_cleanup(&ceudev->notifier);
return ret;
}
} }
return pdata->num_subdevs; return pdata->num_subdevs;
...@@ -1542,8 +1537,8 @@ static int ceu_parse_dt(struct ceu_device *ceudev) ...@@ -1542,8 +1537,8 @@ static int ceu_parse_dt(struct ceu_device *ceudev)
{ {
struct device_node *of = ceudev->dev->of_node; struct device_node *of = ceudev->dev->of_node;
struct v4l2_fwnode_endpoint fw_ep; struct v4l2_fwnode_endpoint fw_ep;
struct device_node *ep, *remote;
struct ceu_subdev *ceu_sd; struct ceu_subdev *ceu_sd;
struct device_node *ep;
unsigned int i; unsigned int i;
int num_ep; int num_ep;
int ret; int ret;
...@@ -1562,40 +1557,46 @@ static int ceu_parse_dt(struct ceu_device *ceudev) ...@@ -1562,40 +1557,46 @@ static int ceu_parse_dt(struct ceu_device *ceudev)
dev_err(ceudev->dev, dev_err(ceudev->dev,
"No subdevice connected on endpoint %u.\n", i); "No subdevice connected on endpoint %u.\n", i);
ret = -ENODEV; ret = -ENODEV;
goto error_put_node; goto error_cleanup;
} }
ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep), &fw_ep); ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep), &fw_ep);
if (ret) { if (ret) {
dev_err(ceudev->dev, dev_err(ceudev->dev,
"Unable to parse endpoint #%u.\n", i); "Unable to parse endpoint #%u.\n", i);
goto error_put_node; goto error_cleanup;
} }
if (fw_ep.bus_type != V4L2_MBUS_PARALLEL) { if (fw_ep.bus_type != V4L2_MBUS_PARALLEL) {
dev_err(ceudev->dev, dev_err(ceudev->dev,
"Only parallel input supported.\n"); "Only parallel input supported.\n");
ret = -EINVAL; ret = -EINVAL;
goto error_put_node; goto error_cleanup;
} }
/* Setup the ceu subdevice and the async subdevice. */ /* Setup the ceu subdevice and the async subdevice. */
ceu_sd = &ceudev->subdevs[i]; ceu_sd = &ceudev->subdevs[i];
INIT_LIST_HEAD(&ceu_sd->asd.list); INIT_LIST_HEAD(&ceu_sd->asd.list);
remote = of_graph_get_remote_port_parent(ep);
ceu_sd->mbus_flags = fw_ep.bus.parallel.flags; ceu_sd->mbus_flags = fw_ep.bus.parallel.flags;
ceu_sd->asd.match_type = V4L2_ASYNC_MATCH_FWNODE; ceu_sd->asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
ceu_sd->asd.match.fwnode = ceu_sd->asd.match.fwnode = of_fwnode_handle(remote);
fwnode_graph_get_remote_port_parent(
of_fwnode_handle(ep)); ret = v4l2_async_notifier_add_subdev(&ceudev->notifier,
&ceu_sd->asd);
if (ret) {
of_node_put(remote);
goto error_cleanup;
}
ceudev->asds[i] = &ceu_sd->asd;
of_node_put(ep); of_node_put(ep);
} }
return num_ep; return num_ep;
error_put_node: error_cleanup:
v4l2_async_notifier_cleanup(&ceudev->notifier);
of_node_put(ep); of_node_put(ep);
return ret; return ret;
} }
...@@ -1674,6 +1675,8 @@ static int ceu_probe(struct platform_device *pdev) ...@@ -1674,6 +1675,8 @@ static int ceu_probe(struct platform_device *pdev)
if (ret) if (ret)
goto error_pm_disable; goto error_pm_disable;
v4l2_async_notifier_init(&ceudev->notifier);
if (IS_ENABLED(CONFIG_OF) && dev->of_node) { if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
ceu_data = of_match_device(ceu_of_match, dev)->data; ceu_data = of_match_device(ceu_of_match, dev)->data;
num_subdevs = ceu_parse_dt(ceudev); num_subdevs = ceu_parse_dt(ceudev);
...@@ -1693,18 +1696,18 @@ static int ceu_probe(struct platform_device *pdev) ...@@ -1693,18 +1696,18 @@ static int ceu_probe(struct platform_device *pdev)
ceudev->irq_mask = ceu_data->irq_mask; ceudev->irq_mask = ceu_data->irq_mask;
ceudev->notifier.v4l2_dev = &ceudev->v4l2_dev; ceudev->notifier.v4l2_dev = &ceudev->v4l2_dev;
ceudev->notifier.subdevs = ceudev->asds;
ceudev->notifier.num_subdevs = num_subdevs;
ceudev->notifier.ops = &ceu_notify_ops; ceudev->notifier.ops = &ceu_notify_ops;
ret = v4l2_async_notifier_register(&ceudev->v4l2_dev, ret = v4l2_async_notifier_register(&ceudev->v4l2_dev,
&ceudev->notifier); &ceudev->notifier);
if (ret) if (ret)
goto error_v4l2_unregister; goto error_cleanup;
dev_info(dev, "Renesas Capture Engine Unit %s\n", dev_name(dev)); dev_info(dev, "Renesas Capture Engine Unit %s\n", dev_name(dev));
return 0; return 0;
error_cleanup:
v4l2_async_notifier_cleanup(&ceudev->notifier);
error_v4l2_unregister: error_v4l2_unregister:
v4l2_device_unregister(&ceudev->v4l2_dev); v4l2_device_unregister(&ceudev->v4l2_dev);
error_pm_disable: error_pm_disable:
...@@ -1723,6 +1726,8 @@ static int ceu_remove(struct platform_device *pdev) ...@@ -1723,6 +1726,8 @@ static int ceu_remove(struct platform_device *pdev)
v4l2_async_notifier_unregister(&ceudev->notifier); v4l2_async_notifier_unregister(&ceudev->notifier);
v4l2_async_notifier_cleanup(&ceudev->notifier);
v4l2_device_unregister(&ceudev->v4l2_dev); v4l2_device_unregister(&ceudev->v4l2_dev);
video_unregister_device(&ceudev->vdev); video_unregister_device(&ceudev->vdev);
......
...@@ -1442,8 +1442,14 @@ static int scan_async_group(struct soc_camera_host *ici, ...@@ -1442,8 +1442,14 @@ static int scan_async_group(struct soc_camera_host *ici,
goto eaddpdev; goto eaddpdev;
} }
sasc->notifier.subdevs = asd; v4l2_async_notifier_init(&sasc->notifier);
sasc->notifier.num_subdevs = size;
for (i = 0; i < size; i++) {
ret = v4l2_async_notifier_add_subdev(&sasc->notifier, asd[i]);
if (ret)
goto eaddasd;
}
sasc->notifier.ops = &soc_camera_async_ops; sasc->notifier.ops = &soc_camera_async_ops;
icd->sasc = sasc; icd->sasc = sasc;
...@@ -1466,6 +1472,8 @@ static int scan_async_group(struct soc_camera_host *ici, ...@@ -1466,6 +1472,8 @@ static int scan_async_group(struct soc_camera_host *ici,
v4l2_clk_unregister(icd->clk); v4l2_clk_unregister(icd->clk);
eclkreg: eclkreg:
icd->clk = NULL; icd->clk = NULL;
eaddasd:
v4l2_async_notifier_cleanup(&sasc->notifier);
platform_device_del(sasc->pdev); platform_device_del(sasc->pdev);
eaddpdev: eaddpdev:
platform_device_put(sasc->pdev); platform_device_put(sasc->pdev);
...@@ -1540,8 +1548,14 @@ static int soc_of_bind(struct soc_camera_host *ici, ...@@ -1540,8 +1548,14 @@ static int soc_of_bind(struct soc_camera_host *ici,
goto eaddpdev; goto eaddpdev;
} }
sasc->notifier.subdevs = &info->subdev; v4l2_async_notifier_init(&sasc->notifier);
sasc->notifier.num_subdevs = 1;
ret = v4l2_async_notifier_add_subdev(&sasc->notifier, info->subdev);
if (ret) {
of_node_put(remote);
goto eaddasd;
}
sasc->notifier.ops = &soc_camera_async_ops; sasc->notifier.ops = &soc_camera_async_ops;
icd->sasc = sasc; icd->sasc = sasc;
...@@ -1568,6 +1582,8 @@ static int soc_of_bind(struct soc_camera_host *ici, ...@@ -1568,6 +1582,8 @@ static int soc_of_bind(struct soc_camera_host *ici,
v4l2_clk_unregister(icd->clk); v4l2_clk_unregister(icd->clk);
eclkreg: eclkreg:
icd->clk = NULL; icd->clk = NULL;
eaddasd:
v4l2_async_notifier_cleanup(&sasc->notifier);
platform_device_del(sasc->pdev); platform_device_del(sasc->pdev);
eaddpdev: eaddpdev:
platform_device_put(sasc->pdev); platform_device_put(sasc->pdev);
...@@ -1582,7 +1598,7 @@ static void scan_of_host(struct soc_camera_host *ici) ...@@ -1582,7 +1598,7 @@ static void scan_of_host(struct soc_camera_host *ici)
{ {
struct device *dev = ici->v4l2_dev.dev; struct device *dev = ici->v4l2_dev.dev;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
struct device_node *epn = NULL, *ren; struct device_node *epn = NULL, *rem;
unsigned int i; unsigned int i;
for (i = 0; ; i++) { for (i = 0; ; i++) {
...@@ -1590,17 +1606,15 @@ static void scan_of_host(struct soc_camera_host *ici) ...@@ -1590,17 +1606,15 @@ static void scan_of_host(struct soc_camera_host *ici)
if (!epn) if (!epn)
break; break;
ren = of_graph_get_remote_port(epn); rem = of_graph_get_remote_port_parent(epn);
if (!ren) { if (!rem) {
dev_notice(dev, "no remote for %pOF\n", epn); dev_notice(dev, "no remote for %pOF\n", epn);
continue; continue;
} }
/* so we now have a remote node to connect */ /* so we now have a remote node to connect */
if (!i) if (!i)
soc_of_bind(ici, epn, ren->parent); soc_of_bind(ici, epn, rem);
of_node_put(ren);
if (i) { if (i) {
dev_err(dev, "multiple subdevices aren't supported yet!\n"); dev_err(dev, "multiple subdevices aren't supported yet!\n");
...@@ -1926,6 +1940,7 @@ void soc_camera_host_unregister(struct soc_camera_host *ici) ...@@ -1926,6 +1940,7 @@ void soc_camera_host_unregister(struct soc_camera_host *ici)
list_for_each_entry(sasc, &notifiers, list) { list_for_each_entry(sasc, &notifiers, list) {
/* Must call unlocked to avoid AB-BA dead-lock */ /* Must call unlocked to avoid AB-BA dead-lock */
v4l2_async_notifier_unregister(&sasc->notifier); v4l2_async_notifier_unregister(&sasc->notifier);
v4l2_async_notifier_cleanup(&sasc->notifier);
put_device(&sasc->pdev->dev); put_device(&sasc->pdev->dev);
} }
......
...@@ -1590,7 +1590,6 @@ static int dcmi_graph_parse(struct stm32_dcmi *dcmi, struct device_node *node) ...@@ -1590,7 +1590,6 @@ static int dcmi_graph_parse(struct stm32_dcmi *dcmi, struct device_node *node)
static int dcmi_graph_init(struct stm32_dcmi *dcmi) static int dcmi_graph_init(struct stm32_dcmi *dcmi)
{ {
struct v4l2_async_subdev **subdevs = NULL;
int ret; int ret;
/* Parse the graph to extract a list of subdevice DT nodes. */ /* Parse the graph to extract a list of subdevice DT nodes. */
...@@ -1600,23 +1599,21 @@ static int dcmi_graph_init(struct stm32_dcmi *dcmi) ...@@ -1600,23 +1599,21 @@ static int dcmi_graph_init(struct stm32_dcmi *dcmi)
return ret; return ret;
} }
/* Register the subdevices notifier. */ v4l2_async_notifier_init(&dcmi->notifier);
subdevs = devm_kzalloc(dcmi->dev, sizeof(*subdevs), GFP_KERNEL);
if (!subdevs) { ret = v4l2_async_notifier_add_subdev(&dcmi->notifier,
&dcmi->entity.asd);
if (ret) {
of_node_put(dcmi->entity.node); of_node_put(dcmi->entity.node);
return -ENOMEM; return ret;
} }
subdevs[0] = &dcmi->entity.asd;
dcmi->notifier.subdevs = subdevs;
dcmi->notifier.num_subdevs = 1;
dcmi->notifier.ops = &dcmi_graph_notify_ops; dcmi->notifier.ops = &dcmi_graph_notify_ops;
ret = v4l2_async_notifier_register(&dcmi->v4l2_dev, &dcmi->notifier); ret = v4l2_async_notifier_register(&dcmi->v4l2_dev, &dcmi->notifier);
if (ret < 0) { if (ret < 0) {
dev_err(dcmi->dev, "Notifier registration failed\n"); dev_err(dcmi->dev, "Notifier registration failed\n");
of_node_put(dcmi->entity.node); v4l2_async_notifier_cleanup(&dcmi->notifier);
return ret; return ret;
} }
...@@ -1773,7 +1770,7 @@ static int dcmi_probe(struct platform_device *pdev) ...@@ -1773,7 +1770,7 @@ static int dcmi_probe(struct platform_device *pdev)
ret = reset_control_assert(dcmi->rstc); ret = reset_control_assert(dcmi->rstc);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Failed to assert the reset line\n"); dev_err(&pdev->dev, "Failed to assert the reset line\n");
goto err_device_release; goto err_cleanup;
} }
usleep_range(3000, 5000); usleep_range(3000, 5000);
...@@ -1781,7 +1778,7 @@ static int dcmi_probe(struct platform_device *pdev) ...@@ -1781,7 +1778,7 @@ static int dcmi_probe(struct platform_device *pdev)
ret = reset_control_deassert(dcmi->rstc); ret = reset_control_deassert(dcmi->rstc);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Failed to deassert the reset line\n"); dev_err(&pdev->dev, "Failed to deassert the reset line\n");
goto err_device_release; goto err_cleanup;
} }
dev_info(&pdev->dev, "Probe done\n"); dev_info(&pdev->dev, "Probe done\n");
...@@ -1792,6 +1789,8 @@ static int dcmi_probe(struct platform_device *pdev) ...@@ -1792,6 +1789,8 @@ static int dcmi_probe(struct platform_device *pdev)
return 0; return 0;
err_cleanup:
v4l2_async_notifier_cleanup(&dcmi->notifier);
err_device_release: err_device_release:
video_device_release(dcmi->vdev); video_device_release(dcmi->vdev);
err_device_unregister: err_device_unregister:
...@@ -1809,6 +1808,7 @@ static int dcmi_remove(struct platform_device *pdev) ...@@ -1809,6 +1808,7 @@ static int dcmi_remove(struct platform_device *pdev)
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
v4l2_async_notifier_unregister(&dcmi->notifier); v4l2_async_notifier_unregister(&dcmi->notifier);
v4l2_async_notifier_cleanup(&dcmi->notifier);
v4l2_device_unregister(&dcmi->v4l2_dev); v4l2_device_unregister(&dcmi->v4l2_dev);
dma_release_channel(dcmi->dma_chan); dma_release_channel(dcmi->dma_chan);
......
...@@ -270,7 +270,6 @@ struct cal_ctx { ...@@ -270,7 +270,6 @@ struct cal_ctx {
struct v4l2_fwnode_endpoint endpoint; struct v4l2_fwnode_endpoint endpoint;
struct v4l2_async_subdev asd; struct v4l2_async_subdev asd;
struct v4l2_async_subdev *asd_list[1];
struct v4l2_fh fh; struct v4l2_fh fh;
struct cal_dev *dev; struct cal_dev *dev;
...@@ -1735,17 +1734,30 @@ static int of_cal_create_instance(struct cal_ctx *ctx, int inst) ...@@ -1735,17 +1734,30 @@ static int of_cal_create_instance(struct cal_ctx *ctx, int inst)
ctx_dbg(1, ctx, "Port: %d found sub-device %pOFn\n", ctx_dbg(1, ctx, "Port: %d found sub-device %pOFn\n",
inst, sensor_node); inst, sensor_node);
ctx->asd_list[0] = asd; v4l2_async_notifier_init(&ctx->notifier);
ctx->notifier.subdevs = ctx->asd_list;
ctx->notifier.num_subdevs = 1; ret = v4l2_async_notifier_add_subdev(&ctx->notifier, asd);
if (ret) {
ctx_err(ctx, "Error adding asd\n");
goto cleanup_exit;
}
ctx->notifier.ops = &cal_async_ops; ctx->notifier.ops = &cal_async_ops;
ret = v4l2_async_notifier_register(&ctx->v4l2_dev, ret = v4l2_async_notifier_register(&ctx->v4l2_dev,
&ctx->notifier); &ctx->notifier);
if (ret) { if (ret) {
ctx_err(ctx, "Error registering async notifier\n"); ctx_err(ctx, "Error registering async notifier\n");
v4l2_async_notifier_cleanup(&ctx->notifier);
ret = -EINVAL; ret = -EINVAL;
} }
/*
* On success we need to keep reference on sensor_node, or
* if notifier_cleanup was called above, sensor_node was
* already put.
*/
sensor_node = NULL;
cleanup_exit: cleanup_exit:
of_node_put(remote_ep); of_node_put(remote_ep);
of_node_put(sensor_node); of_node_put(sensor_node);
...@@ -1806,8 +1818,10 @@ static struct cal_ctx *cal_create_instance(struct cal_dev *dev, int inst) ...@@ -1806,8 +1818,10 @@ static struct cal_ctx *cal_create_instance(struct cal_dev *dev, int inst)
static int cal_probe(struct platform_device *pdev) static int cal_probe(struct platform_device *pdev)
{ {
struct cal_dev *dev; struct cal_dev *dev;
struct cal_ctx *ctx;
int ret; int ret;
int irq; int irq;
int i;
dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL); dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
if (!dev) if (!dev)
...@@ -1875,6 +1889,16 @@ static int cal_probe(struct platform_device *pdev) ...@@ -1875,6 +1889,16 @@ static int cal_probe(struct platform_device *pdev)
runtime_disable: runtime_disable:
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
for (i = 0; i < CAL_NUM_CONTEXT; i++) {
ctx = dev->ctx[i];
if (ctx) {
v4l2_async_notifier_unregister(&ctx->notifier);
v4l2_async_notifier_cleanup(&ctx->notifier);
v4l2_ctrl_handler_free(&ctx->ctrl_handler);
v4l2_device_unregister(&ctx->v4l2_dev);
}
}
return ret; return ret;
} }
...@@ -1896,6 +1920,7 @@ static int cal_remove(struct platform_device *pdev) ...@@ -1896,6 +1920,7 @@ static int cal_remove(struct platform_device *pdev)
video_device_node_name(&ctx->vdev)); video_device_node_name(&ctx->vdev));
camerarx_phy_disable(ctx); camerarx_phy_disable(ctx);
v4l2_async_notifier_unregister(&ctx->notifier); v4l2_async_notifier_unregister(&ctx->notifier);
v4l2_async_notifier_cleanup(&ctx->notifier);
v4l2_ctrl_handler_free(&ctx->ctrl_handler); v4l2_ctrl_handler_free(&ctx->ctrl_handler);
v4l2_device_unregister(&ctx->v4l2_dev); v4l2_device_unregister(&ctx->v4l2_dev);
video_unregister_device(&ctx->vdev); video_unregister_device(&ctx->vdev);
......
This diff is collapsed.
...@@ -28,8 +28,6 @@ ...@@ -28,8 +28,6 @@
* @media_dev: media device * @media_dev: media device
* @dev: (OF) device * @dev: (OF) device
* @notifier: V4L2 asynchronous subdevs notifier * @notifier: V4L2 asynchronous subdevs notifier
* @entities: entities in the graph as a list of xvip_graph_entity
* @num_subdevs: number of subdevs in the pipeline
* @dmas: list of DMA channels at the pipeline output and input * @dmas: list of DMA channels at the pipeline output and input
* @v4l2_caps: V4L2 capabilities of the whole device (see VIDIOC_QUERYCAP) * @v4l2_caps: V4L2 capabilities of the whole device (see VIDIOC_QUERYCAP)
*/ */
...@@ -39,8 +37,6 @@ struct xvip_composite_device { ...@@ -39,8 +37,6 @@ struct xvip_composite_device {
struct device *dev; struct device *dev;
struct v4l2_async_notifier notifier; struct v4l2_async_notifier notifier;
struct list_head entities;
unsigned int num_subdevs;
struct list_head dmas; struct list_head dmas;
u32 v4l2_caps; u32 v4l2_caps;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment