Merge tag 'fbdev-4.5' of git://git.kernel.org/pub/scm/linux/kernel/git/tomba/linux

Pull fbdev updates from Tomi Valkeinen:
 "Summary:

   - pxafb: device-tree support
   - An unsafe kernel parameter 'lockless_register_fb' for debugging
     problems happening while inside the console lock
   - Small miscellaneous fixes & cleanups
   - omapdss: add writeback support functions
   - Separation of omapfb and omapdrm (see below)

  About the separation of omapfb and omapdrm, see

    http://permalink.gmane.org/gmane.comp.video.dri.devel/143151

  for longer story.  The short version:

  omapfb and omapdrm have shared low level drivers (omapdss and panel
  drivers), making further development of omapdrm difficult.  After
  these patches omapfb and omapdrm have their own versions of the
  drivers, which are more or less direct copies for now but will diverge
  soon.

  This also means that omapfb (everything under drivers/video/fbdev/omap2/)
  is now in maintenance mode, and all new development will be done for
  omapdrm (drivers/gpu/drm/omapdrm/)"

* tag 'fbdev-4.5' of git://git.kernel.org/pub/scm/linux/kernel/git/tomba/linux: (49 commits)
  video: fbdev: pxafb: fix out of memory error path
  drm/omap: make omapdrm select OMAP2_DSS
  drm/omap: move omapdss & displays under omapdrm
  omapfb: move vrfb into omapfb
  omapfb: take omapfb's private omapdss into use
  omapfb/displays: change CONFIG_DISPLAY_* to CONFIG_FB_OMAP2_*
  omapfb/dss: change CONFIG_OMAP* to CONFIG_FB_OMAP*
  omapdss: remove CONFIG_OMAP2_DSS_VENC from omapdss.h
  omapfb: copy omapdss & displays for omapfb
  omapfb: allow compilation only if DRM_OMAP is disabled
  fbdev: omap2: panel-dpi: simplify gpio setting
  fbdev: omap2: panel-dpi: in .disable first disable backlight then display
  OMAPDSS: DSS: fix a warning message
  video: omapdss: delete unneeded of_node_put
  OMAPDSS: DISPC: Remove boolean comparisons
  OMAPDSS: DSI: cleanup DSI_IRQ_ERROR_MASK define
  OMAPDSS: remove extra out == NULL checks
  OMAPDSS: change internal dispc functions to static
  OMAPDSS: make a two dss feat funcs internal to omapdss
  OMAPDSS: remove extra EXPORT_SYMBOLs
  ...

1 files changed, 320 insertions, 0 deletions

