OMAPDSS: remove omap_dss_device's suspend/resume
[linux-3.10.git] / drivers / video / omap2 / displays / panel-tfp410.c
1 /*
2  * TFP410 DPI-to-DVI chip
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-tfp410.h>
28
29 static const struct omap_video_timings tfp410_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         .vsync_level    = OMAPDSS_SIG_ACTIVE_HIGH,
44         .hsync_level    = OMAPDSS_SIG_ACTIVE_HIGH,
45         .data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE,
46         .de_level       = OMAPDSS_SIG_ACTIVE_HIGH,
47         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES,
48 };
49
50 struct panel_drv_data {
51         struct omap_dss_device *dssdev;
52
53         struct mutex lock;
54
55         int pd_gpio;
56
57         struct i2c_adapter *i2c_adapter;
58 };
59
60 static int tfp410_power_on(struct omap_dss_device *dssdev)
61 {
62         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
63         int r;
64
65         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
66                 return 0;
67
68         omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
69         omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
70
71         r = omapdss_dpi_display_enable(dssdev);
72         if (r)
73                 goto err0;
74
75         if (gpio_is_valid(ddata->pd_gpio))
76                 gpio_set_value_cansleep(ddata->pd_gpio, 1);
77
78         return 0;
79 err0:
80         return r;
81 }
82
83 static void tfp410_power_off(struct omap_dss_device *dssdev)
84 {
85         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
86
87         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
88                 return;
89
90         if (gpio_is_valid(ddata->pd_gpio))
91                 gpio_set_value_cansleep(ddata->pd_gpio, 0);
92
93         omapdss_dpi_display_disable(dssdev);
94 }
95
96 static int tfp410_probe(struct omap_dss_device *dssdev)
97 {
98         struct panel_drv_data *ddata;
99         int r;
100         int i2c_bus_num;
101
102         ddata = devm_kzalloc(&dssdev->dev, sizeof(*ddata), GFP_KERNEL);
103         if (!ddata)
104                 return -ENOMEM;
105
106         dssdev->panel.timings = tfp410_default_timings;
107
108         ddata->dssdev = dssdev;
109         mutex_init(&ddata->lock);
110
111         if (dssdev->data) {
112                 struct tfp410_platform_data *pdata = dssdev->data;
113
114                 ddata->pd_gpio = pdata->power_down_gpio;
115                 i2c_bus_num = pdata->i2c_bus_num;
116         } else {
117                 ddata->pd_gpio = -1;
118                 i2c_bus_num = -1;
119         }
120
121         if (gpio_is_valid(ddata->pd_gpio)) {
122                 r = devm_gpio_request_one(&dssdev->dev, ddata->pd_gpio,
123                                 GPIOF_OUT_INIT_LOW, "tfp410 pd");
124                 if (r) {
125                         dev_err(&dssdev->dev, "Failed to request PD GPIO %d\n",
126                                         ddata->pd_gpio);
127                         return r;
128                 }
129         }
130
131         if (i2c_bus_num != -1) {
132                 struct i2c_adapter *adapter;
133
134                 adapter = i2c_get_adapter(i2c_bus_num);
135                 if (!adapter) {
136                         dev_err(&dssdev->dev, "Failed to get I2C adapter, bus %d\n",
137                                         i2c_bus_num);
138                         return -EINVAL;
139                 }
140
141                 ddata->i2c_adapter = adapter;
142         }
143
144         dev_set_drvdata(&dssdev->dev, ddata);
145
146         return 0;
147 }
148
149 static void __exit tfp410_remove(struct omap_dss_device *dssdev)
150 {
151         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
152
153         mutex_lock(&ddata->lock);
154
155         if (ddata->i2c_adapter)
156                 i2c_put_adapter(ddata->i2c_adapter);
157
158         dev_set_drvdata(&dssdev->dev, NULL);
159
160         mutex_unlock(&ddata->lock);
161 }
162
163 static int tfp410_enable(struct omap_dss_device *dssdev)
164 {
165         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
166         int r;
167
168         mutex_lock(&ddata->lock);
169
170         r = tfp410_power_on(dssdev);
171         if (r == 0)
172                 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
173
174         mutex_unlock(&ddata->lock);
175
176         return r;
177 }
178
179 static void tfp410_disable(struct omap_dss_device *dssdev)
180 {
181         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
182
183         mutex_lock(&ddata->lock);
184
185         tfp410_power_off(dssdev);
186
187         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
188
189         mutex_unlock(&ddata->lock);
190 }
191
192 static void tfp410_set_timings(struct omap_dss_device *dssdev,
193                 struct omap_video_timings *timings)
194 {
195         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
196
197         mutex_lock(&ddata->lock);
198         omapdss_dpi_set_timings(dssdev, timings);
199         dssdev->panel.timings = *timings;
200         mutex_unlock(&ddata->lock);
201 }
202
203 static void tfp410_get_timings(struct omap_dss_device *dssdev,
204                 struct omap_video_timings *timings)
205 {
206         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
207
208         mutex_lock(&ddata->lock);
209         *timings = dssdev->panel.timings;
210         mutex_unlock(&ddata->lock);
211 }
212
213 static int tfp410_check_timings(struct omap_dss_device *dssdev,
214                 struct omap_video_timings *timings)
215 {
216         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
217         int r;
218
219         mutex_lock(&ddata->lock);
220         r = dpi_check_timings(dssdev, timings);
221         mutex_unlock(&ddata->lock);
222
223         return r;
224 }
225
226
227 static int tfp410_ddc_read(struct i2c_adapter *adapter,
228                 unsigned char *buf, u16 count, u8 offset)
229 {
230         int r, retries;
231
232         for (retries = 3; retries > 0; retries--) {
233                 struct i2c_msg msgs[] = {
234                         {
235                                 .addr   = DDC_ADDR,
236                                 .flags  = 0,
237                                 .len    = 1,
238                                 .buf    = &offset,
239                         }, {
240                                 .addr   = DDC_ADDR,
241                                 .flags  = I2C_M_RD,
242                                 .len    = count,
243                                 .buf    = buf,
244                         }
245                 };
246
247                 r = i2c_transfer(adapter, msgs, 2);
248                 if (r == 2)
249                         return 0;
250
251                 if (r != -EAGAIN)
252                         break;
253         }
254
255         return r < 0 ? r : -EIO;
256 }
257
258 static int tfp410_read_edid(struct omap_dss_device *dssdev,
259                 u8 *edid, int len)
260 {
261         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
262         int r, l, bytes_read;
263
264         mutex_lock(&ddata->lock);
265
266         if (!ddata->i2c_adapter) {
267                 r = -ENODEV;
268                 goto err;
269         }
270
271         l = min(EDID_LENGTH, len);
272         r = tfp410_ddc_read(ddata->i2c_adapter, edid, l, 0);
273         if (r)
274                 goto err;
275
276         bytes_read = l;
277
278         /* if there are extensions, read second block */
279         if (len > EDID_LENGTH && edid[0x7e] > 0) {
280                 l = min(EDID_LENGTH, len - EDID_LENGTH);
281
282                 r = tfp410_ddc_read(ddata->i2c_adapter, edid + EDID_LENGTH,
283                                 l, EDID_LENGTH);
284                 if (r)
285                         goto err;
286
287                 bytes_read += l;
288         }
289
290         mutex_unlock(&ddata->lock);
291
292         return bytes_read;
293
294 err:
295         mutex_unlock(&ddata->lock);
296         return r;
297 }
298
299 static bool tfp410_detect(struct omap_dss_device *dssdev)
300 {
301         struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
302         unsigned char out;
303         int r;
304
305         mutex_lock(&ddata->lock);
306
307         if (!ddata->i2c_adapter)
308                 goto out;
309
310         r = tfp410_ddc_read(ddata->i2c_adapter, &out, 1, 0);
311
312         mutex_unlock(&ddata->lock);
313
314         return r == 0;
315
316 out:
317         mutex_unlock(&ddata->lock);
318         return true;
319 }
320
321 static struct omap_dss_driver tfp410_driver = {
322         .probe          = tfp410_probe,
323         .remove         = __exit_p(tfp410_remove),
324
325         .enable         = tfp410_enable,
326         .disable        = tfp410_disable,
327
328         .set_timings    = tfp410_set_timings,
329         .get_timings    = tfp410_get_timings,
330         .check_timings  = tfp410_check_timings,
331
332         .read_edid      = tfp410_read_edid,
333         .detect         = tfp410_detect,
334
335         .driver         = {
336                 .name   = "tfp410",
337                 .owner  = THIS_MODULE,
338         },
339 };
340
341 static int __init tfp410_init(void)
342 {
343         return omap_dss_register_driver(&tfp410_driver);
344 }
345
346 static void __exit tfp410_exit(void)
347 {
348         omap_dss_unregister_driver(&tfp410_driver);
349 }
350
351 module_init(tfp410_init);
352 module_exit(tfp410_exit);
353 MODULE_LICENSE("GPL");