1 /*
2 * Copyright (C) 2011 Texas Instruments
3 * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #define DSS_SUBSYS_NAME "APPLY"
19
20 #include <linux/kernel.h>
21 #include <linux/slab.h>
22 #include <linux/spinlock.h>
23 #include <linux/jiffies.h>
24
25 #include <video/omapdss.h>
26
27 #include "dss.h"
28 #include "dss_features.h"
29
30 /*
31 * We have 4 levels of cache for the dispc settings. First two are in SW and
32 * the latter two in HW.
33 *
34 * set_info()
35 * v
36 * +--------------------+
37 * | user_info |
38 * +--------------------+
39 * v
40 * apply()
41 * v
42 * +--------------------+
43 * | info |
44 * +--------------------+
45 * v
46 * write_regs()
47 * v
48 * +--------------------+
49 * | shadow registers |
50 * +--------------------+
51 * v
52 * VFP or lcd/digit_enable
53 * v
54 * +--------------------+
55 * | registers |
56 * +--------------------+
57 */
58
59 struct ovl_priv_data {
60
61 bool user_info_dirty;
62 struct omap_overlay_info user_info;
63
64 bool info_dirty;
65 struct omap_overlay_info info;
66
67 bool shadow_info_dirty;
68
69 bool extra_info_dirty;
70 bool shadow_extra_info_dirty;
71
72 bool enabled;
73 enum omap_channel channel;
74 u32 fifo_low, fifo_high;
75
76 /*
77 * True if overlay is to be enabled. Used to check and calculate configs
78 * for the overlay before it is enabled in the HW.
79 */
80 bool enabling;
81 };
82
83 struct mgr_priv_data {
84
85 bool user_info_dirty;
86 struct omap_overlay_manager_info user_info;
87
88 bool info_dirty;
89 struct omap_overlay_manager_info info;
90
91 bool shadow_info_dirty;
92
93 /* If true, GO bit is up and shadow registers cannot be written.
94 * Never true for manual update displays */
95 bool busy;
96
97 /* If true, dispc output is enabled */
98 bool updating;
99
100 /* If true, a display is enabled using this manager */
101 bool enabled;
102 };
103
104 static struct {
105 struct ovl_priv_data ovl_priv_data_array[MAX_DSS_OVERLAYS];
106 struct mgr_priv_data mgr_priv_data_array[MAX_DSS_MANAGERS];
107
108 bool irq_enabled;
109 } dss_data;
110
111 /* protects dss_data */
112 static spinlock_t data_lock;
113 /* lock for blocking functions */
114 static DEFINE_MUTEX(apply_lock);
115 static DECLARE_COMPLETION(extra_updated_completion);
116
117 static void dss_register_vsync_isr(void);
118
get_ovl_priv(struct omap_overlay * ovl)119 static struct ovl_priv_data *get_ovl_priv(struct omap_overlay *ovl)
120 {
121 return &dss_data.ovl_priv_data_array[ovl->id];
122 }
123
get_mgr_priv(struct omap_overlay_manager * mgr)124 static struct mgr_priv_data *get_mgr_priv(struct omap_overlay_manager *mgr)
125 {
126 return &dss_data.mgr_priv_data_array[mgr->id];
127 }
128
dss_apply_init(void)129 void dss_apply_init(void)
130 {
131 const int num_ovls = dss_feat_get_num_ovls();
132 int i;
133
134 spin_lock_init(&data_lock);
135
136 for (i = 0; i < num_ovls; ++i) {
137 struct ovl_priv_data *op;
138
139 op = &dss_data.ovl_priv_data_array[i];
140
141 op->info.global_alpha = 255;
142
143 switch (i) {
144 case 0:
145 op->info.zorder = 0;
146 break;
147 case 1:
148 op->info.zorder =
149 dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 3 : 0;
150 break;
151 case 2:
152 op->info.zorder =
153 dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 2 : 0;
154 break;
155 case 3:
156 op->info.zorder =
157 dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 1 : 0;
158 break;
159 }
160
161 op->user_info = op->info;
162 }
163 }
164
ovl_manual_update(struct omap_overlay * ovl)165 static bool ovl_manual_update(struct omap_overlay *ovl)
166 {
167 return ovl->manager->device->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
168 }
169
mgr_manual_update(struct omap_overlay_manager * mgr)170 static bool mgr_manual_update(struct omap_overlay_manager *mgr)
171 {
172 return mgr->device->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
173 }
174
dss_check_settings_low(struct omap_overlay_manager * mgr,struct omap_dss_device * dssdev,bool applying)175 static int dss_check_settings_low(struct omap_overlay_manager *mgr,
176 struct omap_dss_device *dssdev, bool applying)
177 {
178 struct omap_overlay_info *oi;
179 struct omap_overlay_manager_info *mi;
180 struct omap_overlay *ovl;
181 struct omap_overlay_info *ois[MAX_DSS_OVERLAYS];
182 struct ovl_priv_data *op;
183 struct mgr_priv_data *mp;
184
185 mp = get_mgr_priv(mgr);
186
187 if (applying && mp->user_info_dirty)
188 mi = &mp->user_info;
189 else
190 mi = &mp->info;
191
192 /* collect the infos to be tested into the array */
193 list_for_each_entry(ovl, &mgr->overlays, list) {
194 op = get_ovl_priv(ovl);
195
196 if (!op->enabled && !op->enabling)
197 oi = NULL;
198 else if (applying && op->user_info_dirty)
199 oi = &op->user_info;
200 else
201 oi = &op->info;
202
203 ois[ovl->id] = oi;
204 }
205
206 return dss_mgr_check(mgr, dssdev, mi, ois);
207 }
208
209 /*
210 * check manager and overlay settings using overlay_info from data->info
211 */
dss_check_settings(struct omap_overlay_manager * mgr,struct omap_dss_device * dssdev)212 static int dss_check_settings(struct omap_overlay_manager *mgr,
213 struct omap_dss_device *dssdev)
214 {
215 return dss_check_settings_low(mgr, dssdev, false);
216 }
217
218 /*
219 * check manager and overlay settings using overlay_info from ovl->info if
220 * dirty and from data->info otherwise
221 */
dss_check_settings_apply(struct omap_overlay_manager * mgr,struct omap_dss_device * dssdev)222 static int dss_check_settings_apply(struct omap_overlay_manager *mgr,
223 struct omap_dss_device *dssdev)
224 {
225 return dss_check_settings_low(mgr, dssdev, true);
226 }
227
need_isr(void)228 static bool need_isr(void)
229 {
230 const int num_mgrs = dss_feat_get_num_mgrs();
231 int i;
232
233 for (i = 0; i < num_mgrs; ++i) {
234 struct omap_overlay_manager *mgr;
235 struct mgr_priv_data *mp;
236 struct omap_overlay *ovl;
237
238 mgr = omap_dss_get_overlay_manager(i);
239 mp = get_mgr_priv(mgr);
240
241 if (!mp->enabled)
242 continue;
243
244 if (mgr_manual_update(mgr)) {
245 /* to catch FRAMEDONE */
246 if (mp->updating)
247 return true;
248 } else {
249 /* to catch GO bit going down */
250 if (mp->busy)
251 return true;
252
253 /* to write new values to registers */
254 if (mp->info_dirty)
255 return true;
256
257 /* to set GO bit */
258 if (mp->shadow_info_dirty)
259 return true;
260
261 list_for_each_entry(ovl, &mgr->overlays, list) {
262 struct ovl_priv_data *op;
263
264 op = get_ovl_priv(ovl);
265
266 /*
267 * NOTE: we check extra_info flags even for
268 * disabled overlays, as extra_infos need to be
269 * always written.
270 */
271
272 /* to write new values to registers */
273 if (op->extra_info_dirty)
274 return true;
275
276 /* to set GO bit */
277 if (op->shadow_extra_info_dirty)
278 return true;
279
280 if (!op->enabled)
281 continue;
282
283 /* to write new values to registers */
284 if (op->info_dirty)
285 return true;
286
287 /* to set GO bit */
288 if (op->shadow_info_dirty)
289 return true;
290 }
291 }
292 }
293
294 return false;
295 }
296
need_go(struct omap_overlay_manager * mgr)297 static bool need_go(struct omap_overlay_manager *mgr)
298 {
299 struct omap_overlay *ovl;
300 struct mgr_priv_data *mp;
301 struct ovl_priv_data *op;
302
303 mp = get_mgr_priv(mgr);
304
305 if (mp->shadow_info_dirty)
306 return true;
307
308 list_for_each_entry(ovl, &mgr->overlays, list) {
309 op = get_ovl_priv(ovl);
310 if (op->shadow_info_dirty || op->shadow_extra_info_dirty)
311 return true;
312 }
313
314 return false;
315 }
316
317 /* returns true if an extra_info field is currently being updated */
extra_info_update_ongoing(void)318 static bool extra_info_update_ongoing(void)
319 {
320 const int num_ovls = omap_dss_get_num_overlays();
321 struct ovl_priv_data *op;
322 struct omap_overlay *ovl;
323 struct mgr_priv_data *mp;
324 int i;
325
326 for (i = 0; i < num_ovls; ++i) {
327 ovl = omap_dss_get_overlay(i);
328 op = get_ovl_priv(ovl);
329
330 if (!ovl->manager)
331 continue;
332
333 mp = get_mgr_priv(ovl->manager);
334
335 if (!mp->enabled)
336 continue;
337
338 if (!mp->updating)
339 continue;
340
341 if (op->extra_info_dirty || op->shadow_extra_info_dirty)
342 return true;
343 }
344
345 return false;
346 }
347
348 /* wait until no extra_info updates are pending */
wait_pending_extra_info_updates(void)349 static void wait_pending_extra_info_updates(void)
350 {
351 bool updating;
352 unsigned long flags;
353 unsigned long t;
354
355 spin_lock_irqsave(&data_lock, flags);
356
357 updating = extra_info_update_ongoing();
358
359 if (!updating) {
360 spin_unlock_irqrestore(&data_lock, flags);
361 return;
362 }
363
364 init_completion(&extra_updated_completion);
365
366 spin_unlock_irqrestore(&data_lock, flags);
367
368 t = msecs_to_jiffies(500);
369 wait_for_completion_timeout(&extra_updated_completion, t);
370
371 updating = extra_info_update_ongoing();
372
373 WARN_ON(updating);
374 }
375
dss_mgr_wait_for_go(struct omap_overlay_manager * mgr)376 int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
377 {
378 unsigned long timeout = msecs_to_jiffies(500);
379 struct mgr_priv_data *mp;
380 u32 irq;
381 int r;
382 int i;
383 struct omap_dss_device *dssdev = mgr->device;
384
385 if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
386 return 0;
387
388 if (mgr_manual_update(mgr))
389 return 0;
390
391 irq = dispc_mgr_get_vsync_irq(mgr->id);
392
393 mp = get_mgr_priv(mgr);
394 i = 0;
395 while (1) {
396 unsigned long flags;
397 bool shadow_dirty, dirty;
398
399 spin_lock_irqsave(&data_lock, flags);
400 dirty = mp->info_dirty;
401 shadow_dirty = mp->shadow_info_dirty;
402 spin_unlock_irqrestore(&data_lock, flags);
403
404 if (!dirty && !shadow_dirty) {
405 r = 0;
406 break;
407 }
408
409 /* 4 iterations is the worst case:
410 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
411 * 2 - first VSYNC, dirty = true
412 * 3 - dirty = false, shadow_dirty = true
413 * 4 - shadow_dirty = false */
414 if (i++ == 3) {
415 DSSERR("mgr(%d)->wait_for_go() not finishing\n",
416 mgr->id);
417 r = 0;
418 break;
419 }
420
421 r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
422 if (r == -ERESTARTSYS)
423 break;
424
425 if (r) {
426 DSSERR("mgr(%d)->wait_for_go() timeout\n", mgr->id);
427 break;
428 }
429 }
430
431 return r;
432 }
433
dss_mgr_wait_for_go_ovl(struct omap_overlay * ovl)434 int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
435 {
436 unsigned long timeout = msecs_to_jiffies(500);
437 struct ovl_priv_data *op;
438 struct omap_dss_device *dssdev;
439 u32 irq;
440 int r;
441 int i;
442
443 if (!ovl->manager)
444 return 0;
445
446 dssdev = ovl->manager->device;
447
448 if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
449 return 0;
450
451 if (ovl_manual_update(ovl))
452 return 0;
453
454 irq = dispc_mgr_get_vsync_irq(ovl->manager->id);
455
456 op = get_ovl_priv(ovl);
457 i = 0;
458 while (1) {
459 unsigned long flags;
460 bool shadow_dirty, dirty;
461
462 spin_lock_irqsave(&data_lock, flags);
463 dirty = op->info_dirty;
464 shadow_dirty = op->shadow_info_dirty;
465 spin_unlock_irqrestore(&data_lock, flags);
466
467 if (!dirty && !shadow_dirty) {
468 r = 0;
469 break;
470 }
471
472 /* 4 iterations is the worst case:
473 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
474 * 2 - first VSYNC, dirty = true
475 * 3 - dirty = false, shadow_dirty = true
476 * 4 - shadow_dirty = false */
477 if (i++ == 3) {
478 DSSERR("ovl(%d)->wait_for_go() not finishing\n",
479 ovl->id);
480 r = 0;
481 break;
482 }
483
484 r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
485 if (r == -ERESTARTSYS)
486 break;
487
488 if (r) {
489 DSSERR("ovl(%d)->wait_for_go() timeout\n", ovl->id);
490 break;
491 }
492 }
493
494 return r;
495 }
496
dss_ovl_write_regs(struct omap_overlay * ovl)497 static void dss_ovl_write_regs(struct omap_overlay *ovl)
498 {
499 struct ovl_priv_data *op = get_ovl_priv(ovl);
500 struct omap_overlay_info *oi;
501 bool ilace, replication;
502 struct mgr_priv_data *mp;
503 int r;
504
505 DSSDBGF("%d", ovl->id);
506
507 if (!op->enabled || !op->info_dirty)
508 return;
509
510 oi = &op->info;
511
512 replication = dss_use_replication(ovl->manager->device, oi->color_mode);
513
514 ilace = ovl->manager->device->type == OMAP_DISPLAY_TYPE_VENC;
515
516 r = dispc_ovl_setup(ovl->id, oi, ilace, replication);
517 if (r) {
518 /*
519 * We can't do much here, as this function can be called from
520 * vsync interrupt.
521 */
522 DSSERR("dispc_ovl_setup failed for ovl %d\n", ovl->id);
523
524 /* This will leave fifo configurations in a nonoptimal state */
525 op->enabled = false;
526 dispc_ovl_enable(ovl->id, false);
527 return;
528 }
529
530 mp = get_mgr_priv(ovl->manager);
531
532 op->info_dirty = false;
533 if (mp->updating)
534 op->shadow_info_dirty = true;
535 }
536
dss_ovl_write_regs_extra(struct omap_overlay * ovl)537 static void dss_ovl_write_regs_extra(struct omap_overlay *ovl)
538 {
539 struct ovl_priv_data *op = get_ovl_priv(ovl);
540 struct mgr_priv_data *mp;
541
542 DSSDBGF("%d", ovl->id);
543
544 if (!op->extra_info_dirty)
545 return;
546
547 /* note: write also when op->enabled == false, so that the ovl gets
548 * disabled */
549
550 dispc_ovl_enable(ovl->id, op->enabled);
551 dispc_ovl_set_channel_out(ovl->id, op->channel);
552 dispc_ovl_set_fifo_threshold(ovl->id, op->fifo_low, op->fifo_high);
553
554 mp = get_mgr_priv(ovl->manager);
555
556 op->extra_info_dirty = false;
557 if (mp->updating)
558 op->shadow_extra_info_dirty = true;
559 }
560
dss_mgr_write_regs(struct omap_overlay_manager * mgr)561 static void dss_mgr_write_regs(struct omap_overlay_manager *mgr)
562 {
563 struct mgr_priv_data *mp = get_mgr_priv(mgr);
564 struct omap_overlay *ovl;
565
566 DSSDBGF("%d", mgr->id);
567
568 if (!mp->enabled)
569 return;
570
571 WARN_ON(mp->busy);
572
573 /* Commit overlay settings */
574 list_for_each_entry(ovl, &mgr->overlays, list) {
575 dss_ovl_write_regs(ovl);
576 dss_ovl_write_regs_extra(ovl);
577 }
578
579 if (mp->info_dirty) {
580 dispc_mgr_setup(mgr->id, &mp->info);
581
582 mp->info_dirty = false;
583 if (mp->updating)
584 mp->shadow_info_dirty = true;
585 }
586 }
587
dss_write_regs(void)588 static void dss_write_regs(void)
589 {
590 const int num_mgrs = omap_dss_get_num_overlay_managers();
591 int i;
592
593 for (i = 0; i < num_mgrs; ++i) {
594 struct omap_overlay_manager *mgr;
595 struct mgr_priv_data *mp;
596 int r;
597
598 mgr = omap_dss_get_overlay_manager(i);
599 mp = get_mgr_priv(mgr);
600
601 if (!mp->enabled || mgr_manual_update(mgr) || mp->busy)
602 continue;
603
604 r = dss_check_settings(mgr, mgr->device);
605 if (r) {
606 DSSERR("cannot write registers for manager %s: "
607 "illegal configuration\n", mgr->name);
608 continue;
609 }
610
611 dss_mgr_write_regs(mgr);
612 }
613 }
614
dss_set_go_bits(void)615 static void dss_set_go_bits(void)
616 {
617 const int num_mgrs = omap_dss_get_num_overlay_managers();
618 int i;
619
620 for (i = 0; i < num_mgrs; ++i) {
621 struct omap_overlay_manager *mgr;
622 struct mgr_priv_data *mp;
623
624 mgr = omap_dss_get_overlay_manager(i);
625 mp = get_mgr_priv(mgr);
626
627 if (!mp->enabled || mgr_manual_update(mgr) || mp->busy)
628 continue;
629
630 if (!need_go(mgr))
631 continue;
632
633 mp->busy = true;
634
635 if (!dss_data.irq_enabled && need_isr())
636 dss_register_vsync_isr();
637
638 dispc_mgr_go(mgr->id);
639 }
640
641 }
642
dss_mgr_start_update(struct omap_overlay_manager * mgr)643 void dss_mgr_start_update(struct omap_overlay_manager *mgr)
644 {
645 struct mgr_priv_data *mp = get_mgr_priv(mgr);
646 unsigned long flags;
647 int r;
648
649 spin_lock_irqsave(&data_lock, flags);
650
651 WARN_ON(mp->updating);
652
653 r = dss_check_settings(mgr, mgr->device);
654 if (r) {
655 DSSERR("cannot start manual update: illegal configuration\n");
656 spin_unlock_irqrestore(&data_lock, flags);
657 return;
658 }
659
660 dss_mgr_write_regs(mgr);
661
662 mp->updating = true;
663
664 if (!dss_data.irq_enabled && need_isr())
665 dss_register_vsync_isr();
666
667 dispc_mgr_enable(mgr->id, true);
668
669 spin_unlock_irqrestore(&data_lock, flags);
670 }
671
672 static void dss_apply_irq_handler(void *data, u32 mask);
673
dss_register_vsync_isr(void)674 static void dss_register_vsync_isr(void)
675 {
676 const int num_mgrs = dss_feat_get_num_mgrs();
677 u32 mask;
678 int r, i;
679
680 mask = 0;
681 for (i = 0; i < num_mgrs; ++i)
682 mask |= dispc_mgr_get_vsync_irq(i);
683
684 for (i = 0; i < num_mgrs; ++i)
685 mask |= dispc_mgr_get_framedone_irq(i);
686
687 r = omap_dispc_register_isr(dss_apply_irq_handler, NULL, mask);
688 WARN_ON(r);
689
690 dss_data.irq_enabled = true;
691 }
692
dss_unregister_vsync_isr(void)693 static void dss_unregister_vsync_isr(void)
694 {
695 const int num_mgrs = dss_feat_get_num_mgrs();
696 u32 mask;
697 int r, i;
698
699 mask = 0;
700 for (i = 0; i < num_mgrs; ++i)
701 mask |= dispc_mgr_get_vsync_irq(i);
702
703 for (i = 0; i < num_mgrs; ++i)
704 mask |= dispc_mgr_get_framedone_irq(i);
705
706 r = omap_dispc_unregister_isr(dss_apply_irq_handler, NULL, mask);
707 WARN_ON(r);
708
709 dss_data.irq_enabled = false;
710 }
711
mgr_clear_shadow_dirty(struct omap_overlay_manager * mgr)712 static void mgr_clear_shadow_dirty(struct omap_overlay_manager *mgr)
713 {
714 struct omap_overlay *ovl;
715 struct mgr_priv_data *mp;
716 struct ovl_priv_data *op;
717
718 mp = get_mgr_priv(mgr);
719 mp->shadow_info_dirty = false;
720
721 list_for_each_entry(ovl, &mgr->overlays, list) {
722 op = get_ovl_priv(ovl);
723 op->shadow_info_dirty = false;
724 op->shadow_extra_info_dirty = false;
725 }
726 }
727
dss_apply_irq_handler(void * data,u32 mask)728 static void dss_apply_irq_handler(void *data, u32 mask)
729 {
730 const int num_mgrs = dss_feat_get_num_mgrs();
731 int i;
732 bool extra_updating;
733
734 spin_lock(&data_lock);
735
736 /* clear busy, updating flags, shadow_dirty flags */
737 for (i = 0; i < num_mgrs; i++) {
738 struct omap_overlay_manager *mgr;
739 struct mgr_priv_data *mp;
740 bool was_updating;
741
742 mgr = omap_dss_get_overlay_manager(i);
743 mp = get_mgr_priv(mgr);
744
745 if (!mp->enabled)
746 continue;
747
748 was_updating = mp->updating;
749 mp->updating = dispc_mgr_is_enabled(i);
750
751 if (!mgr_manual_update(mgr)) {
752 bool was_busy = mp->busy;
753 mp->busy = dispc_mgr_go_busy(i);
754
755 if (was_busy && !mp->busy)
756 mgr_clear_shadow_dirty(mgr);
757 } else {
758 if (was_updating && !mp->updating)
759 mgr_clear_shadow_dirty(mgr);
760 }
761 }
762
763 dss_write_regs();
764 dss_set_go_bits();
765
766 extra_updating = extra_info_update_ongoing();
767 if (!extra_updating)
768 complete_all(&extra_updated_completion);
769
770 if (!need_isr())
771 dss_unregister_vsync_isr();
772
773 spin_unlock(&data_lock);
774 }
775
omap_dss_mgr_apply_ovl(struct omap_overlay * ovl)776 static void omap_dss_mgr_apply_ovl(struct omap_overlay *ovl)
777 {
778 struct ovl_priv_data *op;
779
780 op = get_ovl_priv(ovl);
781
782 if (!op->user_info_dirty)
783 return;
784
785 op->user_info_dirty = false;
786 op->info_dirty = true;
787 op->info = op->user_info;
788 }
789
omap_dss_mgr_apply_mgr(struct omap_overlay_manager * mgr)790 static void omap_dss_mgr_apply_mgr(struct omap_overlay_manager *mgr)
791 {
792 struct mgr_priv_data *mp;
793
794 mp = get_mgr_priv(mgr);
795
796 if (!mp->user_info_dirty)
797 return;
798
799 mp->user_info_dirty = false;
800 mp->info_dirty = true;
801 mp->info = mp->user_info;
802 }
803
omap_dss_mgr_apply(struct omap_overlay_manager * mgr)804 int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
805 {
806 unsigned long flags;
807 struct omap_overlay *ovl;
808 int r;
809
810 DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name);
811
812 spin_lock_irqsave(&data_lock, flags);
813
814 r = dss_check_settings_apply(mgr, mgr->device);
815 if (r) {
816 spin_unlock_irqrestore(&data_lock, flags);
817 DSSERR("failed to apply settings: illegal configuration.\n");
818 return r;
819 }
820
821 /* Configure overlays */
822 list_for_each_entry(ovl, &mgr->overlays, list)
823 omap_dss_mgr_apply_ovl(ovl);
824
825 /* Configure manager */
826 omap_dss_mgr_apply_mgr(mgr);
827
828 dss_write_regs();
829 dss_set_go_bits();
830
831 spin_unlock_irqrestore(&data_lock, flags);
832
833 return 0;
834 }
835
dss_apply_ovl_enable(struct omap_overlay * ovl,bool enable)836 static void dss_apply_ovl_enable(struct omap_overlay *ovl, bool enable)
837 {
838 struct ovl_priv_data *op;
839
840 op = get_ovl_priv(ovl);
841
842 if (op->enabled == enable)
843 return;
844
845 op->enabled = enable;
846 op->extra_info_dirty = true;
847 }
848
dss_apply_ovl_fifo_thresholds(struct omap_overlay * ovl,u32 fifo_low,u32 fifo_high)849 static void dss_apply_ovl_fifo_thresholds(struct omap_overlay *ovl,
850 u32 fifo_low, u32 fifo_high)
851 {
852 struct ovl_priv_data *op = get_ovl_priv(ovl);
853
854 if (op->fifo_low == fifo_low && op->fifo_high == fifo_high)
855 return;
856
857 op->fifo_low = fifo_low;
858 op->fifo_high = fifo_high;
859 op->extra_info_dirty = true;
860 }
861
dss_ovl_setup_fifo(struct omap_overlay * ovl)862 static void dss_ovl_setup_fifo(struct omap_overlay *ovl)
863 {
864 struct ovl_priv_data *op = get_ovl_priv(ovl);
865 struct omap_dss_device *dssdev;
866 u32 size, burst_size;
867 u32 fifo_low, fifo_high;
868
869 if (!op->enabled && !op->enabling)
870 return;
871
872 dssdev = ovl->manager->device;
873
874 size = dispc_ovl_get_fifo_size(ovl->id);
875
876 burst_size = dispc_ovl_get_burst_size(ovl->id);
877
878 switch (dssdev->type) {
879 case OMAP_DISPLAY_TYPE_DPI:
880 case OMAP_DISPLAY_TYPE_DBI:
881 case OMAP_DISPLAY_TYPE_SDI:
882 case OMAP_DISPLAY_TYPE_VENC:
883 case OMAP_DISPLAY_TYPE_HDMI:
884 default_get_overlay_fifo_thresholds(ovl->id, size,
885 burst_size, &fifo_low, &fifo_high);
886 break;
887 #ifdef CONFIG_OMAP2_DSS_DSI
888 case OMAP_DISPLAY_TYPE_DSI:
889 dsi_get_overlay_fifo_thresholds(ovl->id, size,
890 burst_size, &fifo_low, &fifo_high);
891 break;
892 #endif
893 default:
894 BUG();
895 }
896
897 dss_apply_ovl_fifo_thresholds(ovl, fifo_low, fifo_high);
898 }
899
dss_mgr_setup_fifos(struct omap_overlay_manager * mgr)900 static void dss_mgr_setup_fifos(struct omap_overlay_manager *mgr)
901 {
902 struct omap_overlay *ovl;
903 struct mgr_priv_data *mp;
904
905 mp = get_mgr_priv(mgr);
906
907 if (!mp->enabled)
908 return;
909
910 list_for_each_entry(ovl, &mgr->overlays, list)
911 dss_ovl_setup_fifo(ovl);
912 }
913
dss_setup_fifos(void)914 static void dss_setup_fifos(void)
915 {
916 const int num_mgrs = omap_dss_get_num_overlay_managers();
917 struct omap_overlay_manager *mgr;
918 int i;
919
920 for (i = 0; i < num_mgrs; ++i) {
921 mgr = omap_dss_get_overlay_manager(i);
922 dss_mgr_setup_fifos(mgr);
923 }
924 }
925
dss_mgr_enable(struct omap_overlay_manager * mgr)926 int dss_mgr_enable(struct omap_overlay_manager *mgr)
927 {
928 struct mgr_priv_data *mp = get_mgr_priv(mgr);
929 unsigned long flags;
930 int r;
931
932 mutex_lock(&apply_lock);
933
934 if (mp->enabled)
935 goto out;
936
937 spin_lock_irqsave(&data_lock, flags);
938
939 mp->enabled = true;
940
941 r = dss_check_settings(mgr, mgr->device);
942 if (r) {
943 DSSERR("failed to enable manager %d: check_settings failed\n",
944 mgr->id);
945 goto err;
946 }
947
948 dss_setup_fifos();
949
950 dss_write_regs();
951 dss_set_go_bits();
952
953 if (!mgr_manual_update(mgr))
954 mp->updating = true;
955
956 spin_unlock_irqrestore(&data_lock, flags);
957
958 if (!mgr_manual_update(mgr))
959 dispc_mgr_enable(mgr->id, true);
960
961 out:
962 mutex_unlock(&apply_lock);
963
964 return 0;
965
966 err:
967 mp->enabled = false;
968 spin_unlock_irqrestore(&data_lock, flags);
969 mutex_unlock(&apply_lock);
970 return r;
971 }
972
dss_mgr_disable(struct omap_overlay_manager * mgr)973 void dss_mgr_disable(struct omap_overlay_manager *mgr)
974 {
975 struct mgr_priv_data *mp = get_mgr_priv(mgr);
976 unsigned long flags;
977
978 mutex_lock(&apply_lock);
979
980 if (!mp->enabled)
981 goto out;
982
983 if (!mgr_manual_update(mgr))
984 dispc_mgr_enable(mgr->id, false);
985
986 spin_lock_irqsave(&data_lock, flags);
987
988 mp->updating = false;
989 mp->enabled = false;
990
991 spin_unlock_irqrestore(&data_lock, flags);
992
993 out:
994 mutex_unlock(&apply_lock);
995 }
996
dss_mgr_set_info(struct omap_overlay_manager * mgr,struct omap_overlay_manager_info * info)997 int dss_mgr_set_info(struct omap_overlay_manager *mgr,
998 struct omap_overlay_manager_info *info)
999 {
1000 struct mgr_priv_data *mp = get_mgr_priv(mgr);
1001 unsigned long flags;
1002 int r;
1003
1004 r = dss_mgr_simple_check(mgr, info);
1005 if (r)
1006 return r;
1007
1008 spin_lock_irqsave(&data_lock, flags);
1009
1010 mp->user_info = *info;
1011 mp->user_info_dirty = true;
1012
1013 spin_unlock_irqrestore(&data_lock, flags);
1014
1015 return 0;
1016 }
1017
dss_mgr_get_info(struct omap_overlay_manager * mgr,struct omap_overlay_manager_info * info)1018 void dss_mgr_get_info(struct omap_overlay_manager *mgr,
1019 struct omap_overlay_manager_info *info)
1020 {
1021 struct mgr_priv_data *mp = get_mgr_priv(mgr);
1022 unsigned long flags;
1023
1024 spin_lock_irqsave(&data_lock, flags);
1025
1026 *info = mp->user_info;
1027
1028 spin_unlock_irqrestore(&data_lock, flags);
1029 }
1030
dss_mgr_set_device(struct omap_overlay_manager * mgr,struct omap_dss_device * dssdev)1031 int dss_mgr_set_device(struct omap_overlay_manager *mgr,
1032 struct omap_dss_device *dssdev)
1033 {
1034 int r;
1035
1036 mutex_lock(&apply_lock);
1037
1038 if (dssdev->manager) {
1039 DSSERR("display '%s' already has a manager '%s'\n",
1040 dssdev->name, dssdev->manager->name);
1041 r = -EINVAL;
1042 goto err;
1043 }
1044
1045 if ((mgr->supported_displays & dssdev->type) == 0) {
1046 DSSERR("display '%s' does not support manager '%s'\n",
1047 dssdev->name, mgr->name);
1048 r = -EINVAL;
1049 goto err;
1050 }
1051
1052 dssdev->manager = mgr;
1053 mgr->device = dssdev;
1054
1055 mutex_unlock(&apply_lock);
1056
1057 return 0;
1058 err:
1059 mutex_unlock(&apply_lock);
1060 return r;
1061 }
1062
dss_mgr_unset_device(struct omap_overlay_manager * mgr)1063 int dss_mgr_unset_device(struct omap_overlay_manager *mgr)
1064 {
1065 int r;
1066
1067 mutex_lock(&apply_lock);
1068
1069 if (!mgr->device) {
1070 DSSERR("failed to unset display, display not set.\n");
1071 r = -EINVAL;
1072 goto err;
1073 }
1074
1075 /*
1076 * Don't allow currently enabled displays to have the overlay manager
1077 * pulled out from underneath them
1078 */
1079 if (mgr->device->state != OMAP_DSS_DISPLAY_DISABLED) {
1080 r = -EINVAL;
1081 goto err;
1082 }
1083
1084 mgr->device->manager = NULL;
1085 mgr->device = NULL;
1086
1087 mutex_unlock(&apply_lock);
1088
1089 return 0;
1090 err:
1091 mutex_unlock(&apply_lock);
1092 return r;
1093 }
1094
1095
dss_ovl_set_info(struct omap_overlay * ovl,struct omap_overlay_info * info)1096 int dss_ovl_set_info(struct omap_overlay *ovl,
1097 struct omap_overlay_info *info)
1098 {
1099 struct ovl_priv_data *op = get_ovl_priv(ovl);
1100 unsigned long flags;
1101 int r;
1102
1103 r = dss_ovl_simple_check(ovl, info);
1104 if (r)
1105 return r;
1106
1107 spin_lock_irqsave(&data_lock, flags);
1108
1109 op->user_info = *info;
1110 op->user_info_dirty = true;
1111
1112 spin_unlock_irqrestore(&data_lock, flags);
1113
1114 return 0;
1115 }
1116
dss_ovl_get_info(struct omap_overlay * ovl,struct omap_overlay_info * info)1117 void dss_ovl_get_info(struct omap_overlay *ovl,
1118 struct omap_overlay_info *info)
1119 {
1120 struct ovl_priv_data *op = get_ovl_priv(ovl);
1121 unsigned long flags;
1122
1123 spin_lock_irqsave(&data_lock, flags);
1124
1125 *info = op->user_info;
1126
1127 spin_unlock_irqrestore(&data_lock, flags);
1128 }
1129
dss_ovl_set_manager(struct omap_overlay * ovl,struct omap_overlay_manager * mgr)1130 int dss_ovl_set_manager(struct omap_overlay *ovl,
1131 struct omap_overlay_manager *mgr)
1132 {
1133 struct ovl_priv_data *op = get_ovl_priv(ovl);
1134 unsigned long flags;
1135 int r;
1136
1137 if (!mgr)
1138 return -EINVAL;
1139
1140 mutex_lock(&apply_lock);
1141
1142 if (ovl->manager) {
1143 DSSERR("overlay '%s' already has a manager '%s'\n",
1144 ovl->name, ovl->manager->name);
1145 r = -EINVAL;
1146 goto err;
1147 }
1148
1149 spin_lock_irqsave(&data_lock, flags);
1150
1151 if (op->enabled) {
1152 spin_unlock_irqrestore(&data_lock, flags);
1153 DSSERR("overlay has to be disabled to change the manager\n");
1154 r = -EINVAL;
1155 goto err;
1156 }
1157
1158 op->channel = mgr->id;
1159 op->extra_info_dirty = true;
1160
1161 ovl->manager = mgr;
1162 list_add_tail(&ovl->list, &mgr->overlays);
1163
1164 spin_unlock_irqrestore(&data_lock, flags);
1165
1166 /* XXX: When there is an overlay on a DSI manual update display, and
1167 * the overlay is first disabled, then moved to tv, and enabled, we
1168 * seem to get SYNC_LOST_DIGIT error.
1169 *
1170 * Waiting doesn't seem to help, but updating the manual update display
1171 * after disabling the overlay seems to fix this. This hints that the
1172 * overlay is perhaps somehow tied to the LCD output until the output
1173 * is updated.
1174 *
1175 * Userspace workaround for this is to update the LCD after disabling
1176 * the overlay, but before moving the overlay to TV.
1177 */
1178
1179 mutex_unlock(&apply_lock);
1180
1181 return 0;
1182 err:
1183 mutex_unlock(&apply_lock);
1184 return r;
1185 }
1186
dss_ovl_unset_manager(struct omap_overlay * ovl)1187 int dss_ovl_unset_manager(struct omap_overlay *ovl)
1188 {
1189 struct ovl_priv_data *op = get_ovl_priv(ovl);
1190 unsigned long flags;
1191 int r;
1192
1193 mutex_lock(&apply_lock);
1194
1195 if (!ovl->manager) {
1196 DSSERR("failed to detach overlay: manager not set\n");
1197 r = -EINVAL;
1198 goto err;
1199 }
1200
1201 spin_lock_irqsave(&data_lock, flags);
1202
1203 if (op->enabled) {
1204 spin_unlock_irqrestore(&data_lock, flags);
1205 DSSERR("overlay has to be disabled to unset the manager\n");
1206 r = -EINVAL;
1207 goto err;
1208 }
1209
1210 op->channel = -1;
1211
1212 ovl->manager = NULL;
1213 list_del(&ovl->list);
1214
1215 spin_unlock_irqrestore(&data_lock, flags);
1216
1217 mutex_unlock(&apply_lock);
1218
1219 return 0;
1220 err:
1221 mutex_unlock(&apply_lock);
1222 return r;
1223 }
1224
dss_ovl_is_enabled(struct omap_overlay * ovl)1225 bool dss_ovl_is_enabled(struct omap_overlay *ovl)
1226 {
1227 struct ovl_priv_data *op = get_ovl_priv(ovl);
1228 unsigned long flags;
1229 bool e;
1230
1231 spin_lock_irqsave(&data_lock, flags);
1232
1233 e = op->enabled;
1234
1235 spin_unlock_irqrestore(&data_lock, flags);
1236
1237 return e;
1238 }
1239
dss_ovl_enable(struct omap_overlay * ovl)1240 int dss_ovl_enable(struct omap_overlay *ovl)
1241 {
1242 struct ovl_priv_data *op = get_ovl_priv(ovl);
1243 unsigned long flags;
1244 int r;
1245
1246 mutex_lock(&apply_lock);
1247
1248 if (op->enabled) {
1249 r = 0;
1250 goto err1;
1251 }
1252
1253 if (ovl->manager == NULL || ovl->manager->device == NULL) {
1254 r = -EINVAL;
1255 goto err1;
1256 }
1257
1258 spin_lock_irqsave(&data_lock, flags);
1259
1260 op->enabling = true;
1261
1262 r = dss_check_settings(ovl->manager, ovl->manager->device);
1263 if (r) {
1264 DSSERR("failed to enable overlay %d: check_settings failed\n",
1265 ovl->id);
1266 goto err2;
1267 }
1268
1269 dss_setup_fifos();
1270
1271 op->enabling = false;
1272 dss_apply_ovl_enable(ovl, true);
1273
1274 dss_write_regs();
1275 dss_set_go_bits();
1276
1277 spin_unlock_irqrestore(&data_lock, flags);
1278
1279 /* wait for overlay to be enabled */
1280 wait_pending_extra_info_updates();
1281
1282 mutex_unlock(&apply_lock);
1283
1284 return 0;
1285 err2:
1286 op->enabling = false;
1287 spin_unlock_irqrestore(&data_lock, flags);
1288 err1:
1289 mutex_unlock(&apply_lock);
1290 return r;
1291 }
1292
dss_ovl_disable(struct omap_overlay * ovl)1293 int dss_ovl_disable(struct omap_overlay *ovl)
1294 {
1295 struct ovl_priv_data *op = get_ovl_priv(ovl);
1296 unsigned long flags;
1297 int r;
1298
1299 mutex_lock(&apply_lock);
1300
1301 if (!op->enabled) {
1302 r = 0;
1303 goto err;
1304 }
1305
1306 if (ovl->manager == NULL || ovl->manager->device == NULL) {
1307 r = -EINVAL;
1308 goto err;
1309 }
1310
1311 spin_lock_irqsave(&data_lock, flags);
1312
1313 dss_apply_ovl_enable(ovl, false);
1314 dss_write_regs();
1315 dss_set_go_bits();
1316
1317 spin_unlock_irqrestore(&data_lock, flags);
1318
1319 /* wait for the overlay to be disabled */
1320 wait_pending_extra_info_updates();
1321
1322 mutex_unlock(&apply_lock);
1323
1324 return 0;
1325
1326 err:
1327 mutex_unlock(&apply_lock);
1328 return r;
1329 }
1330
1331