drivers/video/fbdev/omap2/omapfb/displays/connector-dvi.c

   1 /*
   2  * Generic DVI Connector 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/i2c.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/slab.h>
  16
  17 #include <drm/drm_edid.h>
  18
  19 #include <video/omapfb_dss.h>
  20
  21 static const struct omap_video_timings dvic_default_timings = {
  22         .x_res          = 640,
  23         .y_res          = 480,
  24
  25         .pixelclock     = 23500000,
  26
  27         .hfp            = 48,
  28         .hsw            = 32,
  29         .hbp            = 80,
  30
  31         .vfp            = 3,
  32         .vsw            = 4,
  33         .vbp            = 7,
  34
  35         .vsync_level    = OMAPDSS_SIG_ACTIVE_HIGH,
  36         .hsync_level    = OMAPDSS_SIG_ACTIVE_HIGH,
  37         .data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE,
  38         .de_level       = OMAPDSS_SIG_ACTIVE_HIGH,
  39         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_FALLING_EDGE,
  40 };
  41
  42 struct panel_drv_data {
  43         struct omap_dss_device dssdev;
  44         struct omap_dss_device *in;
  45
  46         struct omap_video_timings timings;
  47
  48         struct i2c_adapter *i2c_adapter;
  49 };
  50
  51 #define to_panel_data(x) container_of(x, struct panel_drv_data, dssdev)
  52
  53 static int dvic_connect(struct omap_dss_device *dssdev)
  54 {
  55         struct panel_drv_data *ddata = to_panel_data(dssdev);
  56         struct omap_dss_device *in = ddata->in;
  57         int r;
  58
  59         if (omapdss_device_is_connected(dssdev))
  60                 return 0;
  61
  62         r = in->ops.dvi->connect(in, dssdev);
  63         if (r)
  64                 return r;
  65
  66         return 0;
  67 }
  68
  69 static void dvic_disconnect(struct omap_dss_device *dssdev)
  70 {
  71         struct panel_drv_data *ddata = to_panel_data(dssdev);
  72         struct omap_dss_device *in = ddata->in;
  73
  74         if (!omapdss_device_is_connected(dssdev))
  75                 return;
  76
  77         in->ops.dvi->disconnect(in, dssdev);
  78 }
  79
  80 static int dvic_enable(struct omap_dss_device *dssdev)
  81 {
  82         struct panel_drv_data *ddata = to_panel_data(dssdev);
  83         struct omap_dss_device *in = ddata->in;
  84         int r;
  85
  86         if (!omapdss_device_is_connected(dssdev))
  87                 return -ENODEV;
  88
  89         if (omapdss_device_is_enabled(dssdev))
  90                 return 0;
  91
  92         in->ops.dvi->set_timings(in, &ddata->timings);
  93
  94         r = in->ops.dvi->enable(in);
  95         if (r)
  96                 return r;
  97
  98         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
  99
 100         return 0;
 101 }
 102
 103 static void dvic_disable(struct omap_dss_device *dssdev)
 104 {
 105         struct panel_drv_data *ddata = to_panel_data(dssdev);
 106         struct omap_dss_device *in = ddata->in;
 107
 108         if (!omapdss_device_is_enabled(dssdev))
 109                 return;
 110
 111         in->ops.dvi->disable(in);
 112
 113         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 114 }
 115
 116 static void dvic_set_timings(struct omap_dss_device *dssdev,
 117                 struct omap_video_timings *timings)
 118 {
 119         struct panel_drv_data *ddata = to_panel_data(dssdev);
 120         struct omap_dss_device *in = ddata->in;
 121
 122         ddata->timings = *timings;
 123         dssdev->panel.timings = *timings;
 124
 125         in->ops.dvi->set_timings(in, timings);
 126 }
 127
 128 static void dvic_get_timings(struct omap_dss_device *dssdev,
 129                 struct omap_video_timings *timings)
 130 {
 131         struct panel_drv_data *ddata = to_panel_data(dssdev);
 132
 133         *timings = ddata->timings;
 134 }
 135
 136 static int dvic_check_timings(struct omap_dss_device *dssdev,
 137                 struct omap_video_timings *timings)
 138 {
 139         struct panel_drv_data *ddata = to_panel_data(dssdev);
 140         struct omap_dss_device *in = ddata->in;
 141
 142         return in->ops.dvi->check_timings(in, timings);
 143 }
 144
 145 static int dvic_ddc_read(struct i2c_adapter *adapter,
 146                 unsigned char *buf, u16 count, u8 offset)
 147 {
 148         int r, retries;
 149
 150         for (retries = 3; retries > 0; retries--) {
 151                 struct i2c_msg msgs[] = {
 152                         {
 153                                 .addr   = DDC_ADDR,
 154                                 .flags  = 0,
 155                                 .len    = 1,
 156                                 .buf    = &offset,
 157                         }, {
 158                                 .addr   = DDC_ADDR,
 159                                 .flags  = I2C_M_RD,
 160                                 .len    = count,
 161                                 .buf    = buf,
 162                         }
 163                 };
 164
 165                 r = i2c_transfer(adapter, msgs, 2);
 166                 if (r == 2)
 167                         return 0;
 168
 169                 if (r != -EAGAIN)
 170                         break;
 171         }
 172
 173         return r < 0 ? r : -EIO;
 174 }
 175
 176 static int dvic_read_edid(struct omap_dss_device *dssdev,
 177                 u8 *edid, int len)
 178 {
 179         struct panel_drv_data *ddata = to_panel_data(dssdev);
 180         int r, l, bytes_read;
 181
 182         if (!ddata->i2c_adapter)
 183                 return -ENODEV;
 184
 185         l = min(EDID_LENGTH, len);
 186         r = dvic_ddc_read(ddata->i2c_adapter, edid, l, 0);
 187         if (r)
 188                 return r;
 189
 190         bytes_read = l;
 191
 192         /* if there are extensions, read second block */
 193         if (len > EDID_LENGTH && edid[0x7e] > 0) {
 194                 l = min(EDID_LENGTH, len - EDID_LENGTH);
 195
 196                 r = dvic_ddc_read(ddata->i2c_adapter, edid + EDID_LENGTH,
 197                                 l, EDID_LENGTH);
 198                 if (r)
 199                         return r;
 200
 201                 bytes_read += l;
 202         }
 203
 204         return bytes_read;
 205 }
 206
 207 static bool dvic_detect(struct omap_dss_device *dssdev)
 208 {
 209         struct panel_drv_data *ddata = to_panel_data(dssdev);
 210         unsigned char out;
 211         int r;
 212
 213         if (!ddata->i2c_adapter)
 214                 return true;
 215
 216         r = dvic_ddc_read(ddata->i2c_adapter, &out, 1, 0);
 217
 218         return r == 0;
 219 }
 220
 221 static struct omap_dss_driver dvic_driver = {
 222         .connect        = dvic_connect,
 223         .disconnect     = dvic_disconnect,
 224
 225         .enable         = dvic_enable,
 226         .disable        = dvic_disable,
 227
 228         .set_timings    = dvic_set_timings,
 229         .get_timings    = dvic_get_timings,
 230         .check_timings  = dvic_check_timings,
 231
 232         .get_resolution = omapdss_default_get_resolution,
 233
 234         .read_edid      = dvic_read_edid,
 235         .detect         = dvic_detect,
 236 };
 237
 238 static int dvic_probe_of(struct platform_device *pdev)
 239 {
 240         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 241         struct device_node *node = pdev->dev.of_node;
 242         struct omap_dss_device *in;
 243         struct device_node *adapter_node;
 244         struct i2c_adapter *adapter;
 245
 246         in = omapdss_of_find_source_for_first_ep(node);
 247         if (IS_ERR(in)) {
 248                 dev_err(&pdev->dev, "failed to find video source\n");
 249                 return PTR_ERR(in);
 250         }
 251
 252         ddata->in = in;
 253
 254         adapter_node = of_parse_phandle(node, "ddc-i2c-bus", 0);
 255         if (adapter_node) {
 256                 adapter = of_get_i2c_adapter_by_node(adapter_node);
 257                 of_node_put(adapter_node);
 258                 if (adapter == NULL) {
 259                         dev_err(&pdev->dev, "failed to parse ddc-i2c-bus\n");
 260                         omap_dss_put_device(ddata->in);
 261                         return -EPROBE_DEFER;
 262                 }
 263
 264                 ddata->i2c_adapter = adapter;
 265         }
 266
 267         return 0;
 268 }
 269
 270 static int dvic_probe(struct platform_device *pdev)
 271 {
 272         struct panel_drv_data *ddata;
 273         struct omap_dss_device *dssdev;
 274         int r;
 275
 276         if (!pdev->dev.of_node)
 277                 return -ENODEV;
 278
 279         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 280         if (!ddata)
 281                 return -ENOMEM;
 282
 283         platform_set_drvdata(pdev, ddata);
 284
 285         r = dvic_probe_of(pdev);
 286         if (r)
 287                 return r;
 288
 289         ddata->timings = dvic_default_timings;
 290
 291         dssdev = &ddata->dssdev;
 292         dssdev->driver = &dvic_driver;
 293         dssdev->dev = &pdev->dev;
 294         dssdev->type = OMAP_DISPLAY_TYPE_DVI;
 295         dssdev->owner = THIS_MODULE;
 296         dssdev->panel.timings = dvic_default_timings;
 297
 298         r = omapdss_register_display(dssdev);
 299         if (r) {
 300                 dev_err(&pdev->dev, "Failed to register panel\n");
 301                 goto err_reg;
 302         }
 303
 304         return 0;
 305
 306 err_reg:
 307         omap_dss_put_device(ddata->in);
 308
 309         i2c_put_adapter(ddata->i2c_adapter);
 310
 311         return r;
 312 }
 313
 314 static int __exit dvic_remove(struct platform_device *pdev)
 315 {
 316         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
 317         struct omap_dss_device *dssdev = &ddata->dssdev;
 318         struct omap_dss_device *in = ddata->in;
 319
 320         omapdss_unregister_display(&ddata->dssdev);
 321
 322         dvic_disable(dssdev);
 323         dvic_disconnect(dssdev);
 324
 325         omap_dss_put_device(in);
 326
 327         i2c_put_adapter(ddata->i2c_adapter);
 328
 329         return 0;
 330 }
 331
 332 static const struct of_device_id dvic_of_match[] = {
 333         { .compatible = "omapdss,dvi-connector", },
 334         {},
 335 };
 336
 337 MODULE_DEVICE_TABLE(of, dvic_of_match);
 338
 339 static struct platform_driver dvi_connector_driver = {
 340         .probe  = dvic_probe,
 341         .remove = __exit_p(dvic_remove),
 342         .driver = {
 343                 .name   = "connector-dvi",
 344                 .of_match_table = dvic_of_match,
 345                 .suppress_bind_attrs = true,
 346         },
 347 };
 348
 349 module_platform_driver(dvi_connector_driver);
 350
 351 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
 352 MODULE_DESCRIPTION("Generic DVI Connector driver");
 353 MODULE_LICENSE("GPL");