drivers/gpu/drm/omapdrm/displays/panel-sharp-ls037v7dw01.c

   1 /*
   2  * LCD panel driver for Sharp LS037V7DW01
   3  *
   4  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
   5  * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
   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/delay.h>
  13 #include <linux/gpio/consumer.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/slab.h>
  18 #include <linux/regulator/consumer.h>
  19
  20 #include "../dss/omapdss.h"
  21
  22 struct panel_drv_data {
  23         struct omap_dss_device dssdev;
  24         struct regulator *vcc;
  25
  26         struct videomode vm;
  27
  28         struct gpio_desc *resb_gpio;    /* low = reset active min 20 us */
  29         struct gpio_desc *ini_gpio;     /* high = power on */
  30         struct gpio_desc *mo_gpio;      /* low = 480x640, high = 240x320 */
  31         struct gpio_desc *lr_gpio;      /* high = conventional horizontal scanning */
  32         struct gpio_desc *ud_gpio;      /* high = conventional vertical scanning */
  33 };
  34
  35 static const struct videomode sharp_ls_vm = {
  36         .hactive = 480,
  37         .vactive = 640,
  38
  39         .pixelclock     = 19200000,
  40
  41         .hsync_len      = 2,
  42         .hfront_porch   = 1,
  43         .hback_porch    = 28,
  44
  45         .vsync_len      = 1,
  46         .vfront_porch   = 1,
  47         .vback_porch    = 1,
  48
  49         .flags          = DISPLAY_FLAGS_HSYNC_LOW | DISPLAY_FLAGS_VSYNC_LOW,
  50 };
  51
  52 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)
  53
  54 static int sharp_ls_connect(struct omap_dss_device *src,
  55                             struct omap_dss_device *dst)
  56 {
  57         return 0;
  58 }
  59
  60 static void sharp_ls_disconnect(struct omap_dss_device *src,
  61                                 struct omap_dss_device *dst)
  62 {
  63 }
  64
  65 static int sharp_ls_enable(struct omap_dss_device *dssdev)
  66 {
  67         struct panel_drv_data *ddata = to_panel_data(dssdev);
  68         struct omap_dss_device *src = dssdev->src;
  69         int r;
  70
  71         if (!omapdss_device_is_connected(dssdev))
  72                 return -ENODEV;
  73
  74         if (omapdss_device_is_enabled(dssdev))
  75                 return 0;
  76
  77         if (ddata->vcc) {
  78                 r = regulator_enable(ddata->vcc);
  79                 if (r != 0)
  80                         return r;
  81         }
  82
  83         r = src->ops->enable(src);
  84         if (r) {
  85                 regulator_disable(ddata->vcc);
  86                 return r;
  87         }
  88
  89         /* wait couple of vsyncs until enabling the LCD */
  90         msleep(50);
  91
  92         if (ddata->resb_gpio)
  93                 gpiod_set_value_cansleep(ddata->resb_gpio, 1);
  94
  95         if (ddata->ini_gpio)
  96                 gpiod_set_value_cansleep(ddata->ini_gpio, 1);
  97
  98         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
  99
 100         return 0;
 101 }
 102
 103 static void sharp_ls_disable(struct omap_dss_device *dssdev)
 104 {
 105         struct panel_drv_data *ddata = to_panel_data(dssdev);
 106         struct omap_dss_device *src = dssdev->src;
 107
 108         if (!omapdss_device_is_enabled(dssdev))
 109                 return;
 110
 111         if (ddata->ini_gpio)
 112                 gpiod_set_value_cansleep(ddata->ini_gpio, 0);
 113
 114         if (ddata->resb_gpio)
 115                 gpiod_set_value_cansleep(ddata->resb_gpio, 0);
 116
 117         /* wait at least 5 vsyncs after disabling the LCD */
 118
 119         msleep(100);
 120
 121         src->ops->disable(src);
 122
 123         if (ddata->vcc)
 124                 regulator_disable(ddata->vcc);
 125
 126         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 127 }
 128
 129 static void sharp_ls_get_timings(struct omap_dss_device *dssdev,
 130                                  struct videomode *vm)
 131 {
 132         struct panel_drv_data *ddata = to_panel_data(dssdev);
 133
 134         *vm = ddata->vm;
 135 }
 136
 137 static const struct omap_dss_device_ops sharp_ls_ops = {
 138         .connect        = sharp_ls_connect,
 139         .disconnect     = sharp_ls_disconnect,
 140
 141         .enable         = sharp_ls_enable,
 142         .disable        = sharp_ls_disable,
 143
 144         .get_timings    = sharp_ls_get_timings,
 145 };
 146
 147 static  int sharp_ls_get_gpio_of(struct device *dev, int index, int val,
 148         const char *desc, struct gpio_desc **gpiod)
 149 {
 150         struct gpio_desc *gd;
 151
 152         *gpiod = NULL;
 153
 154         gd = devm_gpiod_get_index(dev, desc, index, GPIOD_OUT_LOW);
 155         if (IS_ERR(gd))
 156                 return PTR_ERR(gd);
 157
 158         *gpiod = gd;
 159         return 0;
 160 }
 161
 162 static int sharp_ls_probe_of(struct platform_device *pdev)
 163 {
 164         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 165         int r;
 166
 167         ddata->vcc = devm_regulator_get(&pdev->dev, "envdd");
 168         if (IS_ERR(ddata->vcc)) {
 169                 dev_err(&pdev->dev, "failed to get regulator\n");
 170                 return PTR_ERR(ddata->vcc);
 171         }
 172
 173         /* lcd INI */
 174         r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "enable", &ddata->ini_gpio);
 175         if (r)
 176                 return r;
 177
 178         /* lcd RESB */
 179         r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "reset", &ddata->resb_gpio);
 180         if (r)
 181                 return r;
 182
 183         /* lcd MO */
 184         r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "mode", &ddata->mo_gpio);
 185         if (r)
 186                 return r;
 187
 188         /* lcd LR */
 189         r = sharp_ls_get_gpio_of(&pdev->dev, 1, 1, "mode", &ddata->lr_gpio);
 190         if (r)
 191                 return r;
 192
 193         /* lcd UD */
 194         r = sharp_ls_get_gpio_of(&pdev->dev, 2, 1, "mode", &ddata->ud_gpio);
 195         if (r)
 196                 return r;
 197
 198         return 0;
 199 }
 200
 201 static int sharp_ls_probe(struct platform_device *pdev)
 202 {
 203         struct panel_drv_data *ddata;
 204         struct omap_dss_device *dssdev;
 205         int r;
 206
 207         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 208         if (ddata == NULL)
 209                 return -ENOMEM;
 210
 211         platform_set_drvdata(pdev, ddata);
 212
 213         r = sharp_ls_probe_of(pdev);
 214         if (r)
 215                 return r;
 216
 217         ddata->vm = sharp_ls_vm;
 218
 219         dssdev = &ddata->dssdev;
 220         dssdev->dev = &pdev->dev;
 221         dssdev->ops = &sharp_ls_ops;
 222         dssdev->type = OMAP_DISPLAY_TYPE_DPI;
 223         dssdev->owner = THIS_MODULE;
 224         dssdev->of_ports = BIT(0);
 225
 226         /*
 227          * Note: According to the panel documentation:
 228          * DATA needs to be driven on the FALLING edge
 229          */
 230         dssdev->bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_SYNC_NEGEDGE
 231                           | DRM_BUS_FLAG_PIXDATA_POSEDGE;
 232
 233         omapdss_display_init(dssdev);
 234         omapdss_device_register(dssdev);
 235
 236         return 0;
 237 }
 238
 239 static int __exit sharp_ls_remove(struct platform_device *pdev)
 240 {
 241         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 242         struct omap_dss_device *dssdev = &ddata->dssdev;
 243
 244         omapdss_device_unregister(dssdev);
 245
 246         sharp_ls_disable(dssdev);
 247
 248         return 0;
 249 }
 250
 251 static const struct of_device_id sharp_ls_of_match[] = {
 252         { .compatible = "omapdss,sharp,ls037v7dw01", },
 253         {},
 254 };
 255
 256 MODULE_DEVICE_TABLE(of, sharp_ls_of_match);
 257
 258 static struct platform_driver sharp_ls_driver = {
 259         .probe = sharp_ls_probe,
 260         .remove = __exit_p(sharp_ls_remove),
 261         .driver = {
 262                 .name = "panel-sharp-ls037v7dw01",
 263                 .of_match_table = sharp_ls_of_match,
 264                 .suppress_bind_attrs = true,
 265         },
 266 };
 267
 268 module_platform_driver(sharp_ls_driver);
 269
 270 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
 271 MODULE_DESCRIPTION("Sharp LS037V7DW01 Panel Driver");
 272 MODULE_LICENSE("GPL");