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

   1 /*
   2  * LCD panel driver for Sharp LS037V7DW01
   3  *
   4  * Copyright (C) 2013 Texas Instruments
   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 omap_dss_device *in;
  25         struct regulator *vcc;
  26
  27         int data_lines;
  28
  29         struct omap_video_timings videomode;
  30
  31         struct gpio_desc *resb_gpio;    /* low = reset active min 20 us */
  32         struct gpio_desc *ini_gpio;     /* high = power on */
  33         struct gpio_desc *mo_gpio;      /* low = 480x640, high = 240x320 */
  34         struct gpio_desc *lr_gpio;      /* high = conventional horizontal scanning */
  35         struct gpio_desc *ud_gpio;      /* high = conventional vertical scanning */
  36 };
  37
  38 static const struct omap_video_timings sharp_ls_timings = {
  39         .hactive = 480,
  40         .vactive = 640,
  41
  42         .pixelclock     = 19200000,
  43
  44         .hsync_len      = 2,
  45         .hfront_porch   = 1,
  46         .hback_porch    = 28,
  47
  48         .vsync_len      = 1,
  49         .vfront_porch   = 1,
  50         .vback_porch    = 1,
  51
  52         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_FALLING_EDGE,
  53
  54         .flags          = DISPLAY_FLAGS_HSYNC_LOW | DISPLAY_FLAGS_VSYNC_LOW |
  55                           DISPLAY_FLAGS_DE_HIGH | DISPLAY_FLAGS_PIXDATA_POSEDGE,
  56 };
  57
  58 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)
  59
  60 static int sharp_ls_connect(struct omap_dss_device *dssdev)
  61 {
  62         struct panel_drv_data *ddata = to_panel_data(dssdev);
  63         struct omap_dss_device *in = ddata->in;
  64         int r;
  65
  66         if (omapdss_device_is_connected(dssdev))
  67                 return 0;
  68
  69         r = in->ops.dpi->connect(in, dssdev);
  70         if (r)
  71                 return r;
  72
  73         return 0;
  74 }
  75
  76 static void sharp_ls_disconnect(struct omap_dss_device *dssdev)
  77 {
  78         struct panel_drv_data *ddata = to_panel_data(dssdev);
  79         struct omap_dss_device *in = ddata->in;
  80
  81         if (!omapdss_device_is_connected(dssdev))
  82                 return;
  83
  84         in->ops.dpi->disconnect(in, dssdev);
  85 }
  86
  87 static int sharp_ls_enable(struct omap_dss_device *dssdev)
  88 {
  89         struct panel_drv_data *ddata = to_panel_data(dssdev);
  90         struct omap_dss_device *in = ddata->in;
  91         int r;
  92
  93         if (!omapdss_device_is_connected(dssdev))
  94                 return -ENODEV;
  95
  96         if (omapdss_device_is_enabled(dssdev))
  97                 return 0;
  98
  99         if (ddata->data_lines)
 100                 in->ops.dpi->set_data_lines(in, ddata->data_lines);
 101         in->ops.dpi->set_timings(in, &ddata->videomode);
 102
 103         if (ddata->vcc) {
 104                 r = regulator_enable(ddata->vcc);
 105                 if (r != 0)
 106                         return r;
 107         }
 108
 109         r = in->ops.dpi->enable(in);
 110         if (r) {
 111                 regulator_disable(ddata->vcc);
 112                 return r;
 113         }
 114
 115         /* wait couple of vsyncs until enabling the LCD */
 116         msleep(50);
 117
 118         if (ddata->resb_gpio)
 119                 gpiod_set_value_cansleep(ddata->resb_gpio, 1);
 120
 121         if (ddata->ini_gpio)
 122                 gpiod_set_value_cansleep(ddata->ini_gpio, 1);
 123
 124         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 125
 126         return 0;
 127 }
 128
 129 static void sharp_ls_disable(struct omap_dss_device *dssdev)
 130 {
 131         struct panel_drv_data *ddata = to_panel_data(dssdev);
 132         struct omap_dss_device *in = ddata->in;
 133
 134         if (!omapdss_device_is_enabled(dssdev))
 135                 return;
 136
 137         if (ddata->ini_gpio)
 138                 gpiod_set_value_cansleep(ddata->ini_gpio, 0);
 139
 140         if (ddata->resb_gpio)
 141                 gpiod_set_value_cansleep(ddata->resb_gpio, 0);
 142
 143         /* wait at least 5 vsyncs after disabling the LCD */
 144
 145         msleep(100);
 146
 147         in->ops.dpi->disable(in);
 148
 149         if (ddata->vcc)
 150                 regulator_disable(ddata->vcc);
 151
 152         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 153 }
 154
 155 static void sharp_ls_set_timings(struct omap_dss_device *dssdev,
 156                 struct omap_video_timings *timings)
 157 {
 158         struct panel_drv_data *ddata = to_panel_data(dssdev);
 159         struct omap_dss_device *in = ddata->in;
 160
 161         ddata->videomode = *timings;
 162         dssdev->panel.timings = *timings;
 163
 164         in->ops.dpi->set_timings(in, timings);
 165 }
 166
 167 static void sharp_ls_get_timings(struct omap_dss_device *dssdev,
 168                 struct omap_video_timings *timings)
 169 {
 170         struct panel_drv_data *ddata = to_panel_data(dssdev);
 171
 172         *timings = ddata->videomode;
 173 }
 174
 175 static int sharp_ls_check_timings(struct omap_dss_device *dssdev,
 176                 struct omap_video_timings *timings)
 177 {
 178         struct panel_drv_data *ddata = to_panel_data(dssdev);
 179         struct omap_dss_device *in = ddata->in;
 180
 181         return in->ops.dpi->check_timings(in, timings);
 182 }
 183
 184 static struct omap_dss_driver sharp_ls_ops = {
 185         .connect        = sharp_ls_connect,
 186         .disconnect     = sharp_ls_disconnect,
 187
 188         .enable         = sharp_ls_enable,
 189         .disable        = sharp_ls_disable,
 190
 191         .set_timings    = sharp_ls_set_timings,
 192         .get_timings    = sharp_ls_get_timings,
 193         .check_timings  = sharp_ls_check_timings,
 194
 195         .get_resolution = omapdss_default_get_resolution,
 196 };
 197
 198 static  int sharp_ls_get_gpio_of(struct device *dev, int index, int val,
 199         const char *desc, struct gpio_desc **gpiod)
 200 {
 201         struct gpio_desc *gd;
 202
 203         *gpiod = NULL;
 204
 205         gd = devm_gpiod_get_index(dev, desc, index, GPIOD_OUT_LOW);
 206         if (IS_ERR(gd))
 207                 return PTR_ERR(gd);
 208
 209         *gpiod = gd;
 210         return 0;
 211 }
 212
 213 static int sharp_ls_probe_of(struct platform_device *pdev)
 214 {
 215         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 216         struct device_node *node = pdev->dev.of_node;
 217         struct omap_dss_device *in;
 218         int r;
 219
 220         ddata->vcc = devm_regulator_get(&pdev->dev, "envdd");
 221         if (IS_ERR(ddata->vcc)) {
 222                 dev_err(&pdev->dev, "failed to get regulator\n");
 223                 return PTR_ERR(ddata->vcc);
 224         }
 225
 226         /* lcd INI */
 227         r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "enable", &ddata->ini_gpio);
 228         if (r)
 229                 return r;
 230
 231         /* lcd RESB */
 232         r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "reset", &ddata->resb_gpio);
 233         if (r)
 234                 return r;
 235
 236         /* lcd MO */
 237         r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "mode", &ddata->mo_gpio);
 238         if (r)
 239                 return r;
 240
 241         /* lcd LR */
 242         r = sharp_ls_get_gpio_of(&pdev->dev, 1, 1, "mode", &ddata->lr_gpio);
 243         if (r)
 244                 return r;
 245
 246         /* lcd UD */
 247         r = sharp_ls_get_gpio_of(&pdev->dev, 2, 1, "mode", &ddata->ud_gpio);
 248         if (r)
 249                 return r;
 250
 251         in = omapdss_of_find_source_for_first_ep(node);
 252         if (IS_ERR(in)) {
 253                 dev_err(&pdev->dev, "failed to find video source\n");
 254                 return PTR_ERR(in);
 255         }
 256
 257         ddata->in = in;
 258
 259         return 0;
 260 }
 261
 262 static int sharp_ls_probe(struct platform_device *pdev)
 263 {
 264         struct panel_drv_data *ddata;
 265         struct omap_dss_device *dssdev;
 266         int r;
 267
 268         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 269         if (ddata == NULL)
 270                 return -ENOMEM;
 271
 272         platform_set_drvdata(pdev, ddata);
 273
 274         if (!pdev->dev.of_node)
 275                 return -ENODEV;
 276
 277         r = sharp_ls_probe_of(pdev);
 278         if (r)
 279                 return r;
 280
 281         ddata->videomode = sharp_ls_timings;
 282
 283         dssdev = &ddata->dssdev;
 284         dssdev->dev = &pdev->dev;
 285         dssdev->driver = &sharp_ls_ops;
 286         dssdev->type = OMAP_DISPLAY_TYPE_DPI;
 287         dssdev->owner = THIS_MODULE;
 288         dssdev->panel.timings = ddata->videomode;
 289         dssdev->phy.dpi.data_lines = ddata->data_lines;
 290
 291         r = omapdss_register_display(dssdev);
 292         if (r) {
 293                 dev_err(&pdev->dev, "Failed to register panel\n");
 294                 goto err_reg;
 295         }
 296
 297         return 0;
 298
 299 err_reg:
 300         omap_dss_put_device(ddata->in);
 301         return r;
 302 }
 303
 304 static int __exit sharp_ls_remove(struct platform_device *pdev)
 305 {
 306         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 307         struct omap_dss_device *dssdev = &ddata->dssdev;
 308         struct omap_dss_device *in = ddata->in;
 309
 310         omapdss_unregister_display(dssdev);
 311
 312         sharp_ls_disable(dssdev);
 313         sharp_ls_disconnect(dssdev);
 314
 315         omap_dss_put_device(in);
 316
 317         return 0;
 318 }
 319
 320 static const struct of_device_id sharp_ls_of_match[] = {
 321         { .compatible = "omapdss,sharp,ls037v7dw01", },
 322         {},
 323 };
 324
 325 MODULE_DEVICE_TABLE(of, sharp_ls_of_match);
 326
 327 static struct platform_driver sharp_ls_driver = {
 328         .probe = sharp_ls_probe,
 329         .remove = __exit_p(sharp_ls_remove),
 330         .driver = {
 331                 .name = "panel-sharp-ls037v7dw01",
 332                 .of_match_table = sharp_ls_of_match,
 333                 .suppress_bind_attrs = true,
 334         },
 335 };
 336
 337 module_platform_driver(sharp_ls_driver);
 338
 339 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
 340 MODULE_DESCRIPTION("Sharp LS037V7DW01 Panel Driver");
 341 MODULE_LICENSE("GPL");