drivers/video/omap2/displays/panel-dvi.c

   1 /*
   2  * DVI output support
   3  *
   4  * Copyright (C) 2011 Texas Instruments Inc
   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  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/slab.h>
  22 #include <video/omapdss.h>
  23 #include <linux/i2c.h>
  24 #include <linux/gpio.h>
  25 #include <drm/drm_edid.h>
  26
  27 #include <video/omap-panel-dvi.h>
  28
  29 static const struct omap_video_timings panel_dvi_default_timings = {
  30         .x_res          = 640,
  31         .y_res          = 480,
  32
  33         .pixel_clock    = 23500,
  34
  35         .hfp            = 48,
  36         .hsw            = 32,
  37         .hbp            = 80,
  38
  39         .vfp            = 3,
  40         .vsw            = 4,
  41         .vbp            = 7,
  42 };
  43
  44 struct panel_drv_data {
  45         struct omap_dss_device *dssdev;
  46
  47         struct mutex lock;
  48
  49         int pd_gpio;
  50 };
  51
  52 static inline struct panel_dvi_platform_data
  53 *get_pdata(const struct omap_dss_device *dssdev)
  54 {
  55         return dssdev->data;
  56 }
  57
  58 static int panel_dvi_power_on(struct omap_dss_device *dssdev)
  59 {
  60         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
  61         struct panel_dvi_platform_data *pdata = get_pdata(dssdev);
  62         int r;
  63
  64         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
  65                 return 0;
  66
  67         r = omapdss_dpi_display_enable(dssdev);
  68         if (r)
  69                 goto err0;
  70
  71         if (pdata->platform_enable) {
  72                 r = pdata->platform_enable(dssdev);
  73                 if (r)
  74                         goto err1;
  75         }
  76
  77         if (gpio_is_valid(ddata->pd_gpio))
  78                 gpio_set_value(ddata->pd_gpio, 1);
  79
  80         return 0;
  81 err1:
  82         omapdss_dpi_display_disable(dssdev);
  83 err0:
  84         return r;
  85 }
  86
  87 static void panel_dvi_power_off(struct omap_dss_device *dssdev)
  88 {
  89         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
  90         struct panel_dvi_platform_data *pdata = get_pdata(dssdev);
  91
  92         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
  93                 return;
  94
  95         if (gpio_is_valid(ddata->pd_gpio))
  96                 gpio_set_value(ddata->pd_gpio, 0);
  97
  98         if (pdata->platform_disable)
  99                 pdata->platform_disable(dssdev);
 100
 101         omapdss_dpi_display_disable(dssdev);
 102 }
 103
 104 static int panel_dvi_probe(struct omap_dss_device *dssdev)
 105 {
 106         struct panel_dvi_platform_data *pdata = get_pdata(dssdev);
 107         struct panel_drv_data *ddata;
 108         int r;
 109
 110         ddata = kzalloc(sizeof(*ddata), GFP_KERNEL);
 111         if (!ddata)
 112                 return -ENOMEM;
 113
 114         dssdev->panel.timings = panel_dvi_default_timings;
 115         dssdev->panel.config = OMAP_DSS_LCD_TFT;
 116
 117         ddata->dssdev = dssdev;
 118         mutex_init(&ddata->lock);
 119
 120         if (pdata)
 121                 ddata->pd_gpio = pdata->power_down_gpio;
 122         else
 123                 ddata->pd_gpio = -1;
 124
 125         if (gpio_is_valid(ddata->pd_gpio)) {
 126                 r = gpio_request_one(ddata->pd_gpio, GPIOF_OUT_INIT_LOW,
 127                                 "tfp410 pd");
 128                 if (r) {
 129                         dev_err(&dssdev->dev, "Failed to request PD GPIO %d\n",
 130                                         ddata->pd_gpio);
 131                         ddata->pd_gpio = -1;
 132                 }
 133         }
 134
 135         dev_set_drvdata(&dssdev->dev, ddata);
 136
 137         return 0;
 138 }
 139
 140 static void __exit panel_dvi_remove(struct omap_dss_device *dssdev)
 141 {
 142         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 143
 144         mutex_lock(&ddata->lock);
 145
 146         if (gpio_is_valid(ddata->pd_gpio))
 147                 gpio_free(ddata->pd_gpio);
 148
 149         dev_set_drvdata(&dssdev->dev, NULL);
 150
 151         mutex_unlock(&ddata->lock);
 152
 153         kfree(ddata);
 154 }
 155
 156 static int panel_dvi_enable(struct omap_dss_device *dssdev)
 157 {
 158         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 159         int r;
 160
 161         mutex_lock(&ddata->lock);
 162
 163         r = panel_dvi_power_on(dssdev);
 164         if (r == 0)
 165                 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 166
 167         mutex_unlock(&ddata->lock);
 168
 169         return r;
 170 }
 171
 172 static void panel_dvi_disable(struct omap_dss_device *dssdev)
 173 {
 174         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 175
 176         mutex_lock(&ddata->lock);
 177
 178         panel_dvi_power_off(dssdev);
 179
 180         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 181
 182         mutex_unlock(&ddata->lock);
 183 }
 184
 185 static int panel_dvi_suspend(struct omap_dss_device *dssdev)
 186 {
 187         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 188
 189         mutex_lock(&ddata->lock);
 190
 191         panel_dvi_power_off(dssdev);
 192
 193         dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
 194
 195         mutex_unlock(&ddata->lock);
 196
 197         return 0;
 198 }
 199
 200 static int panel_dvi_resume(struct omap_dss_device *dssdev)
 201 {
 202         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 203         int r;
 204
 205         mutex_lock(&ddata->lock);
 206
 207         r = panel_dvi_power_on(dssdev);
 208         if (r == 0)
 209                 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 210
 211         mutex_unlock(&ddata->lock);
 212
 213         return r;
 214 }
 215
 216 static void panel_dvi_set_timings(struct omap_dss_device *dssdev,
 217                 struct omap_video_timings *timings)
 218 {
 219         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 220
 221         mutex_lock(&ddata->lock);
 222         dpi_set_timings(dssdev, timings);
 223         mutex_unlock(&ddata->lock);
 224 }
 225
 226 static void panel_dvi_get_timings(struct omap_dss_device *dssdev,
 227                 struct omap_video_timings *timings)
 228 {
 229         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 230
 231         mutex_lock(&ddata->lock);
 232         *timings = dssdev->panel.timings;
 233         mutex_unlock(&ddata->lock);
 234 }
 235
 236 static int panel_dvi_check_timings(struct omap_dss_device *dssdev,
 237                 struct omap_video_timings *timings)
 238 {
 239         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 240         int r;
 241
 242         mutex_lock(&ddata->lock);
 243         r = dpi_check_timings(dssdev, timings);
 244         mutex_unlock(&ddata->lock);
 245
 246         return r;
 247 }
 248
 249
 250 static int panel_dvi_ddc_read(struct i2c_adapter *adapter,
 251                 unsigned char *buf, u16 count, u8 offset)
 252 {
 253         int r, retries;
 254
 255         for (retries = 3; retries > 0; retries--) {
 256                 struct i2c_msg msgs[] = {
 257                         {
 258                                 .addr   = DDC_ADDR,
 259                                 .flags  = 0,
 260                                 .len    = 1,
 261                                 .buf    = &offset,
 262                         }, {
 263                                 .addr   = DDC_ADDR,
 264                                 .flags  = I2C_M_RD,
 265                                 .len    = count,
 266                                 .buf    = buf,
 267                         }
 268                 };
 269
 270                 r = i2c_transfer(adapter, msgs, 2);
 271                 if (r == 2)
 272                         return 0;
 273
 274                 if (r != -EAGAIN)
 275                         break;
 276         }
 277
 278         return r < 0 ? r : -EIO;
 279 }
 280
 281 static int panel_dvi_read_edid(struct omap_dss_device *dssdev,
 282                 u8 *edid, int len)
 283 {
 284         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 285         struct panel_dvi_platform_data *pdata = get_pdata(dssdev);
 286         struct i2c_adapter *adapter;
 287         int r, l, bytes_read;
 288
 289         mutex_lock(&ddata->lock);
 290
 291         if (pdata->i2c_bus_num == 0) {
 292                 r = -ENODEV;
 293                 goto err;
 294         }
 295
 296         adapter = i2c_get_adapter(pdata->i2c_bus_num);
 297         if (!adapter) {
 298                 dev_err(&dssdev->dev, "Failed to get I2C adapter, bus %d\n",
 299                                 pdata->i2c_bus_num);
 300                 r = -EINVAL;
 301                 goto err;
 302         }
 303
 304         l = min(EDID_LENGTH, len);
 305         r = panel_dvi_ddc_read(adapter, edid, l, 0);
 306         if (r)
 307                 goto err;
 308
 309         bytes_read = l;
 310
 311         /* if there are extensions, read second block */
 312         if (len > EDID_LENGTH && edid[0x7e] > 0) {
 313                 l = min(EDID_LENGTH, len - EDID_LENGTH);
 314
 315                 r = panel_dvi_ddc_read(adapter, edid + EDID_LENGTH,
 316                                 l, EDID_LENGTH);
 317                 if (r)
 318                         goto err;
 319
 320                 bytes_read += l;
 321         }
 322
 323         mutex_unlock(&ddata->lock);
 324
 325         return bytes_read;
 326
 327 err:
 328         mutex_unlock(&ddata->lock);
 329         return r;
 330 }
 331
 332 static bool panel_dvi_detect(struct omap_dss_device *dssdev)
 333 {
 334         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
 335         struct panel_dvi_platform_data *pdata = get_pdata(dssdev);
 336         struct i2c_adapter *adapter;
 337         unsigned char out;
 338         int r;
 339
 340         mutex_lock(&ddata->lock);
 341
 342         if (pdata->i2c_bus_num == 0)
 343                 goto out;
 344
 345         adapter = i2c_get_adapter(pdata->i2c_bus_num);
 346         if (!adapter)
 347                 goto out;
 348
 349         r = panel_dvi_ddc_read(adapter, &out, 1, 0);
 350
 351         mutex_unlock(&ddata->lock);
 352
 353         return r == 0;
 354
 355 out:
 356         mutex_unlock(&ddata->lock);
 357         return true;
 358 }
 359
 360 static struct omap_dss_driver panel_dvi_driver = {
 361         .probe          = panel_dvi_probe,
 362         .remove         = __exit_p(panel_dvi_remove),
 363
 364         .enable         = panel_dvi_enable,
 365         .disable        = panel_dvi_disable,
 366         .suspend        = panel_dvi_suspend,
 367         .resume         = panel_dvi_resume,
 368
 369         .set_timings    = panel_dvi_set_timings,
 370         .get_timings    = panel_dvi_get_timings,
 371         .check_timings  = panel_dvi_check_timings,
 372
 373         .read_edid      = panel_dvi_read_edid,
 374         .detect         = panel_dvi_detect,
 375
 376         .driver         = {
 377                 .name   = "dvi",
 378                 .owner  = THIS_MODULE,
 379         },
 380 };
 381
 382 static int __init panel_dvi_init(void)
 383 {
 384         return omap_dss_register_driver(&panel_dvi_driver);
 385 }
 386
 387 static void __exit panel_dvi_exit(void)
 388 {
 389         omap_dss_unregister_driver(&panel_dvi_driver);
 390 }
 391
 392 module_init(panel_dvi_init);
 393 module_exit(panel_dvi_exit);
 394 MODULE_LICENSE("GPL");