]>
Commit | Line | Data |
---|---|---|
f76ee892 TV |
1 | /* |
2 | * Sony ACX565AKM LCD Panel driver | |
3 | * | |
4 | * Copyright (C) 2010 Nokia Corporation | |
5 | * | |
6 | * Original Driver Author: Imre Deak <imre.deak@nokia.com> | |
7 | * Based on panel-generic.c by Tomi Valkeinen <tomi.valkeinen@nokia.com> | |
8 | * Adapted to new DSS2 framework: Roger Quadros <roger.quadros@nokia.com> | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify it | |
11 | * under the terms of the GNU General Public License version 2 as published by | |
12 | * the Free Software Foundation. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
15 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
16 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
17 | * more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License along with | |
20 | * this program. If not, see <http://www.gnu.org/licenses/>. | |
21 | */ | |
22 | ||
23 | #include <linux/kernel.h> | |
24 | #include <linux/module.h> | |
25 | #include <linux/platform_device.h> | |
26 | #include <linux/delay.h> | |
27 | #include <linux/spi/spi.h> | |
28 | #include <linux/jiffies.h> | |
29 | #include <linux/sched.h> | |
30 | #include <linux/backlight.h> | |
31 | #include <linux/fb.h> | |
32 | #include <linux/gpio.h> | |
33 | #include <linux/of.h> | |
34 | #include <linux/of_gpio.h> | |
35 | ||
62d9e44e | 36 | #include <video/omapfb_dss.h> |
f76ee892 TV |
37 | #include <video/omap-panel-data.h> |
38 | ||
39 | #define MIPID_CMD_READ_DISP_ID 0x04 | |
40 | #define MIPID_CMD_READ_RED 0x06 | |
41 | #define MIPID_CMD_READ_GREEN 0x07 | |
42 | #define MIPID_CMD_READ_BLUE 0x08 | |
43 | #define MIPID_CMD_READ_DISP_STATUS 0x09 | |
44 | #define MIPID_CMD_RDDSDR 0x0F | |
45 | #define MIPID_CMD_SLEEP_IN 0x10 | |
46 | #define MIPID_CMD_SLEEP_OUT 0x11 | |
47 | #define MIPID_CMD_DISP_OFF 0x28 | |
48 | #define MIPID_CMD_DISP_ON 0x29 | |
49 | #define MIPID_CMD_WRITE_DISP_BRIGHTNESS 0x51 | |
50 | #define MIPID_CMD_READ_DISP_BRIGHTNESS 0x52 | |
51 | #define MIPID_CMD_WRITE_CTRL_DISP 0x53 | |
52 | ||
53 | #define CTRL_DISP_BRIGHTNESS_CTRL_ON (1 << 5) | |
54 | #define CTRL_DISP_AMBIENT_LIGHT_CTRL_ON (1 << 4) | |
55 | #define CTRL_DISP_BACKLIGHT_ON (1 << 2) | |
56 | #define CTRL_DISP_AUTO_BRIGHTNESS_ON (1 << 1) | |
57 | ||
58 | #define MIPID_CMD_READ_CTRL_DISP 0x54 | |
59 | #define MIPID_CMD_WRITE_CABC 0x55 | |
60 | #define MIPID_CMD_READ_CABC 0x56 | |
61 | ||
62 | #define MIPID_VER_LPH8923 3 | |
63 | #define MIPID_VER_LS041Y3 4 | |
64 | #define MIPID_VER_L4F00311 8 | |
65 | #define MIPID_VER_ACX565AKM 9 | |
66 | ||
67 | struct panel_drv_data { | |
68 | struct omap_dss_device dssdev; | |
69 | struct omap_dss_device *in; | |
70 | ||
71 | int reset_gpio; | |
72 | int datapairs; | |
73 | ||
74 | struct omap_video_timings videomode; | |
75 | ||
76 | char *name; | |
77 | int enabled; | |
78 | int model; | |
79 | int revision; | |
80 | u8 display_id[3]; | |
81 | unsigned has_bc:1; | |
82 | unsigned has_cabc:1; | |
83 | unsigned cabc_mode; | |
84 | unsigned long hw_guard_end; /* next value of jiffies | |
85 | when we can issue the | |
86 | next sleep in/out command */ | |
87 | unsigned long hw_guard_wait; /* max guard time in jiffies */ | |
88 | ||
89 | struct spi_device *spi; | |
90 | struct mutex mutex; | |
91 | ||
92 | struct backlight_device *bl_dev; | |
93 | }; | |
94 | ||
95 | static const struct omap_video_timings acx565akm_panel_timings = { | |
96 | .x_res = 800, | |
97 | .y_res = 480, | |
98 | .pixelclock = 24000000, | |
99 | .hfp = 28, | |
100 | .hsw = 4, | |
101 | .hbp = 24, | |
102 | .vfp = 3, | |
103 | .vsw = 3, | |
104 | .vbp = 4, | |
105 | ||
106 | .vsync_level = OMAPDSS_SIG_ACTIVE_LOW, | |
107 | .hsync_level = OMAPDSS_SIG_ACTIVE_LOW, | |
108 | ||
109 | .data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE, | |
110 | .de_level = OMAPDSS_SIG_ACTIVE_HIGH, | |
111 | .sync_pclk_edge = OMAPDSS_DRIVE_SIG_FALLING_EDGE, | |
112 | }; | |
113 | ||
114 | #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev) | |
115 | ||
116 | static void acx565akm_transfer(struct panel_drv_data *ddata, int cmd, | |
117 | const u8 *wbuf, int wlen, u8 *rbuf, int rlen) | |
118 | { | |
119 | struct spi_message m; | |
120 | struct spi_transfer *x, xfer[5]; | |
121 | int r; | |
122 | ||
123 | BUG_ON(ddata->spi == NULL); | |
124 | ||
125 | spi_message_init(&m); | |
126 | ||
127 | memset(xfer, 0, sizeof(xfer)); | |
128 | x = &xfer[0]; | |
129 | ||
130 | cmd &= 0xff; | |
131 | x->tx_buf = &cmd; | |
132 | x->bits_per_word = 9; | |
133 | x->len = 2; | |
134 | ||
135 | if (rlen > 1 && wlen == 0) { | |
136 | /* | |
137 | * Between the command and the response data there is a | |
138 | * dummy clock cycle. Add an extra bit after the command | |
139 | * word to account for this. | |
140 | */ | |
141 | x->bits_per_word = 10; | |
142 | cmd <<= 1; | |
143 | } | |
144 | spi_message_add_tail(x, &m); | |
145 | ||
146 | if (wlen) { | |
147 | x++; | |
148 | x->tx_buf = wbuf; | |
149 | x->len = wlen; | |
150 | x->bits_per_word = 9; | |
151 | spi_message_add_tail(x, &m); | |
152 | } | |
153 | ||
154 | if (rlen) { | |
155 | x++; | |
156 | x->rx_buf = rbuf; | |
157 | x->len = rlen; | |
158 | spi_message_add_tail(x, &m); | |
159 | } | |
160 | ||
161 | r = spi_sync(ddata->spi, &m); | |
162 | if (r < 0) | |
163 | dev_dbg(&ddata->spi->dev, "spi_sync %d\n", r); | |
164 | } | |
165 | ||
166 | static inline void acx565akm_cmd(struct panel_drv_data *ddata, int cmd) | |
167 | { | |
168 | acx565akm_transfer(ddata, cmd, NULL, 0, NULL, 0); | |
169 | } | |
170 | ||
171 | static inline void acx565akm_write(struct panel_drv_data *ddata, | |
172 | int reg, const u8 *buf, int len) | |
173 | { | |
174 | acx565akm_transfer(ddata, reg, buf, len, NULL, 0); | |
175 | } | |
176 | ||
177 | static inline void acx565akm_read(struct panel_drv_data *ddata, | |
178 | int reg, u8 *buf, int len) | |
179 | { | |
180 | acx565akm_transfer(ddata, reg, NULL, 0, buf, len); | |
181 | } | |
182 | ||
183 | static void hw_guard_start(struct panel_drv_data *ddata, int guard_msec) | |
184 | { | |
185 | ddata->hw_guard_wait = msecs_to_jiffies(guard_msec); | |
186 | ddata->hw_guard_end = jiffies + ddata->hw_guard_wait; | |
187 | } | |
188 | ||
189 | static void hw_guard_wait(struct panel_drv_data *ddata) | |
190 | { | |
191 | unsigned long wait = ddata->hw_guard_end - jiffies; | |
192 | ||
193 | if ((long)wait > 0 && wait <= ddata->hw_guard_wait) { | |
194 | set_current_state(TASK_UNINTERRUPTIBLE); | |
195 | schedule_timeout(wait); | |
196 | } | |
197 | } | |
198 | ||
199 | static void set_sleep_mode(struct panel_drv_data *ddata, int on) | |
200 | { | |
201 | int cmd; | |
202 | ||
203 | if (on) | |
204 | cmd = MIPID_CMD_SLEEP_IN; | |
205 | else | |
206 | cmd = MIPID_CMD_SLEEP_OUT; | |
207 | /* | |
208 | * We have to keep 120msec between sleep in/out commands. | |
209 | * (8.2.15, 8.2.16). | |
210 | */ | |
211 | hw_guard_wait(ddata); | |
212 | acx565akm_cmd(ddata, cmd); | |
213 | hw_guard_start(ddata, 120); | |
214 | } | |
215 | ||
216 | static void set_display_state(struct panel_drv_data *ddata, int enabled) | |
217 | { | |
218 | int cmd = enabled ? MIPID_CMD_DISP_ON : MIPID_CMD_DISP_OFF; | |
219 | ||
220 | acx565akm_cmd(ddata, cmd); | |
221 | } | |
222 | ||
223 | static int panel_enabled(struct panel_drv_data *ddata) | |
224 | { | |
225 | u32 disp_status; | |
226 | int enabled; | |
227 | ||
228 | acx565akm_read(ddata, MIPID_CMD_READ_DISP_STATUS, | |
229 | (u8 *)&disp_status, 4); | |
230 | disp_status = __be32_to_cpu(disp_status); | |
231 | enabled = (disp_status & (1 << 17)) && (disp_status & (1 << 10)); | |
232 | dev_dbg(&ddata->spi->dev, | |
233 | "LCD panel %senabled by bootloader (status 0x%04x)\n", | |
234 | enabled ? "" : "not ", disp_status); | |
235 | return enabled; | |
236 | } | |
237 | ||
238 | static int panel_detect(struct panel_drv_data *ddata) | |
239 | { | |
240 | acx565akm_read(ddata, MIPID_CMD_READ_DISP_ID, ddata->display_id, 3); | |
241 | dev_dbg(&ddata->spi->dev, "MIPI display ID: %02x%02x%02x\n", | |
242 | ddata->display_id[0], | |
243 | ddata->display_id[1], | |
244 | ddata->display_id[2]); | |
245 | ||
246 | switch (ddata->display_id[0]) { | |
247 | case 0x10: | |
248 | ddata->model = MIPID_VER_ACX565AKM; | |
249 | ddata->name = "acx565akm"; | |
250 | ddata->has_bc = 1; | |
251 | ddata->has_cabc = 1; | |
252 | break; | |
253 | case 0x29: | |
254 | ddata->model = MIPID_VER_L4F00311; | |
255 | ddata->name = "l4f00311"; | |
256 | break; | |
257 | case 0x45: | |
258 | ddata->model = MIPID_VER_LPH8923; | |
259 | ddata->name = "lph8923"; | |
260 | break; | |
261 | case 0x83: | |
262 | ddata->model = MIPID_VER_LS041Y3; | |
263 | ddata->name = "ls041y3"; | |
264 | break; | |
265 | default: | |
266 | ddata->name = "unknown"; | |
267 | dev_err(&ddata->spi->dev, "invalid display ID\n"); | |
268 | return -ENODEV; | |
269 | } | |
270 | ||
271 | ddata->revision = ddata->display_id[1]; | |
272 | ||
273 | dev_info(&ddata->spi->dev, "omapfb: %s rev %02x LCD detected\n", | |
274 | ddata->name, ddata->revision); | |
275 | ||
276 | return 0; | |
277 | } | |
278 | ||
279 | /*----------------------Backlight Control-------------------------*/ | |
280 | ||
281 | static void enable_backlight_ctrl(struct panel_drv_data *ddata, int enable) | |
282 | { | |
283 | u16 ctrl; | |
284 | ||
285 | acx565akm_read(ddata, MIPID_CMD_READ_CTRL_DISP, (u8 *)&ctrl, 1); | |
286 | if (enable) { | |
287 | ctrl |= CTRL_DISP_BRIGHTNESS_CTRL_ON | | |
288 | CTRL_DISP_BACKLIGHT_ON; | |
289 | } else { | |
290 | ctrl &= ~(CTRL_DISP_BRIGHTNESS_CTRL_ON | | |
291 | CTRL_DISP_BACKLIGHT_ON); | |
292 | } | |
293 | ||
294 | ctrl |= 1 << 8; | |
295 | acx565akm_write(ddata, MIPID_CMD_WRITE_CTRL_DISP, (u8 *)&ctrl, 2); | |
296 | } | |
297 | ||
298 | static void set_cabc_mode(struct panel_drv_data *ddata, unsigned mode) | |
299 | { | |
300 | u16 cabc_ctrl; | |
301 | ||
302 | ddata->cabc_mode = mode; | |
303 | if (!ddata->enabled) | |
304 | return; | |
305 | cabc_ctrl = 0; | |
306 | acx565akm_read(ddata, MIPID_CMD_READ_CABC, (u8 *)&cabc_ctrl, 1); | |
307 | cabc_ctrl &= ~3; | |
308 | cabc_ctrl |= (1 << 8) | (mode & 3); | |
309 | acx565akm_write(ddata, MIPID_CMD_WRITE_CABC, (u8 *)&cabc_ctrl, 2); | |
310 | } | |
311 | ||
312 | static unsigned get_cabc_mode(struct panel_drv_data *ddata) | |
313 | { | |
314 | return ddata->cabc_mode; | |
315 | } | |
316 | ||
317 | static unsigned get_hw_cabc_mode(struct panel_drv_data *ddata) | |
318 | { | |
319 | u8 cabc_ctrl; | |
320 | ||
321 | acx565akm_read(ddata, MIPID_CMD_READ_CABC, &cabc_ctrl, 1); | |
322 | return cabc_ctrl & 3; | |
323 | } | |
324 | ||
325 | static void acx565akm_set_brightness(struct panel_drv_data *ddata, int level) | |
326 | { | |
327 | int bv; | |
328 | ||
329 | bv = level | (1 << 8); | |
330 | acx565akm_write(ddata, MIPID_CMD_WRITE_DISP_BRIGHTNESS, (u8 *)&bv, 2); | |
331 | ||
332 | if (level) | |
333 | enable_backlight_ctrl(ddata, 1); | |
334 | else | |
335 | enable_backlight_ctrl(ddata, 0); | |
336 | } | |
337 | ||
338 | static int acx565akm_get_actual_brightness(struct panel_drv_data *ddata) | |
339 | { | |
340 | u8 bv; | |
341 | ||
342 | acx565akm_read(ddata, MIPID_CMD_READ_DISP_BRIGHTNESS, &bv, 1); | |
343 | ||
344 | return bv; | |
345 | } | |
346 | ||
347 | ||
348 | static int acx565akm_bl_update_status(struct backlight_device *dev) | |
349 | { | |
350 | struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev); | |
351 | int level; | |
352 | ||
353 | dev_dbg(&ddata->spi->dev, "%s\n", __func__); | |
354 | ||
355 | if (dev->props.fb_blank == FB_BLANK_UNBLANK && | |
356 | dev->props.power == FB_BLANK_UNBLANK) | |
357 | level = dev->props.brightness; | |
358 | else | |
359 | level = 0; | |
360 | ||
361 | if (ddata->has_bc) | |
362 | acx565akm_set_brightness(ddata, level); | |
363 | else | |
364 | return -ENODEV; | |
365 | ||
366 | return 0; | |
367 | } | |
368 | ||
369 | static int acx565akm_bl_get_intensity(struct backlight_device *dev) | |
370 | { | |
371 | struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev); | |
372 | ||
373 | dev_dbg(&dev->dev, "%s\n", __func__); | |
374 | ||
375 | if (!ddata->has_bc) | |
376 | return -ENODEV; | |
377 | ||
378 | if (dev->props.fb_blank == FB_BLANK_UNBLANK && | |
379 | dev->props.power == FB_BLANK_UNBLANK) { | |
380 | if (ddata->has_bc) | |
381 | return acx565akm_get_actual_brightness(ddata); | |
382 | else | |
383 | return dev->props.brightness; | |
384 | } | |
385 | ||
386 | return 0; | |
387 | } | |
388 | ||
389 | static int acx565akm_bl_update_status_locked(struct backlight_device *dev) | |
390 | { | |
391 | struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev); | |
392 | int r; | |
393 | ||
394 | mutex_lock(&ddata->mutex); | |
395 | r = acx565akm_bl_update_status(dev); | |
396 | mutex_unlock(&ddata->mutex); | |
397 | ||
398 | return r; | |
399 | } | |
400 | ||
401 | static int acx565akm_bl_get_intensity_locked(struct backlight_device *dev) | |
402 | { | |
403 | struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev); | |
404 | int r; | |
405 | ||
406 | mutex_lock(&ddata->mutex); | |
407 | r = acx565akm_bl_get_intensity(dev); | |
408 | mutex_unlock(&ddata->mutex); | |
409 | ||
410 | return r; | |
411 | } | |
412 | ||
413 | static const struct backlight_ops acx565akm_bl_ops = { | |
414 | .get_brightness = acx565akm_bl_get_intensity_locked, | |
415 | .update_status = acx565akm_bl_update_status_locked, | |
416 | }; | |
417 | ||
418 | /*--------------------Auto Brightness control via Sysfs---------------------*/ | |
419 | ||
420 | static const char * const cabc_modes[] = { | |
421 | "off", /* always used when CABC is not supported */ | |
422 | "ui", | |
423 | "still-image", | |
424 | "moving-image", | |
425 | }; | |
426 | ||
427 | static ssize_t show_cabc_mode(struct device *dev, | |
428 | struct device_attribute *attr, | |
429 | char *buf) | |
430 | { | |
431 | struct panel_drv_data *ddata = dev_get_drvdata(dev); | |
432 | const char *mode_str; | |
433 | int mode; | |
434 | int len; | |
435 | ||
436 | if (!ddata->has_cabc) | |
437 | mode = 0; | |
438 | else | |
439 | mode = get_cabc_mode(ddata); | |
440 | mode_str = "unknown"; | |
441 | if (mode >= 0 && mode < ARRAY_SIZE(cabc_modes)) | |
442 | mode_str = cabc_modes[mode]; | |
443 | len = snprintf(buf, PAGE_SIZE, "%s\n", mode_str); | |
444 | ||
445 | return len < PAGE_SIZE - 1 ? len : PAGE_SIZE - 1; | |
446 | } | |
447 | ||
448 | static ssize_t store_cabc_mode(struct device *dev, | |
449 | struct device_attribute *attr, | |
450 | const char *buf, size_t count) | |
451 | { | |
452 | struct panel_drv_data *ddata = dev_get_drvdata(dev); | |
453 | int i; | |
454 | ||
455 | for (i = 0; i < ARRAY_SIZE(cabc_modes); i++) { | |
456 | const char *mode_str = cabc_modes[i]; | |
457 | int cmp_len = strlen(mode_str); | |
458 | ||
459 | if (count > 0 && buf[count - 1] == '\n') | |
460 | count--; | |
461 | if (count != cmp_len) | |
462 | continue; | |
463 | ||
464 | if (strncmp(buf, mode_str, cmp_len) == 0) | |
465 | break; | |
466 | } | |
467 | ||
468 | if (i == ARRAY_SIZE(cabc_modes)) | |
469 | return -EINVAL; | |
470 | ||
471 | if (!ddata->has_cabc && i != 0) | |
472 | return -EINVAL; | |
473 | ||
474 | mutex_lock(&ddata->mutex); | |
475 | set_cabc_mode(ddata, i); | |
476 | mutex_unlock(&ddata->mutex); | |
477 | ||
478 | return count; | |
479 | } | |
480 | ||
481 | static ssize_t show_cabc_available_modes(struct device *dev, | |
482 | struct device_attribute *attr, | |
483 | char *buf) | |
484 | { | |
485 | struct panel_drv_data *ddata = dev_get_drvdata(dev); | |
486 | int len; | |
487 | int i; | |
488 | ||
489 | if (!ddata->has_cabc) | |
490 | return snprintf(buf, PAGE_SIZE, "%s\n", cabc_modes[0]); | |
491 | ||
492 | for (i = 0, len = 0; | |
493 | len < PAGE_SIZE && i < ARRAY_SIZE(cabc_modes); i++) | |
494 | len += snprintf(&buf[len], PAGE_SIZE - len, "%s%s%s", | |
495 | i ? " " : "", cabc_modes[i], | |
496 | i == ARRAY_SIZE(cabc_modes) - 1 ? "\n" : ""); | |
497 | ||
498 | return len < PAGE_SIZE ? len : PAGE_SIZE - 1; | |
499 | } | |
500 | ||
501 | static DEVICE_ATTR(cabc_mode, S_IRUGO | S_IWUSR, | |
502 | show_cabc_mode, store_cabc_mode); | |
503 | static DEVICE_ATTR(cabc_available_modes, S_IRUGO, | |
504 | show_cabc_available_modes, NULL); | |
505 | ||
506 | static struct attribute *bldev_attrs[] = { | |
507 | &dev_attr_cabc_mode.attr, | |
508 | &dev_attr_cabc_available_modes.attr, | |
509 | NULL, | |
510 | }; | |
511 | ||
a8fb2d65 | 512 | static const struct attribute_group bldev_attr_group = { |
f76ee892 TV |
513 | .attrs = bldev_attrs, |
514 | }; | |
515 | ||
516 | static int acx565akm_connect(struct omap_dss_device *dssdev) | |
517 | { | |
518 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
519 | struct omap_dss_device *in = ddata->in; | |
520 | int r; | |
521 | ||
522 | if (omapdss_device_is_connected(dssdev)) | |
523 | return 0; | |
524 | ||
525 | r = in->ops.sdi->connect(in, dssdev); | |
526 | if (r) | |
527 | return r; | |
528 | ||
529 | return 0; | |
530 | } | |
531 | ||
532 | static void acx565akm_disconnect(struct omap_dss_device *dssdev) | |
533 | { | |
534 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
535 | struct omap_dss_device *in = ddata->in; | |
536 | ||
537 | if (!omapdss_device_is_connected(dssdev)) | |
538 | return; | |
539 | ||
540 | in->ops.sdi->disconnect(in, dssdev); | |
541 | } | |
542 | ||
543 | static int acx565akm_panel_power_on(struct omap_dss_device *dssdev) | |
544 | { | |
545 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
546 | struct omap_dss_device *in = ddata->in; | |
547 | int r; | |
548 | ||
549 | dev_dbg(&ddata->spi->dev, "%s\n", __func__); | |
550 | ||
551 | in->ops.sdi->set_timings(in, &ddata->videomode); | |
552 | ||
553 | if (ddata->datapairs > 0) | |
554 | in->ops.sdi->set_datapairs(in, ddata->datapairs); | |
555 | ||
556 | r = in->ops.sdi->enable(in); | |
557 | if (r) { | |
558 | pr_err("%s sdi enable failed\n", __func__); | |
559 | return r; | |
560 | } | |
561 | ||
562 | /*FIXME tweak me */ | |
563 | msleep(50); | |
564 | ||
565 | if (gpio_is_valid(ddata->reset_gpio)) | |
566 | gpio_set_value(ddata->reset_gpio, 1); | |
567 | ||
568 | if (ddata->enabled) { | |
569 | dev_dbg(&ddata->spi->dev, "panel already enabled\n"); | |
570 | return 0; | |
571 | } | |
572 | ||
573 | /* | |
574 | * We have to meet all the following delay requirements: | |
575 | * 1. tRW: reset pulse width 10usec (7.12.1) | |
576 | * 2. tRT: reset cancel time 5msec (7.12.1) | |
577 | * 3. Providing PCLK,HS,VS signals for 2 frames = ~50msec worst | |
578 | * case (7.6.2) | |
579 | * 4. 120msec before the sleep out command (7.12.1) | |
580 | */ | |
581 | msleep(120); | |
582 | ||
583 | set_sleep_mode(ddata, 0); | |
584 | ddata->enabled = 1; | |
585 | ||
586 | /* 5msec between sleep out and the next command. (8.2.16) */ | |
587 | usleep_range(5000, 10000); | |
588 | set_display_state(ddata, 1); | |
589 | set_cabc_mode(ddata, ddata->cabc_mode); | |
590 | ||
591 | return acx565akm_bl_update_status(ddata->bl_dev); | |
592 | } | |
593 | ||
594 | static void acx565akm_panel_power_off(struct omap_dss_device *dssdev) | |
595 | { | |
596 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
597 | struct omap_dss_device *in = ddata->in; | |
598 | ||
599 | dev_dbg(dssdev->dev, "%s\n", __func__); | |
600 | ||
601 | if (!ddata->enabled) | |
602 | return; | |
603 | ||
604 | set_display_state(ddata, 0); | |
605 | set_sleep_mode(ddata, 1); | |
606 | ddata->enabled = 0; | |
607 | /* | |
608 | * We have to provide PCLK,HS,VS signals for 2 frames (worst case | |
609 | * ~50msec) after sending the sleep in command and asserting the | |
610 | * reset signal. We probably could assert the reset w/o the delay | |
611 | * but we still delay to avoid possible artifacts. (7.6.1) | |
612 | */ | |
613 | msleep(50); | |
614 | ||
615 | if (gpio_is_valid(ddata->reset_gpio)) | |
616 | gpio_set_value(ddata->reset_gpio, 0); | |
617 | ||
618 | /* FIXME need to tweak this delay */ | |
619 | msleep(100); | |
620 | ||
621 | in->ops.sdi->disable(in); | |
622 | } | |
623 | ||
624 | static int acx565akm_enable(struct omap_dss_device *dssdev) | |
625 | { | |
626 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
627 | int r; | |
628 | ||
629 | dev_dbg(dssdev->dev, "%s\n", __func__); | |
630 | ||
631 | if (!omapdss_device_is_connected(dssdev)) | |
632 | return -ENODEV; | |
633 | ||
634 | if (omapdss_device_is_enabled(dssdev)) | |
635 | return 0; | |
636 | ||
637 | mutex_lock(&ddata->mutex); | |
638 | r = acx565akm_panel_power_on(dssdev); | |
639 | mutex_unlock(&ddata->mutex); | |
640 | if (r) | |
641 | return r; | |
642 | ||
643 | dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; | |
644 | ||
645 | return 0; | |
646 | } | |
647 | ||
648 | static void acx565akm_disable(struct omap_dss_device *dssdev) | |
649 | { | |
650 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
651 | ||
652 | dev_dbg(dssdev->dev, "%s\n", __func__); | |
653 | ||
654 | if (!omapdss_device_is_enabled(dssdev)) | |
655 | return; | |
656 | ||
657 | mutex_lock(&ddata->mutex); | |
658 | acx565akm_panel_power_off(dssdev); | |
659 | mutex_unlock(&ddata->mutex); | |
660 | ||
661 | dssdev->state = OMAP_DSS_DISPLAY_DISABLED; | |
662 | } | |
663 | ||
664 | static void acx565akm_set_timings(struct omap_dss_device *dssdev, | |
665 | struct omap_video_timings *timings) | |
666 | { | |
667 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
668 | struct omap_dss_device *in = ddata->in; | |
669 | ||
670 | ddata->videomode = *timings; | |
671 | dssdev->panel.timings = *timings; | |
672 | ||
673 | in->ops.sdi->set_timings(in, timings); | |
674 | } | |
675 | ||
676 | static void acx565akm_get_timings(struct omap_dss_device *dssdev, | |
677 | struct omap_video_timings *timings) | |
678 | { | |
679 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
680 | ||
681 | *timings = ddata->videomode; | |
682 | } | |
683 | ||
684 | static int acx565akm_check_timings(struct omap_dss_device *dssdev, | |
685 | struct omap_video_timings *timings) | |
686 | { | |
687 | struct panel_drv_data *ddata = to_panel_data(dssdev); | |
688 | struct omap_dss_device *in = ddata->in; | |
689 | ||
690 | return in->ops.sdi->check_timings(in, timings); | |
691 | } | |
692 | ||
693 | static struct omap_dss_driver acx565akm_ops = { | |
694 | .connect = acx565akm_connect, | |
695 | .disconnect = acx565akm_disconnect, | |
696 | ||
697 | .enable = acx565akm_enable, | |
698 | .disable = acx565akm_disable, | |
699 | ||
700 | .set_timings = acx565akm_set_timings, | |
701 | .get_timings = acx565akm_get_timings, | |
702 | .check_timings = acx565akm_check_timings, | |
703 | ||
704 | .get_resolution = omapdss_default_get_resolution, | |
705 | }; | |
706 | ||
707 | static int acx565akm_probe_pdata(struct spi_device *spi) | |
708 | { | |
709 | const struct panel_acx565akm_platform_data *pdata; | |
710 | struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev); | |
711 | struct omap_dss_device *dssdev, *in; | |
712 | ||
713 | pdata = dev_get_platdata(&spi->dev); | |
714 | ||
715 | ddata->reset_gpio = pdata->reset_gpio; | |
716 | ||
717 | in = omap_dss_find_output(pdata->source); | |
718 | if (in == NULL) { | |
719 | dev_err(&spi->dev, "failed to find video source '%s'\n", | |
720 | pdata->source); | |
721 | return -EPROBE_DEFER; | |
722 | } | |
723 | ddata->in = in; | |
724 | ||
725 | ddata->datapairs = pdata->datapairs; | |
726 | ||
727 | dssdev = &ddata->dssdev; | |
728 | dssdev->name = pdata->name; | |
729 | ||
730 | return 0; | |
731 | } | |
732 | ||
733 | static int acx565akm_probe_of(struct spi_device *spi) | |
734 | { | |
735 | struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev); | |
736 | struct device_node *np = spi->dev.of_node; | |
737 | ||
738 | ddata->reset_gpio = of_get_named_gpio(np, "reset-gpios", 0); | |
739 | ||
740 | ddata->in = omapdss_of_find_source_for_first_ep(np); | |
741 | if (IS_ERR(ddata->in)) { | |
742 | dev_err(&spi->dev, "failed to find video source\n"); | |
743 | return PTR_ERR(ddata->in); | |
744 | } | |
745 | ||
746 | return 0; | |
747 | } | |
748 | ||
749 | static int acx565akm_probe(struct spi_device *spi) | |
750 | { | |
751 | struct panel_drv_data *ddata; | |
752 | struct omap_dss_device *dssdev; | |
753 | struct backlight_device *bldev; | |
754 | int max_brightness, brightness; | |
755 | struct backlight_properties props; | |
756 | int r; | |
757 | ||
758 | dev_dbg(&spi->dev, "%s\n", __func__); | |
759 | ||
760 | spi->mode = SPI_MODE_3; | |
761 | ||
762 | ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL); | |
763 | if (ddata == NULL) | |
764 | return -ENOMEM; | |
765 | ||
766 | dev_set_drvdata(&spi->dev, ddata); | |
767 | ||
768 | ddata->spi = spi; | |
769 | ||
770 | mutex_init(&ddata->mutex); | |
771 | ||
772 | if (dev_get_platdata(&spi->dev)) { | |
773 | r = acx565akm_probe_pdata(spi); | |
774 | if (r) | |
775 | return r; | |
776 | } else if (spi->dev.of_node) { | |
777 | r = acx565akm_probe_of(spi); | |
778 | if (r) | |
779 | return r; | |
780 | } else { | |
781 | dev_err(&spi->dev, "platform data missing!\n"); | |
782 | return -ENODEV; | |
783 | } | |
784 | ||
785 | if (gpio_is_valid(ddata->reset_gpio)) { | |
786 | r = devm_gpio_request_one(&spi->dev, ddata->reset_gpio, | |
787 | GPIOF_OUT_INIT_LOW, "lcd reset"); | |
788 | if (r) | |
789 | goto err_gpio; | |
790 | } | |
791 | ||
792 | if (gpio_is_valid(ddata->reset_gpio)) | |
793 | gpio_set_value(ddata->reset_gpio, 1); | |
794 | ||
795 | /* | |
796 | * After reset we have to wait 5 msec before the first | |
797 | * command can be sent. | |
798 | */ | |
799 | usleep_range(5000, 10000); | |
800 | ||
801 | ddata->enabled = panel_enabled(ddata); | |
802 | ||
803 | r = panel_detect(ddata); | |
804 | ||
805 | if (!ddata->enabled && gpio_is_valid(ddata->reset_gpio)) | |
806 | gpio_set_value(ddata->reset_gpio, 0); | |
807 | ||
808 | if (r) { | |
809 | dev_err(&spi->dev, "%s panel detect error\n", __func__); | |
810 | goto err_detect; | |
811 | } | |
812 | ||
813 | memset(&props, 0, sizeof(props)); | |
814 | props.fb_blank = FB_BLANK_UNBLANK; | |
815 | props.power = FB_BLANK_UNBLANK; | |
816 | props.type = BACKLIGHT_RAW; | |
817 | ||
818 | bldev = backlight_device_register("acx565akm", &ddata->spi->dev, | |
819 | ddata, &acx565akm_bl_ops, &props); | |
820 | if (IS_ERR(bldev)) { | |
821 | r = PTR_ERR(bldev); | |
822 | goto err_reg_bl; | |
823 | } | |
824 | ddata->bl_dev = bldev; | |
825 | if (ddata->has_cabc) { | |
826 | r = sysfs_create_group(&bldev->dev.kobj, &bldev_attr_group); | |
827 | if (r) { | |
828 | dev_err(&bldev->dev, | |
829 | "%s failed to create sysfs files\n", __func__); | |
830 | goto err_sysfs; | |
831 | } | |
832 | ddata->cabc_mode = get_hw_cabc_mode(ddata); | |
833 | } | |
834 | ||
835 | max_brightness = 255; | |
836 | ||
837 | if (ddata->has_bc) | |
838 | brightness = acx565akm_get_actual_brightness(ddata); | |
839 | else | |
840 | brightness = 0; | |
841 | ||
842 | bldev->props.max_brightness = max_brightness; | |
843 | bldev->props.brightness = brightness; | |
844 | ||
845 | acx565akm_bl_update_status(bldev); | |
846 | ||
847 | ||
848 | ddata->videomode = acx565akm_panel_timings; | |
849 | ||
850 | dssdev = &ddata->dssdev; | |
851 | dssdev->dev = &spi->dev; | |
852 | dssdev->driver = &acx565akm_ops; | |
853 | dssdev->type = OMAP_DISPLAY_TYPE_SDI; | |
854 | dssdev->owner = THIS_MODULE; | |
855 | dssdev->panel.timings = ddata->videomode; | |
856 | ||
857 | r = omapdss_register_display(dssdev); | |
858 | if (r) { | |
859 | dev_err(&spi->dev, "Failed to register panel\n"); | |
860 | goto err_reg; | |
861 | } | |
862 | ||
863 | return 0; | |
864 | ||
865 | err_reg: | |
866 | sysfs_remove_group(&bldev->dev.kobj, &bldev_attr_group); | |
867 | err_sysfs: | |
868 | backlight_device_unregister(bldev); | |
869 | err_reg_bl: | |
870 | err_detect: | |
871 | err_gpio: | |
872 | omap_dss_put_device(ddata->in); | |
873 | return r; | |
874 | } | |
875 | ||
876 | static int acx565akm_remove(struct spi_device *spi) | |
877 | { | |
878 | struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev); | |
879 | struct omap_dss_device *dssdev = &ddata->dssdev; | |
880 | struct omap_dss_device *in = ddata->in; | |
881 | ||
882 | dev_dbg(&ddata->spi->dev, "%s\n", __func__); | |
883 | ||
884 | sysfs_remove_group(&ddata->bl_dev->dev.kobj, &bldev_attr_group); | |
885 | backlight_device_unregister(ddata->bl_dev); | |
886 | ||
887 | omapdss_unregister_display(dssdev); | |
888 | ||
889 | acx565akm_disable(dssdev); | |
890 | acx565akm_disconnect(dssdev); | |
891 | ||
892 | omap_dss_put_device(in); | |
893 | ||
894 | return 0; | |
895 | } | |
896 | ||
897 | static const struct of_device_id acx565akm_of_match[] = { | |
898 | { .compatible = "omapdss,sony,acx565akm", }, | |
899 | {}, | |
900 | }; | |
901 | MODULE_DEVICE_TABLE(of, acx565akm_of_match); | |
902 | ||
903 | static struct spi_driver acx565akm_driver = { | |
904 | .driver = { | |
905 | .name = "acx565akm", | |
906 | .of_match_table = acx565akm_of_match, | |
907 | .suppress_bind_attrs = true, | |
908 | }, | |
909 | .probe = acx565akm_probe, | |
910 | .remove = acx565akm_remove, | |
911 | }; | |
912 | ||
913 | module_spi_driver(acx565akm_driver); | |
914 | ||
915 | MODULE_AUTHOR("Nokia Corporation"); | |
916 | MODULE_DESCRIPTION("acx565akm LCD Driver"); | |
917 | MODULE_LICENSE("GPL"); |