drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

   1 /*
   2  * TPD12S015 HDMI ESD protection & level shifter chip driver
   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/completion.h>
  13 #include <linux/delay.h>
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/gpio/consumer.h>
  18
  19 #include <video/omapfb_dss.h>
  20
  21 struct panel_drv_data {
  22         struct omap_dss_device dssdev;
  23         struct omap_dss_device *in;
  24
  25         struct gpio_desc *ct_cp_hpd_gpio;
  26         struct gpio_desc *ls_oe_gpio;
  27         struct gpio_desc *hpd_gpio;
  28
  29         struct omap_video_timings timings;
  30 };
  31
  32 #define to_panel_data(x) container_of(x, struct panel_drv_data, dssdev)
  33
  34 static int tpd_connect(struct omap_dss_device *dssdev,
  35                 struct omap_dss_device *dst)
  36 {
  37         struct panel_drv_data *ddata = to_panel_data(dssdev);
  38         struct omap_dss_device *in = ddata->in;
  39         int r;
  40
  41         r = in->ops.hdmi->connect(in, dssdev);
  42         if (r)
  43                 return r;
  44
  45         dst->src = dssdev;
  46         dssdev->dst = dst;
  47
  48         if (ddata->ct_cp_hpd_gpio) {
  49                 gpiod_set_value_cansleep(ddata->ct_cp_hpd_gpio, 1);
  50                 /* DC-DC converter needs at max 300us to get to 90% of 5V */
  51                 udelay(300);
  52         }
  53
  54         return 0;
  55 }
  56
  57 static void tpd_disconnect(struct omap_dss_device *dssdev,
  58                 struct omap_dss_device *dst)
  59 {
  60         struct panel_drv_data *ddata = to_panel_data(dssdev);
  61         struct omap_dss_device *in = ddata->in;
  62
  63         WARN_ON(dst != dssdev->dst);
  64
  65         if (dst != dssdev->dst)
  66                 return;
  67
  68         gpiod_set_value_cansleep(ddata->ct_cp_hpd_gpio, 0);
  69
  70         dst->src = NULL;
  71         dssdev->dst = NULL;
  72
  73         in->ops.hdmi->disconnect(in, &ddata->dssdev);
  74 }
  75
  76 static int tpd_enable(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         int r;
  81
  82         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
  83                 return 0;
  84
  85         in->ops.hdmi->set_timings(in, &ddata->timings);
  86
  87         r = in->ops.hdmi->enable(in);
  88         if (r)
  89                 return r;
  90
  91         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
  92
  93         return r;
  94 }
  95
  96 static void tpd_disable(struct omap_dss_device *dssdev)
  97 {
  98         struct panel_drv_data *ddata = to_panel_data(dssdev);
  99         struct omap_dss_device *in = ddata->in;
 100
 101         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
 102                 return;
 103
 104         in->ops.hdmi->disable(in);
 105
 106         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 107 }
 108
 109 static void tpd_set_timings(struct omap_dss_device *dssdev,
 110                 struct omap_video_timings *timings)
 111 {
 112         struct panel_drv_data *ddata = to_panel_data(dssdev);
 113         struct omap_dss_device *in = ddata->in;
 114
 115         ddata->timings = *timings;
 116         dssdev->panel.timings = *timings;
 117
 118         in->ops.hdmi->set_timings(in, timings);
 119 }
 120
 121 static void tpd_get_timings(struct omap_dss_device *dssdev,
 122                 struct omap_video_timings *timings)
 123 {
 124         struct panel_drv_data *ddata = to_panel_data(dssdev);
 125
 126         *timings = ddata->timings;
 127 }
 128
 129 static int tpd_check_timings(struct omap_dss_device *dssdev,
 130                 struct omap_video_timings *timings)
 131 {
 132         struct panel_drv_data *ddata = to_panel_data(dssdev);
 133         struct omap_dss_device *in = ddata->in;
 134         int r;
 135
 136         r = in->ops.hdmi->check_timings(in, timings);
 137
 138         return r;
 139 }
 140
 141 static int tpd_read_edid(struct omap_dss_device *dssdev,
 142                 u8 *edid, int len)
 143 {
 144         struct panel_drv_data *ddata = to_panel_data(dssdev);
 145         struct omap_dss_device *in = ddata->in;
 146         int r;
 147
 148         if (!gpiod_get_value_cansleep(ddata->hpd_gpio))
 149                 return -ENODEV;
 150
 151         gpiod_set_value_cansleep(ddata->ls_oe_gpio, 1);
 152
 153         r = in->ops.hdmi->read_edid(in, edid, len);
 154
 155         gpiod_set_value_cansleep(ddata->ls_oe_gpio, 0);
 156
 157         return r;
 158 }
 159
 160 static bool tpd_detect(struct omap_dss_device *dssdev)
 161 {
 162         struct panel_drv_data *ddata = to_panel_data(dssdev);
 163
 164         return gpiod_get_value_cansleep(ddata->hpd_gpio);
 165 }
 166
 167 static int tpd_set_infoframe(struct omap_dss_device *dssdev,
 168                 const struct hdmi_avi_infoframe *avi)
 169 {
 170         struct panel_drv_data *ddata = to_panel_data(dssdev);
 171         struct omap_dss_device *in = ddata->in;
 172
 173         return in->ops.hdmi->set_infoframe(in, avi);
 174 }
 175
 176 static int tpd_set_hdmi_mode(struct omap_dss_device *dssdev,
 177                 bool hdmi_mode)
 178 {
 179         struct panel_drv_data *ddata = to_panel_data(dssdev);
 180         struct omap_dss_device *in = ddata->in;
 181
 182         return in->ops.hdmi->set_hdmi_mode(in, hdmi_mode);
 183 }
 184
 185 static const struct omapdss_hdmi_ops tpd_hdmi_ops = {
 186         .connect                = tpd_connect,
 187         .disconnect             = tpd_disconnect,
 188
 189         .enable                 = tpd_enable,
 190         .disable                = tpd_disable,
 191
 192         .check_timings          = tpd_check_timings,
 193         .set_timings            = tpd_set_timings,
 194         .get_timings            = tpd_get_timings,
 195
 196         .read_edid              = tpd_read_edid,
 197         .detect                 = tpd_detect,
 198         .set_infoframe          = tpd_set_infoframe,
 199         .set_hdmi_mode          = tpd_set_hdmi_mode,
 200 };
 201
 202 static int tpd_probe_of(struct platform_device *pdev)
 203 {
 204         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 205         struct device_node *node = pdev->dev.of_node;
 206         struct omap_dss_device *in;
 207
 208         in = omapdss_of_find_source_for_first_ep(node);
 209         if (IS_ERR(in)) {
 210                 dev_err(&pdev->dev, "failed to find video source\n");
 211                 return PTR_ERR(in);
 212         }
 213
 214         ddata->in = in;
 215
 216         return 0;
 217 }
 218
 219 static int tpd_probe(struct platform_device *pdev)
 220 {
 221         struct omap_dss_device *in, *dssdev;
 222         struct panel_drv_data *ddata;
 223         int r;
 224         struct gpio_desc *gpio;
 225
 226         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 227         if (!ddata)
 228                 return -ENOMEM;
 229
 230         platform_set_drvdata(pdev, ddata);
 231
 232         if (pdev->dev.of_node) {
 233                 r = tpd_probe_of(pdev);
 234                 if (r)
 235                         return r;
 236         } else {
 237                 return -ENODEV;
 238         }
 239
 240
 241         gpio = devm_gpiod_get_index_optional(&pdev->dev, NULL, 0,
 242                 GPIOD_OUT_LOW);
 243         if (IS_ERR(gpio)) {
 244                 r = PTR_ERR(gpio);
 245                 goto err_gpio;
 246         }
 247
 248         ddata->ct_cp_hpd_gpio = gpio;
 249
 250         gpio = devm_gpiod_get_index_optional(&pdev->dev, NULL, 1,
 251                 GPIOD_OUT_LOW);
 252         if (IS_ERR(gpio)) {
 253                 r = PTR_ERR(gpio);
 254                 goto err_gpio;
 255         }
 256
 257         ddata->ls_oe_gpio = gpio;
 258
 259         gpio = devm_gpiod_get_index(&pdev->dev, NULL, 2,
 260                 GPIOD_IN);
 261         if (IS_ERR(gpio)) {
 262                 r = PTR_ERR(gpio);
 263                 goto err_gpio;
 264         }
 265
 266         ddata->hpd_gpio = gpio;
 267
 268         dssdev = &ddata->dssdev;
 269         dssdev->ops.hdmi = &tpd_hdmi_ops;
 270         dssdev->dev = &pdev->dev;
 271         dssdev->type = OMAP_DISPLAY_TYPE_HDMI;
 272         dssdev->output_type = OMAP_DISPLAY_TYPE_HDMI;
 273         dssdev->owner = THIS_MODULE;
 274         dssdev->port_num = 1;
 275
 276         in = ddata->in;
 277
 278         r = omapdss_register_output(dssdev);
 279         if (r) {
 280                 dev_err(&pdev->dev, "Failed to register output\n");
 281                 goto err_reg;
 282         }
 283
 284         return 0;
 285 err_reg:
 286 err_gpio:
 287         omap_dss_put_device(ddata->in);
 288         return r;
 289 }
 290
 291 static int __exit tpd_remove(struct platform_device *pdev)
 292 {
 293         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 294         struct omap_dss_device *dssdev = &ddata->dssdev;
 295         struct omap_dss_device *in = ddata->in;
 296
 297         omapdss_unregister_output(&ddata->dssdev);
 298
 299         WARN_ON(omapdss_device_is_enabled(dssdev));
 300         if (omapdss_device_is_enabled(dssdev))
 301                 tpd_disable(dssdev);
 302
 303         WARN_ON(omapdss_device_is_connected(dssdev));
 304         if (omapdss_device_is_connected(dssdev))
 305                 tpd_disconnect(dssdev, dssdev->dst);
 306
 307         omap_dss_put_device(in);
 308
 309         return 0;
 310 }
 311
 312 static const struct of_device_id tpd_of_match[] = {
 313         { .compatible = "omapdss,ti,tpd12s015", },
 314         {},
 315 };
 316
 317 MODULE_DEVICE_TABLE(of, tpd_of_match);
 318
 319 static struct platform_driver tpd_driver = {
 320         .probe  = tpd_probe,
 321         .remove = __exit_p(tpd_remove),
 322         .driver = {
 323                 .name   = "tpd12s015",
 324                 .of_match_table = tpd_of_match,
 325                 .suppress_bind_attrs = true,
 326         },
 327 };
 328
 329 module_platform_driver(tpd_driver);
 330
 331 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
 332 MODULE_DESCRIPTION("TPD12S015 driver");
 333 MODULE_LICENSE("GPL");