mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-08-05 16:54:27 +00:00
01ecc142ef
After commit 0edb555a65 ("platform: Make platform_driver::remove()
return void") .remove() is (again) the right callback to implement for
platform drivers.
Convert all platform drivers below drivers/video/fbdev to use .remove(),
with the eventual goal to drop struct platform_driver::remove_new(). As
.remove() and .remove_new() have the same prototypes, conversion is done
by just changing the structure member name in the driver initializer.
While touching these files, make indention of the struct initializer
consistent in several files.
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
Reviewed-by: Thomas Zimmermann <tzimmermann@suse.de>
Signed-off-by: Helge Deller <deller@gmx.de>
272 lines
6.1 KiB
C
272 lines
6.1 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* OPA362 analog video amplifier with output/power control
|
|
*
|
|
* Copyright (C) 2014 Golden Delicious Computers
|
|
* Author: H. Nikolaus Schaller <hns@goldelico.com>
|
|
*
|
|
* based on encoder-tfp410
|
|
*
|
|
* Copyright (C) 2013 Texas Instruments
|
|
* Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
|
|
*/
|
|
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mod_devicetable.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <video/omapfb_dss.h>
|
|
|
|
struct panel_drv_data {
|
|
struct omap_dss_device dssdev;
|
|
struct omap_dss_device *in;
|
|
|
|
struct gpio_desc *enable_gpio;
|
|
|
|
struct omap_video_timings timings;
|
|
};
|
|
|
|
#define to_panel_data(x) container_of(x, struct panel_drv_data, dssdev)
|
|
|
|
static int opa362_connect(struct omap_dss_device *dssdev,
|
|
struct omap_dss_device *dst)
|
|
{
|
|
struct panel_drv_data *ddata = to_panel_data(dssdev);
|
|
struct omap_dss_device *in = ddata->in;
|
|
int r;
|
|
|
|
dev_dbg(dssdev->dev, "connect\n");
|
|
|
|
if (omapdss_device_is_connected(dssdev))
|
|
return -EBUSY;
|
|
|
|
r = in->ops.atv->connect(in, dssdev);
|
|
if (r)
|
|
return r;
|
|
|
|
dst->src = dssdev;
|
|
dssdev->dst = dst;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void opa362_disconnect(struct omap_dss_device *dssdev,
|
|
struct omap_dss_device *dst)
|
|
{
|
|
struct panel_drv_data *ddata = to_panel_data(dssdev);
|
|
struct omap_dss_device *in = ddata->in;
|
|
|
|
dev_dbg(dssdev->dev, "disconnect\n");
|
|
|
|
WARN_ON(!omapdss_device_is_connected(dssdev));
|
|
if (!omapdss_device_is_connected(dssdev))
|
|
return;
|
|
|
|
WARN_ON(dst != dssdev->dst);
|
|
if (dst != dssdev->dst)
|
|
return;
|
|
|
|
dst->src = NULL;
|
|
dssdev->dst = NULL;
|
|
|
|
in->ops.atv->disconnect(in, &ddata->dssdev);
|
|
}
|
|
|
|
static int opa362_enable(struct omap_dss_device *dssdev)
|
|
{
|
|
struct panel_drv_data *ddata = to_panel_data(dssdev);
|
|
struct omap_dss_device *in = ddata->in;
|
|
int r;
|
|
|
|
dev_dbg(dssdev->dev, "enable\n");
|
|
|
|
if (!omapdss_device_is_connected(dssdev))
|
|
return -ENODEV;
|
|
|
|
if (omapdss_device_is_enabled(dssdev))
|
|
return 0;
|
|
|
|
in->ops.atv->set_timings(in, &ddata->timings);
|
|
|
|
r = in->ops.atv->enable(in);
|
|
if (r)
|
|
return r;
|
|
|
|
if (ddata->enable_gpio)
|
|
gpiod_set_value_cansleep(ddata->enable_gpio, 1);
|
|
|
|
dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void opa362_disable(struct omap_dss_device *dssdev)
|
|
{
|
|
struct panel_drv_data *ddata = to_panel_data(dssdev);
|
|
struct omap_dss_device *in = ddata->in;
|
|
|
|
dev_dbg(dssdev->dev, "disable\n");
|
|
|
|
if (!omapdss_device_is_enabled(dssdev))
|
|
return;
|
|
|
|
if (ddata->enable_gpio)
|
|
gpiod_set_value_cansleep(ddata->enable_gpio, 0);
|
|
|
|
in->ops.atv->disable(in);
|
|
|
|
dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
|
|
}
|
|
|
|
static void opa362_set_timings(struct omap_dss_device *dssdev,
|
|
struct omap_video_timings *timings)
|
|
{
|
|
struct panel_drv_data *ddata = to_panel_data(dssdev);
|
|
struct omap_dss_device *in = ddata->in;
|
|
|
|
dev_dbg(dssdev->dev, "set_timings\n");
|
|
|
|
ddata->timings = *timings;
|
|
dssdev->panel.timings = *timings;
|
|
|
|
in->ops.atv->set_timings(in, timings);
|
|
}
|
|
|
|
static void opa362_get_timings(struct omap_dss_device *dssdev,
|
|
struct omap_video_timings *timings)
|
|
{
|
|
struct panel_drv_data *ddata = to_panel_data(dssdev);
|
|
|
|
dev_dbg(dssdev->dev, "get_timings\n");
|
|
|
|
*timings = ddata->timings;
|
|
}
|
|
|
|
static int opa362_check_timings(struct omap_dss_device *dssdev,
|
|
struct omap_video_timings *timings)
|
|
{
|
|
struct panel_drv_data *ddata = to_panel_data(dssdev);
|
|
struct omap_dss_device *in = ddata->in;
|
|
|
|
dev_dbg(dssdev->dev, "check_timings\n");
|
|
|
|
return in->ops.atv->check_timings(in, timings);
|
|
}
|
|
|
|
static void opa362_set_type(struct omap_dss_device *dssdev,
|
|
enum omap_dss_venc_type type)
|
|
{
|
|
/* we can only drive a COMPOSITE output */
|
|
WARN_ON(type != OMAP_DSS_VENC_TYPE_COMPOSITE);
|
|
|
|
}
|
|
|
|
static const struct omapdss_atv_ops opa362_atv_ops = {
|
|
.connect = opa362_connect,
|
|
.disconnect = opa362_disconnect,
|
|
|
|
.enable = opa362_enable,
|
|
.disable = opa362_disable,
|
|
|
|
.check_timings = opa362_check_timings,
|
|
.set_timings = opa362_set_timings,
|
|
.get_timings = opa362_get_timings,
|
|
|
|
.set_type = opa362_set_type,
|
|
};
|
|
|
|
static int opa362_probe(struct platform_device *pdev)
|
|
{
|
|
struct device_node *node = pdev->dev.of_node;
|
|
struct panel_drv_data *ddata;
|
|
struct omap_dss_device *dssdev, *in;
|
|
struct gpio_desc *gpio;
|
|
int r;
|
|
|
|
dev_dbg(&pdev->dev, "probe\n");
|
|
|
|
if (node == NULL) {
|
|
dev_err(&pdev->dev, "Unable to find device tree\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
|
|
if (!ddata)
|
|
return -ENOMEM;
|
|
|
|
platform_set_drvdata(pdev, ddata);
|
|
|
|
gpio = devm_gpiod_get_optional(&pdev->dev, "enable", GPIOD_OUT_LOW);
|
|
if (IS_ERR(gpio))
|
|
return PTR_ERR(gpio);
|
|
|
|
ddata->enable_gpio = gpio;
|
|
|
|
in = omapdss_of_find_source_for_first_ep(node);
|
|
if (IS_ERR(in)) {
|
|
dev_err(&pdev->dev, "failed to find video source\n");
|
|
return PTR_ERR(in);
|
|
}
|
|
|
|
ddata->in = in;
|
|
|
|
dssdev = &ddata->dssdev;
|
|
dssdev->ops.atv = &opa362_atv_ops;
|
|
dssdev->dev = &pdev->dev;
|
|
dssdev->type = OMAP_DISPLAY_TYPE_VENC;
|
|
dssdev->output_type = OMAP_DISPLAY_TYPE_VENC;
|
|
dssdev->owner = THIS_MODULE;
|
|
|
|
r = omapdss_register_output(dssdev);
|
|
if (r) {
|
|
dev_err(&pdev->dev, "Failed to register output\n");
|
|
goto err_reg;
|
|
}
|
|
|
|
return 0;
|
|
err_reg:
|
|
omap_dss_put_device(ddata->in);
|
|
return r;
|
|
}
|
|
|
|
static void opa362_remove(struct platform_device *pdev)
|
|
{
|
|
struct panel_drv_data *ddata = platform_get_drvdata(pdev);
|
|
struct omap_dss_device *dssdev = &ddata->dssdev;
|
|
struct omap_dss_device *in = ddata->in;
|
|
|
|
omapdss_unregister_output(&ddata->dssdev);
|
|
|
|
WARN_ON(omapdss_device_is_enabled(dssdev));
|
|
if (omapdss_device_is_enabled(dssdev))
|
|
opa362_disable(dssdev);
|
|
|
|
WARN_ON(omapdss_device_is_connected(dssdev));
|
|
if (omapdss_device_is_connected(dssdev))
|
|
opa362_disconnect(dssdev, dssdev->dst);
|
|
|
|
omap_dss_put_device(in);
|
|
}
|
|
|
|
static const struct of_device_id opa362_of_match[] = {
|
|
{ .compatible = "omapdss,ti,opa362", },
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, opa362_of_match);
|
|
|
|
static struct platform_driver opa362_driver = {
|
|
.probe = opa362_probe,
|
|
.remove = opa362_remove,
|
|
.driver = {
|
|
.name = "amplifier-opa362",
|
|
.of_match_table = opa362_of_match,
|
|
},
|
|
};
|
|
|
|
module_platform_driver(opa362_driver);
|
|
|
|
MODULE_AUTHOR("H. Nikolaus Schaller <hns@goldelico.com>");
|
|
MODULE_DESCRIPTION("OPA362 analog video amplifier with output/power control");
|
|
MODULE_LICENSE("GPL v2");
|