diff --git a/drivers/gpu/drm/omapdrm/displays/encoder-tfp410.c b/drivers/gpu/drm/omapdrm/displays/encoder-tfp410.c
new file mode 100644
index 000000000000..d9048b3df495
--- /dev/null
+++ b/drivers/gpu/drm/omapdrm/displays/encoder-tfp410.c
@@ -0,0 +1,320 @@
+/*
+ * TFP410 DPI-to-DVI encoder driver
+ *
+ * Copyright (C) 2013 Texas Instruments
+ * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+
+#include <linux/gpio.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/of_gpio.h>
+
+#include <video/omapdss.h>
+#include <video/omap-panel-data.h>
+
+struct panel_drv_data {
+        struct omap_dss_device dssdev;
+        struct omap_dss_device *in;
+
+        int pd_gpio;
+        int data_lines;
+
+        struct omap_video_timings timings;
+};
+
+#define to_panel_data(x) container_of(x, struct panel_drv_data, dssdev)
+
+static int tfp410_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;
+
+        if (omapdss_device_is_connected(dssdev))
+                return -EBUSY;
+
+        r = in->ops.dpi->connect(in, dssdev);
+        if (r)
+                return r;
+
+        dst->src = dssdev;
+        dssdev->dst = dst;
+
+        return 0;
+}
+
+static void tfp410_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;
+
+        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.dpi->disconnect(in, &ddata->dssdev);
+}
+
+static int tfp410_enable(struct omap_dss_device *dssdev)
+{
+        struct panel_drv_data *ddata = to_panel_data(dssdev);
+        struct omap_dss_device *in = ddata->in;
+        int r;
+
+        if (!omapdss_device_is_connected(dssdev))
+                return -ENODEV;
+
+        if (omapdss_device_is_enabled(dssdev))
+                return 0;
+
+        in->ops.dpi->set_timings(in, &ddata->timings);
+        if (ddata->data_lines)
+                in->ops.dpi->set_data_lines(in, ddata->data_lines);
+
+        r = in->ops.dpi->enable(in);
+        if (r)
+                return r;
+
+        if (gpio_is_valid(ddata->pd_gpio))
+                gpio_set_value_cansleep(ddata->pd_gpio, 1);
+
+        dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
+
+        return 0;
+}
+
+static void tfp410_disable(struct omap_dss_device *dssdev)
+{
+        struct panel_drv_data *ddata = to_panel_data(dssdev);
+        struct omap_dss_device *in = ddata->in;
+
+        if (!omapdss_device_is_enabled(dssdev))
+                return;
+
+        if (gpio_is_valid(ddata->pd_gpio))
+                gpio_set_value_cansleep(ddata->pd_gpio, 0);
+
+        in->ops.dpi->disable(in);
+
+        dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
+}
+
+static void tfp410_fix_timings(struct omap_video_timings *timings)
+{
+        timings->data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
+        timings->sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
+        timings->de_level = OMAPDSS_SIG_ACTIVE_HIGH;
+}
+
+static void tfp410_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;
+
+        tfp410_fix_timings(timings);
+
+        ddata->timings = *timings;
+        dssdev->panel.timings = *timings;
+
+        in->ops.dpi->set_timings(in, timings);
+}
+
+static void tfp410_get_timings(struct omap_dss_device *dssdev,
+                struct omap_video_timings *timings)
+{
+        struct panel_drv_data *ddata = to_panel_data(dssdev);
+
+        *timings = ddata->timings;
+}
+
+static int tfp410_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;
+
+        tfp410_fix_timings(timings);
+
+        return in->ops.dpi->check_timings(in, timings);
+}
+
+static const struct omapdss_dvi_ops tfp410_dvi_ops = {
+        .connect        = tfp410_connect,
+        .disconnect     = tfp410_disconnect,
+
+        .enable         = tfp410_enable,
+        .disable        = tfp410_disable,
+
+        .check_timings  = tfp410_check_timings,
+        .set_timings    = tfp410_set_timings,
+        .get_timings    = tfp410_get_timings,
+};
+
+static int tfp410_probe_pdata(struct platform_device *pdev)
+{
+        struct panel_drv_data *ddata = platform_get_drvdata(pdev);
+        struct encoder_tfp410_platform_data *pdata;
+        struct omap_dss_device *dssdev, *in;
+
+        pdata = dev_get_platdata(&pdev->dev);
+
+        ddata->pd_gpio = pdata->power_down_gpio;
+
+        ddata->data_lines = pdata->data_lines;
+
+        in = omap_dss_find_output(pdata->source);
+        if (in == NULL) {
+                dev_err(&pdev->dev, "Failed to find video source\n");
+                return -ENODEV;
+        }
+
+        ddata->in = in;
+
+        dssdev = &ddata->dssdev;
+        dssdev->name = pdata->name;
+
+        return 0;
+}
+
+static int tfp410_probe_of(struct platform_device *pdev)
+{
+        struct panel_drv_data *ddata = platform_get_drvdata(pdev);
+        struct device_node *node = pdev->dev.of_node;
+        struct omap_dss_device *in;
+        int gpio;
+
+        gpio = of_get_named_gpio(node, "powerdown-gpios", 0);
+
+        if (gpio_is_valid(gpio) || gpio == -ENOENT) {
+                ddata->pd_gpio = gpio;
+        } else {
+                dev_err(&pdev->dev, "failed to parse PD gpio\n");
+                return 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;
+
+        return 0;
+}
+
+static int tfp410_probe(struct platform_device *pdev)
+{
+        struct panel_drv_data *ddata;
+        struct omap_dss_device *dssdev;
+        int r;
+
+        ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
+        if (!ddata)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, ddata);
+
+        if (dev_get_platdata(&pdev->dev)) {
+                r = tfp410_probe_pdata(pdev);
+                if (r)
+                        return r;
+        } else if (pdev->dev.of_node) {
+                r = tfp410_probe_of(pdev);
+                if (r)
+                        return r;
+        } else {
+                return -ENODEV;
+        }
+
+        if (gpio_is_valid(ddata->pd_gpio)) {
+                r = devm_gpio_request_one(&pdev->dev, ddata->pd_gpio,
+                                GPIOF_OUT_INIT_LOW, "tfp410 PD");
+                if (r) {
+                        dev_err(&pdev->dev, "Failed to request PD GPIO %d\n",
+                                        ddata->pd_gpio);
+                        goto err_gpio;
+                }
+        }
+
+        dssdev = &ddata->dssdev;
+        dssdev->ops.dvi = &tfp410_dvi_ops;
+        dssdev->dev = &pdev->dev;
+        dssdev->type = OMAP_DISPLAY_TYPE_DPI;
+        dssdev->output_type = OMAP_DISPLAY_TYPE_DVI;
+        dssdev->owner = THIS_MODULE;
+        dssdev->phy.dpi.data_lines = ddata->data_lines;
+        dssdev->port_num = 1;
+
+        r = omapdss_register_output(dssdev);
+        if (r) {
+                dev_err(&pdev->dev, "Failed to register output\n");
+                goto err_reg;
+        }
+
+        return 0;
+err_reg:
+err_gpio:
+        omap_dss_put_device(ddata->in);
+        return r;
+}
+
+static int __exit tfp410_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))
+                tfp410_disable(dssdev);
+
+        WARN_ON(omapdss_device_is_connected(dssdev));
+        if (omapdss_device_is_connected(dssdev))
+                tfp410_disconnect(dssdev, dssdev->dst);
+
+        omap_dss_put_device(in);
+
+        return 0;
+}
+
+static const struct of_device_id tfp410_of_match[] = {
+        { .compatible = "omapdss,ti,tfp410", },
+        {},
+};
+
+MODULE_DEVICE_TABLE(of, tfp410_of_match);
+
+static struct platform_driver tfp410_driver = {
+        .probe  = tfp410_probe,
+        .remove = __exit_p(tfp410_remove),
+        .driver = {
+                .name   = "tfp410",
+                .of_match_table = tfp410_of_match,
+                .suppress_bind_attrs = true,
+        },
+};
+
+module_platform_driver(tfp410_driver);
+
+MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
+MODULE_DESCRIPTION("TFP410 DPI to DVI encoder driver");
+MODULE_LICENSE("GPL");