Loading...
1/*
2 * linux/drivers/video/omap2/dss/dpi.c
3 *
4 * Copyright (C) 2009 Nokia Corporation
5 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
6 *
7 * Some code and ideas taken from drivers/video/omap/ driver
8 * by Imre Deak.
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#define DSS_SUBSYS_NAME "DPI"
24
25#include <linux/kernel.h>
26#include <linux/delay.h>
27#include <linux/export.h>
28#include <linux/err.h>
29#include <linux/errno.h>
30#include <linux/platform_device.h>
31#include <linux/regulator/consumer.h>
32#include <linux/string.h>
33#include <linux/of.h>
34#include <linux/clk.h>
35#include <linux/component.h>
36
37#include <video/omapdss.h>
38
39#include "dss.h"
40#include "dss_features.h"
41
42#define HSDIV_DISPC 0
43
44struct dpi_data {
45 struct platform_device *pdev;
46
47 struct regulator *vdds_dsi_reg;
48 struct dss_pll *pll;
49
50 struct mutex lock;
51
52 struct omap_video_timings timings;
53 struct dss_lcd_mgr_config mgr_config;
54 int data_lines;
55
56 struct omap_dss_device output;
57
58 bool port_initialized;
59};
60
61static struct dpi_data *dpi_get_data_from_dssdev(struct omap_dss_device *dssdev)
62{
63 return container_of(dssdev, struct dpi_data, output);
64}
65
66/* only used in non-DT mode */
67static struct dpi_data *dpi_get_data_from_pdev(struct platform_device *pdev)
68{
69 return dev_get_drvdata(&pdev->dev);
70}
71
72static struct dss_pll *dpi_get_pll(enum omap_channel channel)
73{
74 /*
75 * XXX we can't currently use DSI PLL for DPI with OMAP3, as the DSI PLL
76 * would also be used for DISPC fclk. Meaning, when the DPI output is
77 * disabled, DISPC clock will be disabled, and TV out will stop.
78 */
79 switch (omapdss_get_version()) {
80 case OMAPDSS_VER_OMAP24xx:
81 case OMAPDSS_VER_OMAP34xx_ES1:
82 case OMAPDSS_VER_OMAP34xx_ES3:
83 case OMAPDSS_VER_OMAP3630:
84 case OMAPDSS_VER_AM35xx:
85 case OMAPDSS_VER_AM43xx:
86 return NULL;
87
88 case OMAPDSS_VER_OMAP4430_ES1:
89 case OMAPDSS_VER_OMAP4430_ES2:
90 case OMAPDSS_VER_OMAP4:
91 switch (channel) {
92 case OMAP_DSS_CHANNEL_LCD:
93 return dss_pll_find("dsi0");
94 case OMAP_DSS_CHANNEL_LCD2:
95 return dss_pll_find("dsi1");
96 default:
97 return NULL;
98 }
99
100 case OMAPDSS_VER_OMAP5:
101 switch (channel) {
102 case OMAP_DSS_CHANNEL_LCD:
103 return dss_pll_find("dsi0");
104 case OMAP_DSS_CHANNEL_LCD3:
105 return dss_pll_find("dsi1");
106 default:
107 return NULL;
108 }
109
110 case OMAPDSS_VER_DRA7xx:
111 switch (channel) {
112 case OMAP_DSS_CHANNEL_LCD:
113 case OMAP_DSS_CHANNEL_LCD2:
114 return dss_pll_find("video0");
115 case OMAP_DSS_CHANNEL_LCD3:
116 return dss_pll_find("video1");
117 default:
118 return NULL;
119 }
120
121 default:
122 return NULL;
123 }
124}
125
126static enum omap_dss_clk_source dpi_get_alt_clk_src(enum omap_channel channel)
127{
128 switch (channel) {
129 case OMAP_DSS_CHANNEL_LCD:
130 return OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC;
131 case OMAP_DSS_CHANNEL_LCD2:
132 return OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC;
133 case OMAP_DSS_CHANNEL_LCD3:
134 return OMAP_DSS_CLK_SRC_DSI2_PLL_HSDIV_DISPC;
135 default:
136 /* this shouldn't happen */
137 WARN_ON(1);
138 return OMAP_DSS_CLK_SRC_FCK;
139 }
140}
141
142struct dpi_clk_calc_ctx {
143 struct dss_pll *pll;
144
145 /* inputs */
146
147 unsigned long pck_min, pck_max;
148
149 /* outputs */
150
151 struct dss_pll_clock_info dsi_cinfo;
152 unsigned long fck;
153 struct dispc_clock_info dispc_cinfo;
154};
155
156static bool dpi_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
157 unsigned long pck, void *data)
158{
159 struct dpi_clk_calc_ctx *ctx = data;
160
161 /*
162 * Odd dividers give us uneven duty cycle, causing problem when level
163 * shifted. So skip all odd dividers when the pixel clock is on the
164 * higher side.
165 */
166 if (ctx->pck_min >= 100000000) {
167 if (lckd > 1 && lckd % 2 != 0)
168 return false;
169
170 if (pckd > 1 && pckd % 2 != 0)
171 return false;
172 }
173
174 ctx->dispc_cinfo.lck_div = lckd;
175 ctx->dispc_cinfo.pck_div = pckd;
176 ctx->dispc_cinfo.lck = lck;
177 ctx->dispc_cinfo.pck = pck;
178
179 return true;
180}
181
182
183static bool dpi_calc_hsdiv_cb(int m_dispc, unsigned long dispc,
184 void *data)
185{
186 struct dpi_clk_calc_ctx *ctx = data;
187
188 /*
189 * Odd dividers give us uneven duty cycle, causing problem when level
190 * shifted. So skip all odd dividers when the pixel clock is on the
191 * higher side.
192 */
193 if (m_dispc > 1 && m_dispc % 2 != 0 && ctx->pck_min >= 100000000)
194 return false;
195
196 ctx->dsi_cinfo.mX[HSDIV_DISPC] = m_dispc;
197 ctx->dsi_cinfo.clkout[HSDIV_DISPC] = dispc;
198
199 return dispc_div_calc(dispc, ctx->pck_min, ctx->pck_max,
200 dpi_calc_dispc_cb, ctx);
201}
202
203
204static bool dpi_calc_pll_cb(int n, int m, unsigned long fint,
205 unsigned long clkdco,
206 void *data)
207{
208 struct dpi_clk_calc_ctx *ctx = data;
209
210 ctx->dsi_cinfo.n = n;
211 ctx->dsi_cinfo.m = m;
212 ctx->dsi_cinfo.fint = fint;
213 ctx->dsi_cinfo.clkdco = clkdco;
214
215 return dss_pll_hsdiv_calc(ctx->pll, clkdco,
216 ctx->pck_min, dss_feat_get_param_max(FEAT_PARAM_DSS_FCK),
217 dpi_calc_hsdiv_cb, ctx);
218}
219
220static bool dpi_calc_dss_cb(unsigned long fck, void *data)
221{
222 struct dpi_clk_calc_ctx *ctx = data;
223
224 ctx->fck = fck;
225
226 return dispc_div_calc(fck, ctx->pck_min, ctx->pck_max,
227 dpi_calc_dispc_cb, ctx);
228}
229
230static bool dpi_dsi_clk_calc(struct dpi_data *dpi, unsigned long pck,
231 struct dpi_clk_calc_ctx *ctx)
232{
233 unsigned long clkin;
234 unsigned long pll_min, pll_max;
235
236 memset(ctx, 0, sizeof(*ctx));
237 ctx->pll = dpi->pll;
238 ctx->pck_min = pck - 1000;
239 ctx->pck_max = pck + 1000;
240
241 pll_min = 0;
242 pll_max = 0;
243
244 clkin = clk_get_rate(ctx->pll->clkin);
245
246 return dss_pll_calc(ctx->pll, clkin,
247 pll_min, pll_max,
248 dpi_calc_pll_cb, ctx);
249}
250
251static bool dpi_dss_clk_calc(unsigned long pck, struct dpi_clk_calc_ctx *ctx)
252{
253 int i;
254
255 /*
256 * DSS fck gives us very few possibilities, so finding a good pixel
257 * clock may not be possible. We try multiple times to find the clock,
258 * each time widening the pixel clock range we look for, up to
259 * +/- ~15MHz.
260 */
261
262 for (i = 0; i < 25; ++i) {
263 bool ok;
264
265 memset(ctx, 0, sizeof(*ctx));
266 if (pck > 1000 * i * i * i)
267 ctx->pck_min = max(pck - 1000 * i * i * i, 0lu);
268 else
269 ctx->pck_min = 0;
270 ctx->pck_max = pck + 1000 * i * i * i;
271
272 ok = dss_div_calc(pck, ctx->pck_min, dpi_calc_dss_cb, ctx);
273 if (ok)
274 return ok;
275 }
276
277 return false;
278}
279
280
281
282static int dpi_set_dsi_clk(struct dpi_data *dpi, enum omap_channel channel,
283 unsigned long pck_req, unsigned long *fck, int *lck_div,
284 int *pck_div)
285{
286 struct dpi_clk_calc_ctx ctx;
287 int r;
288 bool ok;
289
290 ok = dpi_dsi_clk_calc(dpi, pck_req, &ctx);
291 if (!ok)
292 return -EINVAL;
293
294 r = dss_pll_set_config(dpi->pll, &ctx.dsi_cinfo);
295 if (r)
296 return r;
297
298 dss_select_lcd_clk_source(channel,
299 dpi_get_alt_clk_src(channel));
300
301 dpi->mgr_config.clock_info = ctx.dispc_cinfo;
302
303 *fck = ctx.dsi_cinfo.clkout[HSDIV_DISPC];
304 *lck_div = ctx.dispc_cinfo.lck_div;
305 *pck_div = ctx.dispc_cinfo.pck_div;
306
307 return 0;
308}
309
310static int dpi_set_dispc_clk(struct dpi_data *dpi, unsigned long pck_req,
311 unsigned long *fck, int *lck_div, int *pck_div)
312{
313 struct dpi_clk_calc_ctx ctx;
314 int r;
315 bool ok;
316
317 ok = dpi_dss_clk_calc(pck_req, &ctx);
318 if (!ok)
319 return -EINVAL;
320
321 r = dss_set_fck_rate(ctx.fck);
322 if (r)
323 return r;
324
325 dpi->mgr_config.clock_info = ctx.dispc_cinfo;
326
327 *fck = ctx.fck;
328 *lck_div = ctx.dispc_cinfo.lck_div;
329 *pck_div = ctx.dispc_cinfo.pck_div;
330
331 return 0;
332}
333
334static int dpi_set_mode(struct dpi_data *dpi)
335{
336 struct omap_dss_device *out = &dpi->output;
337 enum omap_channel channel = out->dispc_channel;
338 struct omap_video_timings *t = &dpi->timings;
339 int lck_div = 0, pck_div = 0;
340 unsigned long fck = 0;
341 unsigned long pck;
342 int r = 0;
343
344 if (dpi->pll)
345 r = dpi_set_dsi_clk(dpi, channel, t->pixelclock, &fck,
346 &lck_div, &pck_div);
347 else
348 r = dpi_set_dispc_clk(dpi, t->pixelclock, &fck,
349 &lck_div, &pck_div);
350 if (r)
351 return r;
352
353 pck = fck / lck_div / pck_div;
354
355 if (pck != t->pixelclock) {
356 DSSWARN("Could not find exact pixel clock. Requested %d Hz, got %lu Hz\n",
357 t->pixelclock, pck);
358
359 t->pixelclock = pck;
360 }
361
362 dss_mgr_set_timings(channel, t);
363
364 return 0;
365}
366
367static void dpi_config_lcd_manager(struct dpi_data *dpi)
368{
369 struct omap_dss_device *out = &dpi->output;
370 enum omap_channel channel = out->dispc_channel;
371
372 dpi->mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
373
374 dpi->mgr_config.stallmode = false;
375 dpi->mgr_config.fifohandcheck = false;
376
377 dpi->mgr_config.video_port_width = dpi->data_lines;
378
379 dpi->mgr_config.lcden_sig_polarity = 0;
380
381 dss_mgr_set_lcd_config(channel, &dpi->mgr_config);
382}
383
384static int dpi_display_enable(struct omap_dss_device *dssdev)
385{
386 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
387 struct omap_dss_device *out = &dpi->output;
388 enum omap_channel channel = out->dispc_channel;
389 int r;
390
391 mutex_lock(&dpi->lock);
392
393 if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI) && !dpi->vdds_dsi_reg) {
394 DSSERR("no VDSS_DSI regulator\n");
395 r = -ENODEV;
396 goto err_no_reg;
397 }
398
399 if (!out->dispc_channel_connected) {
400 DSSERR("failed to enable display: no output/manager\n");
401 r = -ENODEV;
402 goto err_no_out_mgr;
403 }
404
405 if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI)) {
406 r = regulator_enable(dpi->vdds_dsi_reg);
407 if (r)
408 goto err_reg_enable;
409 }
410
411 r = dispc_runtime_get();
412 if (r)
413 goto err_get_dispc;
414
415 r = dss_dpi_select_source(out->port_num, channel);
416 if (r)
417 goto err_src_sel;
418
419 if (dpi->pll) {
420 r = dss_pll_enable(dpi->pll);
421 if (r)
422 goto err_dsi_pll_init;
423 }
424
425 r = dpi_set_mode(dpi);
426 if (r)
427 goto err_set_mode;
428
429 dpi_config_lcd_manager(dpi);
430
431 mdelay(2);
432
433 r = dss_mgr_enable(channel);
434 if (r)
435 goto err_mgr_enable;
436
437 mutex_unlock(&dpi->lock);
438
439 return 0;
440
441err_mgr_enable:
442err_set_mode:
443 if (dpi->pll)
444 dss_pll_disable(dpi->pll);
445err_dsi_pll_init:
446err_src_sel:
447 dispc_runtime_put();
448err_get_dispc:
449 if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI))
450 regulator_disable(dpi->vdds_dsi_reg);
451err_reg_enable:
452err_no_out_mgr:
453err_no_reg:
454 mutex_unlock(&dpi->lock);
455 return r;
456}
457
458static void dpi_display_disable(struct omap_dss_device *dssdev)
459{
460 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
461 enum omap_channel channel = dpi->output.dispc_channel;
462
463 mutex_lock(&dpi->lock);
464
465 dss_mgr_disable(channel);
466
467 if (dpi->pll) {
468 dss_select_lcd_clk_source(channel, OMAP_DSS_CLK_SRC_FCK);
469 dss_pll_disable(dpi->pll);
470 }
471
472 dispc_runtime_put();
473
474 if (dss_has_feature(FEAT_DPI_USES_VDDS_DSI))
475 regulator_disable(dpi->vdds_dsi_reg);
476
477 mutex_unlock(&dpi->lock);
478}
479
480static void dpi_set_timings(struct omap_dss_device *dssdev,
481 struct omap_video_timings *timings)
482{
483 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
484
485 DSSDBG("dpi_set_timings\n");
486
487 mutex_lock(&dpi->lock);
488
489 dpi->timings = *timings;
490
491 mutex_unlock(&dpi->lock);
492}
493
494static void dpi_get_timings(struct omap_dss_device *dssdev,
495 struct omap_video_timings *timings)
496{
497 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
498
499 mutex_lock(&dpi->lock);
500
501 *timings = dpi->timings;
502
503 mutex_unlock(&dpi->lock);
504}
505
506static int dpi_check_timings(struct omap_dss_device *dssdev,
507 struct omap_video_timings *timings)
508{
509 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
510 enum omap_channel channel = dpi->output.dispc_channel;
511 int lck_div, pck_div;
512 unsigned long fck;
513 unsigned long pck;
514 struct dpi_clk_calc_ctx ctx;
515 bool ok;
516
517 if (timings->x_res % 8 != 0)
518 return -EINVAL;
519
520 if (!dispc_mgr_timings_ok(channel, timings))
521 return -EINVAL;
522
523 if (timings->pixelclock == 0)
524 return -EINVAL;
525
526 if (dpi->pll) {
527 ok = dpi_dsi_clk_calc(dpi, timings->pixelclock, &ctx);
528 if (!ok)
529 return -EINVAL;
530
531 fck = ctx.dsi_cinfo.clkout[HSDIV_DISPC];
532 } else {
533 ok = dpi_dss_clk_calc(timings->pixelclock, &ctx);
534 if (!ok)
535 return -EINVAL;
536
537 fck = ctx.fck;
538 }
539
540 lck_div = ctx.dispc_cinfo.lck_div;
541 pck_div = ctx.dispc_cinfo.pck_div;
542
543 pck = fck / lck_div / pck_div;
544
545 timings->pixelclock = pck;
546
547 return 0;
548}
549
550static void dpi_set_data_lines(struct omap_dss_device *dssdev, int data_lines)
551{
552 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
553
554 mutex_lock(&dpi->lock);
555
556 dpi->data_lines = data_lines;
557
558 mutex_unlock(&dpi->lock);
559}
560
561static int dpi_verify_dsi_pll(struct dss_pll *pll)
562{
563 int r;
564
565 /* do initial setup with the PLL to see if it is operational */
566
567 r = dss_pll_enable(pll);
568 if (r)
569 return r;
570
571 dss_pll_disable(pll);
572
573 return 0;
574}
575
576static int dpi_init_regulator(struct dpi_data *dpi)
577{
578 struct regulator *vdds_dsi;
579
580 if (!dss_has_feature(FEAT_DPI_USES_VDDS_DSI))
581 return 0;
582
583 if (dpi->vdds_dsi_reg)
584 return 0;
585
586 vdds_dsi = devm_regulator_get(&dpi->pdev->dev, "vdds_dsi");
587 if (IS_ERR(vdds_dsi)) {
588 if (PTR_ERR(vdds_dsi) != -EPROBE_DEFER)
589 DSSERR("can't get VDDS_DSI regulator\n");
590 return PTR_ERR(vdds_dsi);
591 }
592
593 dpi->vdds_dsi_reg = vdds_dsi;
594
595 return 0;
596}
597
598static void dpi_init_pll(struct dpi_data *dpi)
599{
600 struct dss_pll *pll;
601
602 if (dpi->pll)
603 return;
604
605 pll = dpi_get_pll(dpi->output.dispc_channel);
606 if (!pll)
607 return;
608
609 /* On DRA7 we need to set a mux to use the PLL */
610 if (omapdss_get_version() == OMAPDSS_VER_DRA7xx)
611 dss_ctrl_pll_set_control_mux(pll->id, dpi->output.dispc_channel);
612
613 if (dpi_verify_dsi_pll(pll)) {
614 DSSWARN("DSI PLL not operational\n");
615 return;
616 }
617
618 dpi->pll = pll;
619}
620
621/*
622 * Return a hardcoded channel for the DPI output. This should work for
623 * current use cases, but this can be later expanded to either resolve
624 * the channel in some more dynamic manner, or get the channel as a user
625 * parameter.
626 */
627static enum omap_channel dpi_get_channel(int port_num)
628{
629 switch (omapdss_get_version()) {
630 case OMAPDSS_VER_OMAP24xx:
631 case OMAPDSS_VER_OMAP34xx_ES1:
632 case OMAPDSS_VER_OMAP34xx_ES3:
633 case OMAPDSS_VER_OMAP3630:
634 case OMAPDSS_VER_AM35xx:
635 case OMAPDSS_VER_AM43xx:
636 return OMAP_DSS_CHANNEL_LCD;
637
638 case OMAPDSS_VER_DRA7xx:
639 switch (port_num) {
640 case 2:
641 return OMAP_DSS_CHANNEL_LCD3;
642 case 1:
643 return OMAP_DSS_CHANNEL_LCD2;
644 case 0:
645 default:
646 return OMAP_DSS_CHANNEL_LCD;
647 }
648
649 case OMAPDSS_VER_OMAP4430_ES1:
650 case OMAPDSS_VER_OMAP4430_ES2:
651 case OMAPDSS_VER_OMAP4:
652 return OMAP_DSS_CHANNEL_LCD2;
653
654 case OMAPDSS_VER_OMAP5:
655 return OMAP_DSS_CHANNEL_LCD3;
656
657 default:
658 DSSWARN("unsupported DSS version\n");
659 return OMAP_DSS_CHANNEL_LCD;
660 }
661}
662
663static int dpi_connect(struct omap_dss_device *dssdev,
664 struct omap_dss_device *dst)
665{
666 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
667 enum omap_channel channel = dpi->output.dispc_channel;
668 int r;
669
670 r = dpi_init_regulator(dpi);
671 if (r)
672 return r;
673
674 dpi_init_pll(dpi);
675
676 r = dss_mgr_connect(channel, dssdev);
677 if (r)
678 return r;
679
680 r = omapdss_output_set_device(dssdev, dst);
681 if (r) {
682 DSSERR("failed to connect output to new device: %s\n",
683 dst->name);
684 dss_mgr_disconnect(channel, dssdev);
685 return r;
686 }
687
688 return 0;
689}
690
691static void dpi_disconnect(struct omap_dss_device *dssdev,
692 struct omap_dss_device *dst)
693{
694 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
695 enum omap_channel channel = dpi->output.dispc_channel;
696
697 WARN_ON(dst != dssdev->dst);
698
699 if (dst != dssdev->dst)
700 return;
701
702 omapdss_output_unset_device(dssdev);
703
704 dss_mgr_disconnect(channel, dssdev);
705}
706
707static const struct omapdss_dpi_ops dpi_ops = {
708 .connect = dpi_connect,
709 .disconnect = dpi_disconnect,
710
711 .enable = dpi_display_enable,
712 .disable = dpi_display_disable,
713
714 .check_timings = dpi_check_timings,
715 .set_timings = dpi_set_timings,
716 .get_timings = dpi_get_timings,
717
718 .set_data_lines = dpi_set_data_lines,
719};
720
721static void dpi_init_output(struct platform_device *pdev)
722{
723 struct dpi_data *dpi = dpi_get_data_from_pdev(pdev);
724 struct omap_dss_device *out = &dpi->output;
725
726 out->dev = &pdev->dev;
727 out->id = OMAP_DSS_OUTPUT_DPI;
728 out->output_type = OMAP_DISPLAY_TYPE_DPI;
729 out->name = "dpi.0";
730 out->dispc_channel = dpi_get_channel(0);
731 out->ops.dpi = &dpi_ops;
732 out->owner = THIS_MODULE;
733
734 omapdss_register_output(out);
735}
736
737static void dpi_uninit_output(struct platform_device *pdev)
738{
739 struct dpi_data *dpi = dpi_get_data_from_pdev(pdev);
740 struct omap_dss_device *out = &dpi->output;
741
742 omapdss_unregister_output(out);
743}
744
745static void dpi_init_output_port(struct platform_device *pdev,
746 struct device_node *port)
747{
748 struct dpi_data *dpi = port->data;
749 struct omap_dss_device *out = &dpi->output;
750 int r;
751 u32 port_num;
752
753 r = of_property_read_u32(port, "reg", &port_num);
754 if (r)
755 port_num = 0;
756
757 switch (port_num) {
758 case 2:
759 out->name = "dpi.2";
760 break;
761 case 1:
762 out->name = "dpi.1";
763 break;
764 case 0:
765 default:
766 out->name = "dpi.0";
767 break;
768 }
769
770 out->dev = &pdev->dev;
771 out->id = OMAP_DSS_OUTPUT_DPI;
772 out->output_type = OMAP_DISPLAY_TYPE_DPI;
773 out->dispc_channel = dpi_get_channel(port_num);
774 out->port_num = port_num;
775 out->ops.dpi = &dpi_ops;
776 out->owner = THIS_MODULE;
777
778 omapdss_register_output(out);
779}
780
781static void dpi_uninit_output_port(struct device_node *port)
782{
783 struct dpi_data *dpi = port->data;
784 struct omap_dss_device *out = &dpi->output;
785
786 omapdss_unregister_output(out);
787}
788
789static int dpi_bind(struct device *dev, struct device *master, void *data)
790{
791 struct platform_device *pdev = to_platform_device(dev);
792 struct dpi_data *dpi;
793
794 dpi = devm_kzalloc(&pdev->dev, sizeof(*dpi), GFP_KERNEL);
795 if (!dpi)
796 return -ENOMEM;
797
798 dpi->pdev = pdev;
799
800 dev_set_drvdata(&pdev->dev, dpi);
801
802 mutex_init(&dpi->lock);
803
804 dpi_init_output(pdev);
805
806 return 0;
807}
808
809static void dpi_unbind(struct device *dev, struct device *master, void *data)
810{
811 struct platform_device *pdev = to_platform_device(dev);
812
813 dpi_uninit_output(pdev);
814}
815
816static const struct component_ops dpi_component_ops = {
817 .bind = dpi_bind,
818 .unbind = dpi_unbind,
819};
820
821static int dpi_probe(struct platform_device *pdev)
822{
823 return component_add(&pdev->dev, &dpi_component_ops);
824}
825
826static int dpi_remove(struct platform_device *pdev)
827{
828 component_del(&pdev->dev, &dpi_component_ops);
829 return 0;
830}
831
832static struct platform_driver omap_dpi_driver = {
833 .probe = dpi_probe,
834 .remove = dpi_remove,
835 .driver = {
836 .name = "omapdss_dpi",
837 .suppress_bind_attrs = true,
838 },
839};
840
841int __init dpi_init_platform_driver(void)
842{
843 return platform_driver_register(&omap_dpi_driver);
844}
845
846void dpi_uninit_platform_driver(void)
847{
848 platform_driver_unregister(&omap_dpi_driver);
849}
850
851int dpi_init_port(struct platform_device *pdev, struct device_node *port)
852{
853 struct dpi_data *dpi;
854 struct device_node *ep;
855 u32 datalines;
856 int r;
857
858 dpi = devm_kzalloc(&pdev->dev, sizeof(*dpi), GFP_KERNEL);
859 if (!dpi)
860 return -ENOMEM;
861
862 ep = omapdss_of_get_next_endpoint(port, NULL);
863 if (!ep)
864 return 0;
865
866 r = of_property_read_u32(ep, "data-lines", &datalines);
867 if (r) {
868 DSSERR("failed to parse datalines\n");
869 goto err_datalines;
870 }
871
872 dpi->data_lines = datalines;
873
874 of_node_put(ep);
875
876 dpi->pdev = pdev;
877 port->data = dpi;
878
879 mutex_init(&dpi->lock);
880
881 dpi_init_output_port(pdev, port);
882
883 dpi->port_initialized = true;
884
885 return 0;
886
887err_datalines:
888 of_node_put(ep);
889
890 return r;
891}
892
893void dpi_uninit_port(struct device_node *port)
894{
895 struct dpi_data *dpi = port->data;
896
897 if (!dpi->port_initialized)
898 return;
899
900 dpi_uninit_output_port(port);
901}
1/*
2 * Copyright (C) 2009 Nokia Corporation
3 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
4 *
5 * Some code and ideas taken from drivers/video/omap/ driver
6 * by Imre Deak.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published by
10 * the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21#define DSS_SUBSYS_NAME "DPI"
22
23#include <linux/kernel.h>
24#include <linux/delay.h>
25#include <linux/export.h>
26#include <linux/err.h>
27#include <linux/errno.h>
28#include <linux/platform_device.h>
29#include <linux/regulator/consumer.h>
30#include <linux/string.h>
31#include <linux/of.h>
32#include <linux/clk.h>
33#include <linux/sys_soc.h>
34
35#include "omapdss.h"
36#include "dss.h"
37
38struct dpi_data {
39 struct platform_device *pdev;
40 enum dss_model dss_model;
41 struct dss_device *dss;
42
43 struct regulator *vdds_dsi_reg;
44 enum dss_clk_source clk_src;
45 struct dss_pll *pll;
46
47 struct mutex lock;
48
49 struct videomode vm;
50 struct dss_lcd_mgr_config mgr_config;
51 int data_lines;
52
53 struct omap_dss_device output;
54};
55
56static struct dpi_data *dpi_get_data_from_dssdev(struct omap_dss_device *dssdev)
57{
58 return container_of(dssdev, struct dpi_data, output);
59}
60
61static enum dss_clk_source dpi_get_clk_src_dra7xx(struct dpi_data *dpi,
62 enum omap_channel channel)
63{
64 /*
65 * Possible clock sources:
66 * LCD1: FCK/PLL1_1/HDMI_PLL
67 * LCD2: FCK/PLL1_3/HDMI_PLL (DRA74x: PLL2_3)
68 * LCD3: FCK/PLL1_3/HDMI_PLL (DRA74x: PLL2_1)
69 */
70
71 switch (channel) {
72 case OMAP_DSS_CHANNEL_LCD:
73 {
74 if (dss_pll_find_by_src(dpi->dss, DSS_CLK_SRC_PLL1_1))
75 return DSS_CLK_SRC_PLL1_1;
76 break;
77 }
78 case OMAP_DSS_CHANNEL_LCD2:
79 {
80 if (dss_pll_find_by_src(dpi->dss, DSS_CLK_SRC_PLL1_3))
81 return DSS_CLK_SRC_PLL1_3;
82 if (dss_pll_find_by_src(dpi->dss, DSS_CLK_SRC_PLL2_3))
83 return DSS_CLK_SRC_PLL2_3;
84 break;
85 }
86 case OMAP_DSS_CHANNEL_LCD3:
87 {
88 if (dss_pll_find_by_src(dpi->dss, DSS_CLK_SRC_PLL2_1))
89 return DSS_CLK_SRC_PLL2_1;
90 if (dss_pll_find_by_src(dpi->dss, DSS_CLK_SRC_PLL1_3))
91 return DSS_CLK_SRC_PLL1_3;
92 break;
93 }
94 default:
95 break;
96 }
97
98 return DSS_CLK_SRC_FCK;
99}
100
101static enum dss_clk_source dpi_get_clk_src(struct dpi_data *dpi)
102{
103 enum omap_channel channel = dpi->output.dispc_channel;
104
105 /*
106 * XXX we can't currently use DSI PLL for DPI with OMAP3, as the DSI PLL
107 * would also be used for DISPC fclk. Meaning, when the DPI output is
108 * disabled, DISPC clock will be disabled, and TV out will stop.
109 */
110 switch (dpi->dss_model) {
111 case DSS_MODEL_OMAP2:
112 case DSS_MODEL_OMAP3:
113 return DSS_CLK_SRC_FCK;
114
115 case DSS_MODEL_OMAP4:
116 switch (channel) {
117 case OMAP_DSS_CHANNEL_LCD:
118 return DSS_CLK_SRC_PLL1_1;
119 case OMAP_DSS_CHANNEL_LCD2:
120 return DSS_CLK_SRC_PLL2_1;
121 default:
122 return DSS_CLK_SRC_FCK;
123 }
124
125 case DSS_MODEL_OMAP5:
126 switch (channel) {
127 case OMAP_DSS_CHANNEL_LCD:
128 return DSS_CLK_SRC_PLL1_1;
129 case OMAP_DSS_CHANNEL_LCD3:
130 return DSS_CLK_SRC_PLL2_1;
131 case OMAP_DSS_CHANNEL_LCD2:
132 default:
133 return DSS_CLK_SRC_FCK;
134 }
135
136 case DSS_MODEL_DRA7:
137 return dpi_get_clk_src_dra7xx(dpi, channel);
138
139 default:
140 return DSS_CLK_SRC_FCK;
141 }
142}
143
144struct dpi_clk_calc_ctx {
145 struct dpi_data *dpi;
146 unsigned int clkout_idx;
147
148 /* inputs */
149
150 unsigned long pck_min, pck_max;
151
152 /* outputs */
153
154 struct dss_pll_clock_info pll_cinfo;
155 unsigned long fck;
156 struct dispc_clock_info dispc_cinfo;
157};
158
159static bool dpi_calc_dispc_cb(int lckd, int pckd, unsigned long lck,
160 unsigned long pck, void *data)
161{
162 struct dpi_clk_calc_ctx *ctx = data;
163
164 /*
165 * Odd dividers give us uneven duty cycle, causing problem when level
166 * shifted. So skip all odd dividers when the pixel clock is on the
167 * higher side.
168 */
169 if (ctx->pck_min >= 100000000) {
170 if (lckd > 1 && lckd % 2 != 0)
171 return false;
172
173 if (pckd > 1 && pckd % 2 != 0)
174 return false;
175 }
176
177 ctx->dispc_cinfo.lck_div = lckd;
178 ctx->dispc_cinfo.pck_div = pckd;
179 ctx->dispc_cinfo.lck = lck;
180 ctx->dispc_cinfo.pck = pck;
181
182 return true;
183}
184
185
186static bool dpi_calc_hsdiv_cb(int m_dispc, unsigned long dispc,
187 void *data)
188{
189 struct dpi_clk_calc_ctx *ctx = data;
190
191 ctx->pll_cinfo.mX[ctx->clkout_idx] = m_dispc;
192 ctx->pll_cinfo.clkout[ctx->clkout_idx] = dispc;
193
194 return dispc_div_calc(ctx->dpi->dss->dispc, dispc,
195 ctx->pck_min, ctx->pck_max,
196 dpi_calc_dispc_cb, ctx);
197}
198
199
200static bool dpi_calc_pll_cb(int n, int m, unsigned long fint,
201 unsigned long clkdco,
202 void *data)
203{
204 struct dpi_clk_calc_ctx *ctx = data;
205
206 ctx->pll_cinfo.n = n;
207 ctx->pll_cinfo.m = m;
208 ctx->pll_cinfo.fint = fint;
209 ctx->pll_cinfo.clkdco = clkdco;
210
211 return dss_pll_hsdiv_calc_a(ctx->dpi->pll, clkdco,
212 ctx->pck_min, dss_get_max_fck_rate(ctx->dpi->dss),
213 dpi_calc_hsdiv_cb, ctx);
214}
215
216static bool dpi_calc_dss_cb(unsigned long fck, void *data)
217{
218 struct dpi_clk_calc_ctx *ctx = data;
219
220 ctx->fck = fck;
221
222 return dispc_div_calc(ctx->dpi->dss->dispc, fck,
223 ctx->pck_min, ctx->pck_max,
224 dpi_calc_dispc_cb, ctx);
225}
226
227static bool dpi_pll_clk_calc(struct dpi_data *dpi, unsigned long pck,
228 struct dpi_clk_calc_ctx *ctx)
229{
230 unsigned long clkin;
231
232 memset(ctx, 0, sizeof(*ctx));
233 ctx->dpi = dpi;
234 ctx->clkout_idx = dss_pll_get_clkout_idx_for_src(dpi->clk_src);
235
236 clkin = clk_get_rate(dpi->pll->clkin);
237
238 if (dpi->pll->hw->type == DSS_PLL_TYPE_A) {
239 unsigned long pll_min, pll_max;
240
241 ctx->pck_min = pck - 1000;
242 ctx->pck_max = pck + 1000;
243
244 pll_min = 0;
245 pll_max = 0;
246
247 return dss_pll_calc_a(ctx->dpi->pll, clkin,
248 pll_min, pll_max,
249 dpi_calc_pll_cb, ctx);
250 } else { /* DSS_PLL_TYPE_B */
251 dss_pll_calc_b(dpi->pll, clkin, pck, &ctx->pll_cinfo);
252
253 ctx->dispc_cinfo.lck_div = 1;
254 ctx->dispc_cinfo.pck_div = 1;
255 ctx->dispc_cinfo.lck = ctx->pll_cinfo.clkout[0];
256 ctx->dispc_cinfo.pck = ctx->dispc_cinfo.lck;
257
258 return true;
259 }
260}
261
262static bool dpi_dss_clk_calc(struct dpi_data *dpi, unsigned long pck,
263 struct dpi_clk_calc_ctx *ctx)
264{
265 int i;
266
267 /*
268 * DSS fck gives us very few possibilities, so finding a good pixel
269 * clock may not be possible. We try multiple times to find the clock,
270 * each time widening the pixel clock range we look for, up to
271 * +/- ~15MHz.
272 */
273
274 for (i = 0; i < 25; ++i) {
275 bool ok;
276
277 memset(ctx, 0, sizeof(*ctx));
278 ctx->dpi = dpi;
279 if (pck > 1000 * i * i * i)
280 ctx->pck_min = max(pck - 1000 * i * i * i, 0lu);
281 else
282 ctx->pck_min = 0;
283 ctx->pck_max = pck + 1000 * i * i * i;
284
285 ok = dss_div_calc(dpi->dss, pck, ctx->pck_min,
286 dpi_calc_dss_cb, ctx);
287 if (ok)
288 return ok;
289 }
290
291 return false;
292}
293
294
295
296static int dpi_set_pll_clk(struct dpi_data *dpi, enum omap_channel channel,
297 unsigned long pck_req, unsigned long *fck, int *lck_div,
298 int *pck_div)
299{
300 struct dpi_clk_calc_ctx ctx;
301 int r;
302 bool ok;
303
304 ok = dpi_pll_clk_calc(dpi, pck_req, &ctx);
305 if (!ok)
306 return -EINVAL;
307
308 r = dss_pll_set_config(dpi->pll, &ctx.pll_cinfo);
309 if (r)
310 return r;
311
312 dss_select_lcd_clk_source(dpi->dss, channel, dpi->clk_src);
313
314 dpi->mgr_config.clock_info = ctx.dispc_cinfo;
315
316 *fck = ctx.pll_cinfo.clkout[ctx.clkout_idx];
317 *lck_div = ctx.dispc_cinfo.lck_div;
318 *pck_div = ctx.dispc_cinfo.pck_div;
319
320 return 0;
321}
322
323static int dpi_set_dispc_clk(struct dpi_data *dpi, unsigned long pck_req,
324 unsigned long *fck, int *lck_div, int *pck_div)
325{
326 struct dpi_clk_calc_ctx ctx;
327 int r;
328 bool ok;
329
330 ok = dpi_dss_clk_calc(dpi, pck_req, &ctx);
331 if (!ok)
332 return -EINVAL;
333
334 r = dss_set_fck_rate(dpi->dss, ctx.fck);
335 if (r)
336 return r;
337
338 dpi->mgr_config.clock_info = ctx.dispc_cinfo;
339
340 *fck = ctx.fck;
341 *lck_div = ctx.dispc_cinfo.lck_div;
342 *pck_div = ctx.dispc_cinfo.pck_div;
343
344 return 0;
345}
346
347static int dpi_set_mode(struct dpi_data *dpi)
348{
349 struct videomode *vm = &dpi->vm;
350 int lck_div = 0, pck_div = 0;
351 unsigned long fck = 0;
352 unsigned long pck;
353 int r = 0;
354
355 if (dpi->pll)
356 r = dpi_set_pll_clk(dpi, dpi->output.dispc_channel,
357 vm->pixelclock, &fck, &lck_div, &pck_div);
358 else
359 r = dpi_set_dispc_clk(dpi, vm->pixelclock, &fck,
360 &lck_div, &pck_div);
361 if (r)
362 return r;
363
364 pck = fck / lck_div / pck_div;
365
366 if (pck != vm->pixelclock) {
367 DSSWARN("Could not find exact pixel clock. Requested %lu Hz, got %lu Hz\n",
368 vm->pixelclock, pck);
369
370 vm->pixelclock = pck;
371 }
372
373 dss_mgr_set_timings(&dpi->output, vm);
374
375 return 0;
376}
377
378static void dpi_config_lcd_manager(struct dpi_data *dpi)
379{
380 dpi->mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
381
382 dpi->mgr_config.stallmode = false;
383 dpi->mgr_config.fifohandcheck = false;
384
385 dpi->mgr_config.video_port_width = dpi->data_lines;
386
387 dpi->mgr_config.lcden_sig_polarity = 0;
388
389 dss_mgr_set_lcd_config(&dpi->output, &dpi->mgr_config);
390}
391
392static int dpi_display_enable(struct omap_dss_device *dssdev)
393{
394 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
395 struct omap_dss_device *out = &dpi->output;
396 int r;
397
398 mutex_lock(&dpi->lock);
399
400 if (!out->dispc_channel_connected) {
401 DSSERR("failed to enable display: no output/manager\n");
402 r = -ENODEV;
403 goto err_no_out_mgr;
404 }
405
406 if (dpi->vdds_dsi_reg) {
407 r = regulator_enable(dpi->vdds_dsi_reg);
408 if (r)
409 goto err_reg_enable;
410 }
411
412 r = dispc_runtime_get(dpi->dss->dispc);
413 if (r)
414 goto err_get_dispc;
415
416 r = dss_dpi_select_source(dpi->dss, out->port_num, out->dispc_channel);
417 if (r)
418 goto err_src_sel;
419
420 if (dpi->pll) {
421 r = dss_pll_enable(dpi->pll);
422 if (r)
423 goto err_pll_init;
424 }
425
426 r = dpi_set_mode(dpi);
427 if (r)
428 goto err_set_mode;
429
430 dpi_config_lcd_manager(dpi);
431
432 mdelay(2);
433
434 r = dss_mgr_enable(&dpi->output);
435 if (r)
436 goto err_mgr_enable;
437
438 mutex_unlock(&dpi->lock);
439
440 return 0;
441
442err_mgr_enable:
443err_set_mode:
444 if (dpi->pll)
445 dss_pll_disable(dpi->pll);
446err_pll_init:
447err_src_sel:
448 dispc_runtime_put(dpi->dss->dispc);
449err_get_dispc:
450 if (dpi->vdds_dsi_reg)
451 regulator_disable(dpi->vdds_dsi_reg);
452err_reg_enable:
453err_no_out_mgr:
454 mutex_unlock(&dpi->lock);
455 return r;
456}
457
458static void dpi_display_disable(struct omap_dss_device *dssdev)
459{
460 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
461
462 mutex_lock(&dpi->lock);
463
464 dss_mgr_disable(&dpi->output);
465
466 if (dpi->pll) {
467 dss_select_lcd_clk_source(dpi->dss, dpi->output.dispc_channel,
468 DSS_CLK_SRC_FCK);
469 dss_pll_disable(dpi->pll);
470 }
471
472 dispc_runtime_put(dpi->dss->dispc);
473
474 if (dpi->vdds_dsi_reg)
475 regulator_disable(dpi->vdds_dsi_reg);
476
477 mutex_unlock(&dpi->lock);
478}
479
480static void dpi_set_timings(struct omap_dss_device *dssdev,
481 struct videomode *vm)
482{
483 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
484
485 DSSDBG("dpi_set_timings\n");
486
487 mutex_lock(&dpi->lock);
488
489 dpi->vm = *vm;
490
491 mutex_unlock(&dpi->lock);
492}
493
494static void dpi_get_timings(struct omap_dss_device *dssdev,
495 struct videomode *vm)
496{
497 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
498
499 mutex_lock(&dpi->lock);
500
501 *vm = dpi->vm;
502
503 mutex_unlock(&dpi->lock);
504}
505
506static int dpi_check_timings(struct omap_dss_device *dssdev,
507 struct videomode *vm)
508{
509 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
510 enum omap_channel channel = dpi->output.dispc_channel;
511 int lck_div, pck_div;
512 unsigned long fck;
513 unsigned long pck;
514 struct dpi_clk_calc_ctx ctx;
515 bool ok;
516
517 if (vm->hactive % 8 != 0)
518 return -EINVAL;
519
520 if (!dispc_mgr_timings_ok(dpi->dss->dispc, channel, vm))
521 return -EINVAL;
522
523 if (vm->pixelclock == 0)
524 return -EINVAL;
525
526 if (dpi->pll) {
527 ok = dpi_pll_clk_calc(dpi, vm->pixelclock, &ctx);
528 if (!ok)
529 return -EINVAL;
530
531 fck = ctx.pll_cinfo.clkout[ctx.clkout_idx];
532 } else {
533 ok = dpi_dss_clk_calc(dpi, vm->pixelclock, &ctx);
534 if (!ok)
535 return -EINVAL;
536
537 fck = ctx.fck;
538 }
539
540 lck_div = ctx.dispc_cinfo.lck_div;
541 pck_div = ctx.dispc_cinfo.pck_div;
542
543 pck = fck / lck_div / pck_div;
544
545 vm->pixelclock = pck;
546
547 return 0;
548}
549
550static int dpi_verify_pll(struct dss_pll *pll)
551{
552 int r;
553
554 /* do initial setup with the PLL to see if it is operational */
555
556 r = dss_pll_enable(pll);
557 if (r)
558 return r;
559
560 dss_pll_disable(pll);
561
562 return 0;
563}
564
565static const struct soc_device_attribute dpi_soc_devices[] = {
566 { .machine = "OMAP3[456]*" },
567 { .machine = "[AD]M37*" },
568 { /* sentinel */ }
569};
570
571static int dpi_init_regulator(struct dpi_data *dpi)
572{
573 struct regulator *vdds_dsi;
574
575 /*
576 * The DPI uses the DSI VDDS on OMAP34xx, OMAP35xx, OMAP36xx, AM37xx and
577 * DM37xx only.
578 */
579 if (!soc_device_match(dpi_soc_devices))
580 return 0;
581
582 if (dpi->vdds_dsi_reg)
583 return 0;
584
585 vdds_dsi = devm_regulator_get(&dpi->pdev->dev, "vdds_dsi");
586 if (IS_ERR(vdds_dsi)) {
587 if (PTR_ERR(vdds_dsi) != -EPROBE_DEFER)
588 DSSERR("can't get VDDS_DSI regulator\n");
589 return PTR_ERR(vdds_dsi);
590 }
591
592 dpi->vdds_dsi_reg = vdds_dsi;
593
594 return 0;
595}
596
597static void dpi_init_pll(struct dpi_data *dpi)
598{
599 struct dss_pll *pll;
600
601 if (dpi->pll)
602 return;
603
604 dpi->clk_src = dpi_get_clk_src(dpi);
605
606 pll = dss_pll_find_by_src(dpi->dss, dpi->clk_src);
607 if (!pll)
608 return;
609
610 if (dpi_verify_pll(pll)) {
611 DSSWARN("PLL not operational\n");
612 return;
613 }
614
615 dpi->pll = pll;
616}
617
618/*
619 * Return a hardcoded channel for the DPI output. This should work for
620 * current use cases, but this can be later expanded to either resolve
621 * the channel in some more dynamic manner, or get the channel as a user
622 * parameter.
623 */
624static enum omap_channel dpi_get_channel(struct dpi_data *dpi, int port_num)
625{
626 switch (dpi->dss_model) {
627 case DSS_MODEL_OMAP2:
628 case DSS_MODEL_OMAP3:
629 return OMAP_DSS_CHANNEL_LCD;
630
631 case DSS_MODEL_DRA7:
632 switch (port_num) {
633 case 2:
634 return OMAP_DSS_CHANNEL_LCD3;
635 case 1:
636 return OMAP_DSS_CHANNEL_LCD2;
637 case 0:
638 default:
639 return OMAP_DSS_CHANNEL_LCD;
640 }
641
642 case DSS_MODEL_OMAP4:
643 return OMAP_DSS_CHANNEL_LCD2;
644
645 case DSS_MODEL_OMAP5:
646 return OMAP_DSS_CHANNEL_LCD3;
647
648 default:
649 DSSWARN("unsupported DSS version\n");
650 return OMAP_DSS_CHANNEL_LCD;
651 }
652}
653
654static int dpi_connect(struct omap_dss_device *dssdev,
655 struct omap_dss_device *dst)
656{
657 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
658 int r;
659
660 r = dpi_init_regulator(dpi);
661 if (r)
662 return r;
663
664 dpi_init_pll(dpi);
665
666 r = dss_mgr_connect(&dpi->output, dssdev);
667 if (r)
668 return r;
669
670 r = omapdss_output_set_device(dssdev, dst);
671 if (r) {
672 DSSERR("failed to connect output to new device: %s\n",
673 dst->name);
674 dss_mgr_disconnect(&dpi->output, dssdev);
675 return r;
676 }
677
678 return 0;
679}
680
681static void dpi_disconnect(struct omap_dss_device *dssdev,
682 struct omap_dss_device *dst)
683{
684 struct dpi_data *dpi = dpi_get_data_from_dssdev(dssdev);
685
686 WARN_ON(dst != dssdev->dst);
687
688 if (dst != dssdev->dst)
689 return;
690
691 omapdss_output_unset_device(dssdev);
692
693 dss_mgr_disconnect(&dpi->output, dssdev);
694}
695
696static const struct omapdss_dpi_ops dpi_ops = {
697 .connect = dpi_connect,
698 .disconnect = dpi_disconnect,
699
700 .enable = dpi_display_enable,
701 .disable = dpi_display_disable,
702
703 .check_timings = dpi_check_timings,
704 .set_timings = dpi_set_timings,
705 .get_timings = dpi_get_timings,
706};
707
708static void dpi_init_output_port(struct dpi_data *dpi, struct device_node *port)
709{
710 struct omap_dss_device *out = &dpi->output;
711 int r;
712 u32 port_num;
713
714 r = of_property_read_u32(port, "reg", &port_num);
715 if (r)
716 port_num = 0;
717
718 switch (port_num) {
719 case 2:
720 out->name = "dpi.2";
721 break;
722 case 1:
723 out->name = "dpi.1";
724 break;
725 case 0:
726 default:
727 out->name = "dpi.0";
728 break;
729 }
730
731 out->dev = &dpi->pdev->dev;
732 out->id = OMAP_DSS_OUTPUT_DPI;
733 out->output_type = OMAP_DISPLAY_TYPE_DPI;
734 out->dispc_channel = dpi_get_channel(dpi, port_num);
735 out->port_num = port_num;
736 out->ops.dpi = &dpi_ops;
737 out->owner = THIS_MODULE;
738
739 omapdss_register_output(out);
740}
741
742static void dpi_uninit_output_port(struct device_node *port)
743{
744 struct dpi_data *dpi = port->data;
745 struct omap_dss_device *out = &dpi->output;
746
747 omapdss_unregister_output(out);
748}
749
750int dpi_init_port(struct dss_device *dss, struct platform_device *pdev,
751 struct device_node *port, enum dss_model dss_model)
752{
753 struct dpi_data *dpi;
754 struct device_node *ep;
755 u32 datalines;
756 int r;
757
758 dpi = devm_kzalloc(&pdev->dev, sizeof(*dpi), GFP_KERNEL);
759 if (!dpi)
760 return -ENOMEM;
761
762 ep = of_get_next_child(port, NULL);
763 if (!ep)
764 return 0;
765
766 r = of_property_read_u32(ep, "data-lines", &datalines);
767 if (r) {
768 DSSERR("failed to parse datalines\n");
769 goto err_datalines;
770 }
771
772 dpi->data_lines = datalines;
773
774 of_node_put(ep);
775
776 dpi->pdev = pdev;
777 dpi->dss_model = dss_model;
778 dpi->dss = dss;
779 port->data = dpi;
780
781 mutex_init(&dpi->lock);
782
783 dpi_init_output_port(dpi, port);
784
785 return 0;
786
787err_datalines:
788 of_node_put(ep);
789
790 return r;
791}
792
793void dpi_uninit_port(struct device_node *port)
794{
795 struct dpi_data *dpi = port->data;
796
797 if (!dpi)
798 return;
799
800 dpi_uninit_output_port(port);
801}