drivers/gpu/drm/omapdrm/displays/panel-dpi.c

   1 /*
   2  * Generic MIPI DPI Panel Driver
   3  *
   4  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
   5  * Author: Tomi Valkeinen <[email protected]>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published by
   9  * the Free Software Foundation.
  10  */
  11
  12 #include <linux/gpio/consumer.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/slab.h>
  16 #include <linux/of.h>
  17 #include <linux/regulator/consumer.h>
  18 #include <linux/backlight.h>
  19
  20 #include <video/of_display_timing.h>
  21
  22 #include "../dss/omapdss.h"
  23
  24 struct panel_drv_data {
  25         struct omap_dss_device dssdev;
  26
  27         struct videomode vm;
  28
  29         struct backlight_device *backlight;
  30
  31         struct gpio_desc *enable_gpio;
  32         struct regulator *vcc_supply;
  33 };
  34
  35 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)
  36
  37 static int panel_dpi_connect(struct omap_dss_device *src,
  38                              struct omap_dss_device *dst)
  39 {
  40         return 0;
  41 }
  42
  43 static void panel_dpi_disconnect(struct omap_dss_device *src,
  44                                  struct omap_dss_device *dst)
  45 {
  46 }
  47
  48 static int panel_dpi_enable(struct omap_dss_device *dssdev)
  49 {
  50         struct panel_drv_data *ddata = to_panel_data(dssdev);
  51         struct omap_dss_device *src = dssdev->src;
  52         int r;
  53
  54         if (!omapdss_device_is_connected(dssdev))
  55                 return -ENODEV;
  56
  57         if (omapdss_device_is_enabled(dssdev))
  58                 return 0;
  59
  60         r = src->ops->enable(src);
  61         if (r)
  62                 return r;
  63
  64         r = regulator_enable(ddata->vcc_supply);
  65         if (r) {
  66                 src->ops->disable(src);
  67                 return r;
  68         }
  69
  70         gpiod_set_value_cansleep(ddata->enable_gpio, 1);
  71         backlight_enable(ddata->backlight);
  72
  73         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
  74
  75         return 0;
  76 }
  77
  78 static void panel_dpi_disable(struct omap_dss_device *dssdev)
  79 {
  80         struct panel_drv_data *ddata = to_panel_data(dssdev);
  81         struct omap_dss_device *src = dssdev->src;
  82
  83         if (!omapdss_device_is_enabled(dssdev))
  84                 return;
  85
  86         backlight_disable(ddata->backlight);
  87
  88         gpiod_set_value_cansleep(ddata->enable_gpio, 0);
  89         regulator_disable(ddata->vcc_supply);
  90
  91         src->ops->disable(src);
  92
  93         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
  94 }
  95
  96 static void panel_dpi_get_timings(struct omap_dss_device *dssdev,
  97                                   struct videomode *vm)
  98 {
  99         struct panel_drv_data *ddata = to_panel_data(dssdev);
 100
 101         *vm = ddata->vm;
 102 }
 103
 104 static const struct omap_dss_device_ops panel_dpi_ops = {
 105         .connect        = panel_dpi_connect,
 106         .disconnect     = panel_dpi_disconnect,
 107
 108         .enable         = panel_dpi_enable,
 109         .disable        = panel_dpi_disable,
 110
 111         .get_timings    = panel_dpi_get_timings,
 112 };
 113
 114 static int panel_dpi_probe_of(struct platform_device *pdev)
 115 {
 116         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 117         struct device_node *node = pdev->dev.of_node;
 118         int r;
 119         struct display_timing timing;
 120         struct gpio_desc *gpio;
 121
 122         gpio = devm_gpiod_get_optional(&pdev->dev, "enable", GPIOD_OUT_LOW);
 123         if (IS_ERR(gpio))
 124                 return PTR_ERR(gpio);
 125
 126         ddata->enable_gpio = gpio;
 127
 128         /*
 129          * Many different panels are supported by this driver and there are
 130          * probably very different needs for their reset pins in regards to
 131          * timing and order relative to the enable gpio. So for now it's just
 132          * ensured that the reset line isn't active.
 133          */
 134         gpio = devm_gpiod_get_optional(&pdev->dev, "reset", GPIOD_OUT_LOW);
 135         if (IS_ERR(gpio))
 136                 return PTR_ERR(gpio);
 137
 138         ddata->vcc_supply = devm_regulator_get(&pdev->dev, "vcc");
 139         if (IS_ERR(ddata->vcc_supply))
 140                 return PTR_ERR(ddata->vcc_supply);
 141
 142         ddata->backlight = devm_of_find_backlight(&pdev->dev);
 143
 144         if (IS_ERR(ddata->backlight))
 145                 return PTR_ERR(ddata->backlight);
 146
 147         r = of_get_display_timing(node, "panel-timing", &timing);
 148         if (r) {
 149                 dev_err(&pdev->dev, "failed to get video timing\n");
 150                 return r;
 151         }
 152
 153         videomode_from_timing(&timing, &ddata->vm);
 154
 155         return 0;
 156 }
 157
 158 static int panel_dpi_probe(struct platform_device *pdev)
 159 {
 160         struct panel_drv_data *ddata;
 161         struct omap_dss_device *dssdev;
 162         int r;
 163
 164         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 165         if (ddata == NULL)
 166                 return -ENOMEM;
 167
 168         platform_set_drvdata(pdev, ddata);
 169
 170         r = panel_dpi_probe_of(pdev);
 171         if (r)
 172                 return r;
 173
 174         dssdev = &ddata->dssdev;
 175         dssdev->dev = &pdev->dev;
 176         dssdev->ops = &panel_dpi_ops;
 177         dssdev->type = OMAP_DISPLAY_TYPE_DPI;
 178         dssdev->owner = THIS_MODULE;
 179         dssdev->of_ports = BIT(0);
 180         drm_bus_flags_from_videomode(&ddata->vm, &dssdev->bus_flags);
 181
 182         omapdss_display_init(dssdev);
 183         omapdss_device_register(dssdev);
 184
 185         return 0;
 186 }
 187
 188 static int __exit panel_dpi_remove(struct platform_device *pdev)
 189 {
 190         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 191         struct omap_dss_device *dssdev = &ddata->dssdev;
 192
 193         omapdss_device_unregister(dssdev);
 194
 195         panel_dpi_disable(dssdev);
 196
 197         return 0;
 198 }
 199
 200 static const struct of_device_id panel_dpi_of_match[] = {
 201         { .compatible = "omapdss,panel-dpi", },
 202         {},
 203 };
 204
 205 MODULE_DEVICE_TABLE(of, panel_dpi_of_match);
 206
 207 static struct platform_driver panel_dpi_driver = {
 208         .probe = panel_dpi_probe,
 209         .remove = __exit_p(panel_dpi_remove),
 210         .driver = {
 211                 .name = "panel-dpi",
 212                 .of_match_table = panel_dpi_of_match,
 213                 .suppress_bind_attrs = true,
 214         },
 215 };
 216
 217 module_platform_driver(panel_dpi_driver);
 218
 219 MODULE_AUTHOR("Tomi Valkeinen <[email protected]>");
 220 MODULE_DESCRIPTION("Generic MIPI DPI Panel Driver");
 221 MODULE_LICENSE("GPL");