omapfb/displays/panel-sharp-ls037v7dw01.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * LCD panel driver for Sharp LS037V7DW01
0004  *
0005  * Copyright (C) 2013 Texas Instruments
0006  * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
0007  */
0008
0009 #include <linux/delay.h>
0010 #include <linux/gpio.h>
0011 #include <linux/module.h>
0012 #include <linux/of.h>
0013 #include <linux/of_gpio.h>
0014 #include <linux/platform_device.h>
0015 #include <linux/slab.h>
0016 #include <linux/regulator/consumer.h>
0017 #include <video/omapfb_dss.h>
0018
0019 struct panel_drv_data {
0020     struct omap_dss_device dssdev;
0021     struct omap_dss_device *in;
0022     struct regulator *vcc;
0023
0024     int data_lines;
0025
0026     struct omap_video_timings videomode;
0027
0028     struct gpio_desc *resb_gpio;    /* low = reset active min 20 us */
0029     struct gpio_desc *ini_gpio; /* high = power on */
0030     struct gpio_desc *mo_gpio;  /* low = 480x640, high = 240x320 */
0031     struct gpio_desc *lr_gpio;  /* high = conventional horizontal scanning */
0032     struct gpio_desc *ud_gpio;  /* high = conventional vertical scanning */
0033 };
0034
0035 static const struct omap_video_timings sharp_ls_timings = {
0036     .x_res = 480,
0037     .y_res = 640,
0038
0039     .pixelclock = 19200000,
0040
0041     .hsw        = 2,
0042     .hfp        = 1,
0043     .hbp        = 28,
0044
0045     .vsw        = 1,
0046     .vfp        = 1,
0047     .vbp        = 1,
0048
0049     .vsync_level    = OMAPDSS_SIG_ACTIVE_LOW,
0050     .hsync_level    = OMAPDSS_SIG_ACTIVE_LOW,
0051     .data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE,
0052     .de_level   = OMAPDSS_SIG_ACTIVE_HIGH,
0053     .sync_pclk_edge = OMAPDSS_DRIVE_SIG_FALLING_EDGE,
0054 };
0055
0056 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)
0057
0058 static int sharp_ls_connect(struct omap_dss_device *dssdev)
0059 {
0060     struct panel_drv_data *ddata = to_panel_data(dssdev);
0061     struct omap_dss_device *in = ddata->in;
0062
0063     if (omapdss_device_is_connected(dssdev))
0064         return 0;
0065
0066     return in->ops.dpi->connect(in, dssdev);
0067 }
0068
0069 static void sharp_ls_disconnect(struct omap_dss_device *dssdev)
0070 {
0071     struct panel_drv_data *ddata = to_panel_data(dssdev);
0072     struct omap_dss_device *in = ddata->in;
0073
0074     if (!omapdss_device_is_connected(dssdev))
0075         return;
0076
0077     in->ops.dpi->disconnect(in, dssdev);
0078 }
0079
0080 static int sharp_ls_enable(struct omap_dss_device *dssdev)
0081 {
0082     struct panel_drv_data *ddata = to_panel_data(dssdev);
0083     struct omap_dss_device *in = ddata->in;
0084     int r;
0085
0086     if (!omapdss_device_is_connected(dssdev))
0087         return -ENODEV;
0088
0089     if (omapdss_device_is_enabled(dssdev))
0090         return 0;
0091
0092     if (ddata->data_lines)
0093         in->ops.dpi->set_data_lines(in, ddata->data_lines);
0094     in->ops.dpi->set_timings(in, &ddata->videomode);
0095
0096     if (ddata->vcc) {
0097         r = regulator_enable(ddata->vcc);
0098         if (r != 0)
0099             return r;
0100     }
0101
0102     r = in->ops.dpi->enable(in);
0103     if (r) {
0104         regulator_disable(ddata->vcc);
0105         return r;
0106     }
0107
0108     /* wait couple of vsyncs until enabling the LCD */
0109     msleep(50);
0110
0111     if (ddata->resb_gpio)
0112         gpiod_set_value_cansleep(ddata->resb_gpio, 1);
0113
0114     if (ddata->ini_gpio)
0115         gpiod_set_value_cansleep(ddata->ini_gpio, 1);
0116
0117     dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
0118
0119     return 0;
0120 }
0121
0122 static void sharp_ls_disable(struct omap_dss_device *dssdev)
0123 {
0124     struct panel_drv_data *ddata = to_panel_data(dssdev);
0125     struct omap_dss_device *in = ddata->in;
0126
0127     if (!omapdss_device_is_enabled(dssdev))
0128         return;
0129
0130     if (ddata->ini_gpio)
0131         gpiod_set_value_cansleep(ddata->ini_gpio, 0);
0132
0133     if (ddata->resb_gpio)
0134         gpiod_set_value_cansleep(ddata->resb_gpio, 0);
0135
0136     /* wait at least 5 vsyncs after disabling the LCD */
0137
0138     msleep(100);
0139
0140     in->ops.dpi->disable(in);
0141
0142     if (ddata->vcc)
0143         regulator_disable(ddata->vcc);
0144
0145     dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
0146 }
0147
0148 static void sharp_ls_set_timings(struct omap_dss_device *dssdev,
0149         struct omap_video_timings *timings)
0150 {
0151     struct panel_drv_data *ddata = to_panel_data(dssdev);
0152     struct omap_dss_device *in = ddata->in;
0153
0154     ddata->videomode = *timings;
0155     dssdev->panel.timings = *timings;
0156
0157     in->ops.dpi->set_timings(in, timings);
0158 }
0159
0160 static void sharp_ls_get_timings(struct omap_dss_device *dssdev,
0161         struct omap_video_timings *timings)
0162 {
0163     struct panel_drv_data *ddata = to_panel_data(dssdev);
0164
0165     *timings = ddata->videomode;
0166 }
0167
0168 static int sharp_ls_check_timings(struct omap_dss_device *dssdev,
0169         struct omap_video_timings *timings)
0170 {
0171     struct panel_drv_data *ddata = to_panel_data(dssdev);
0172     struct omap_dss_device *in = ddata->in;
0173
0174     return in->ops.dpi->check_timings(in, timings);
0175 }
0176
0177 static struct omap_dss_driver sharp_ls_ops = {
0178     .connect    = sharp_ls_connect,
0179     .disconnect = sharp_ls_disconnect,
0180
0181     .enable     = sharp_ls_enable,
0182     .disable    = sharp_ls_disable,
0183
0184     .set_timings    = sharp_ls_set_timings,
0185     .get_timings    = sharp_ls_get_timings,
0186     .check_timings  = sharp_ls_check_timings,
0187
0188     .get_resolution = omapdss_default_get_resolution,
0189 };
0190
0191 static  int sharp_ls_get_gpio_of(struct device *dev, int index, int val,
0192     const char *desc, struct gpio_desc **gpiod)
0193 {
0194     struct gpio_desc *gd;
0195
0196     *gpiod = NULL;
0197
0198     gd = devm_gpiod_get_index(dev, desc, index, GPIOD_OUT_LOW);
0199     if (IS_ERR(gd))
0200         return PTR_ERR(gd);
0201
0202     *gpiod = gd;
0203     return 0;
0204 }
0205
0206 static int sharp_ls_probe_of(struct platform_device *pdev)
0207 {
0208     struct panel_drv_data *ddata = platform_get_drvdata(pdev);
0209     struct device_node *node = pdev->dev.of_node;
0210     struct omap_dss_device *in;
0211     int r;
0212
0213     ddata->vcc = devm_regulator_get(&pdev->dev, "envdd");
0214     if (IS_ERR(ddata->vcc))
0215         return dev_err_probe(&pdev->dev, PTR_ERR(ddata->vcc),
0216                      "failed to get regulator\n");
0217
0218     /* lcd INI */
0219     r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "enable", &ddata->ini_gpio);
0220     if (r)
0221         return r;
0222
0223     /* lcd RESB */
0224     r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "reset", &ddata->resb_gpio);
0225     if (r)
0226         return r;
0227
0228     /* lcd MO */
0229     r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "mode", &ddata->mo_gpio);
0230     if (r)
0231         return r;
0232
0233     /* lcd LR */
0234     r = sharp_ls_get_gpio_of(&pdev->dev, 1, 1, "mode", &ddata->lr_gpio);
0235     if (r)
0236         return r;
0237
0238     /* lcd UD */
0239     r = sharp_ls_get_gpio_of(&pdev->dev, 2, 1, "mode", &ddata->ud_gpio);
0240     if (r)
0241         return r;
0242
0243     in = omapdss_of_find_source_for_first_ep(node);
0244     if (IS_ERR(in)) {
0245         dev_err(&pdev->dev, "failed to find video source\n");
0246         return PTR_ERR(in);
0247     }
0248
0249     ddata->in = in;
0250
0251     return 0;
0252 }
0253
0254 static int sharp_ls_probe(struct platform_device *pdev)
0255 {
0256     struct panel_drv_data *ddata;
0257     struct omap_dss_device *dssdev;
0258     int r;
0259
0260     if (!pdev->dev.of_node)
0261         return -ENODEV;
0262
0263     ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
0264     if (ddata == NULL)
0265         return -ENOMEM;
0266
0267     platform_set_drvdata(pdev, ddata);
0268
0269     r = sharp_ls_probe_of(pdev);
0270     if (r)
0271         return r;
0272
0273     ddata->videomode = sharp_ls_timings;
0274
0275     dssdev = &ddata->dssdev;
0276     dssdev->dev = &pdev->dev;
0277     dssdev->driver = &sharp_ls_ops;
0278     dssdev->type = OMAP_DISPLAY_TYPE_DPI;
0279     dssdev->owner = THIS_MODULE;
0280     dssdev->panel.timings = ddata->videomode;
0281     dssdev->phy.dpi.data_lines = ddata->data_lines;
0282
0283     r = omapdss_register_display(dssdev);
0284     if (r) {
0285         dev_err(&pdev->dev, "Failed to register panel\n");
0286         goto err_reg;
0287     }
0288
0289     return 0;
0290
0291 err_reg:
0292     omap_dss_put_device(ddata->in);
0293     return r;
0294 }
0295
0296 static int __exit sharp_ls_remove(struct platform_device *pdev)
0297 {
0298     struct panel_drv_data *ddata = platform_get_drvdata(pdev);
0299     struct omap_dss_device *dssdev = &ddata->dssdev;
0300     struct omap_dss_device *in = ddata->in;
0301
0302     omapdss_unregister_display(dssdev);
0303
0304     sharp_ls_disable(dssdev);
0305     sharp_ls_disconnect(dssdev);
0306
0307     omap_dss_put_device(in);
0308
0309     return 0;
0310 }
0311
0312 static const struct of_device_id sharp_ls_of_match[] = {
0313     { .compatible = "omapdss,sharp,ls037v7dw01", },
0314     {},
0315 };
0316
0317 MODULE_DEVICE_TABLE(of, sharp_ls_of_match);
0318
0319 static struct platform_driver sharp_ls_driver = {
0320     .probe = sharp_ls_probe,
0321     .remove = __exit_p(sharp_ls_remove),
0322     .driver = {
0323         .name = "panel-sharp-ls037v7dw01",
0324         .of_match_table = sharp_ls_of_match,
0325         .suppress_bind_attrs = true,
0326     },
0327 };
0328
0329 module_platform_driver(sharp_ls_driver);
0330
0331 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
0332 MODULE_DESCRIPTION("Sharp LS037V7DW01 Panel Driver");
0333 MODULE_LICENSE("GPL");