1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2011 Texas Instruments
4  * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
5  */
6 
7 #define DSS_SUBSYS_NAME "APPLY"
8 
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/jiffies.h>
14 
15 #include <video/omapfb_dss.h>
16 
17 #include "dss.h"
18 #include "dss_features.h"
19 #include "dispc-compat.h"
20 
21 /*
22  * We have 4 levels of cache for the dispc settings. First two are in SW and
23  * the latter two in HW.
24  *
25  *       set_info()
26  *          v
27  * +--------------------+
28  * |     user_info      |
29  * +--------------------+
30  *          v
31  *        apply()
32  *          v
33  * +--------------------+
34  * |       info         |
35  * +--------------------+
36  *          v
37  *      write_regs()
38  *          v
39  * +--------------------+
40  * |  shadow registers  |
41  * +--------------------+
42  *          v
43  * VFP or lcd/digit_enable
44  *          v
45  * +--------------------+
46  * |      registers     |
47  * +--------------------+
48  */
49 
50 struct ovl_priv_data {
51 
52 	bool user_info_dirty;
53 	struct omap_overlay_info user_info;
54 
55 	bool info_dirty;
56 	struct omap_overlay_info info;
57 
58 	bool shadow_info_dirty;
59 
60 	bool extra_info_dirty;
61 	bool shadow_extra_info_dirty;
62 
63 	bool enabled;
64 	u32 fifo_low, fifo_high;
65 
66 	/*
67 	 * True if overlay is to be enabled. Used to check and calculate configs
68 	 * for the overlay before it is enabled in the HW.
69 	 */
70 	bool enabling;
71 };
72 
73 struct mgr_priv_data {
74 
75 	bool user_info_dirty;
76 	struct omap_overlay_manager_info user_info;
77 
78 	bool info_dirty;
79 	struct omap_overlay_manager_info info;
80 
81 	bool shadow_info_dirty;
82 
83 	/* If true, GO bit is up and shadow registers cannot be written.
84 	 * Never true for manual update displays */
85 	bool busy;
86 
87 	/* If true, dispc output is enabled */
88 	bool updating;
89 
90 	/* If true, a display is enabled using this manager */
91 	bool enabled;
92 
93 	bool extra_info_dirty;
94 	bool shadow_extra_info_dirty;
95 
96 	struct omap_video_timings timings;
97 	struct dss_lcd_mgr_config lcd_config;
98 
99 	void (*framedone_handler)(void *);
100 	void *framedone_handler_data;
101 };
102 
103 static struct {
104 	struct ovl_priv_data ovl_priv_data_array[MAX_DSS_OVERLAYS];
105 	struct mgr_priv_data mgr_priv_data_array[MAX_DSS_MANAGERS];
106 
107 	bool irq_enabled;
108 } dss_data;
109 
110 /* protects dss_data */
111 static DEFINE_SPINLOCK(data_lock);
112 /* lock for blocking functions */
113 static DEFINE_MUTEX(apply_lock);
114 static DECLARE_COMPLETION(extra_updated_completion);
115 
116 static void dss_register_vsync_isr(void);
117 
118 static struct ovl_priv_data *get_ovl_priv(struct omap_overlay *ovl)
119 {
120 	return &dss_data.ovl_priv_data_array[ovl->id];
121 }
122 
123 static struct mgr_priv_data *get_mgr_priv(struct omap_overlay_manager *mgr)
124 {
125 	return &dss_data.mgr_priv_data_array[mgr->id];
126 }
127 
128 static void apply_init_priv(void)
129 {
130 	const int num_ovls = dss_feat_get_num_ovls();
131 	struct mgr_priv_data *mp;
132 	int i;
133 
134 	for (i = 0; i < num_ovls; ++i) {
135 		struct ovl_priv_data *op;
136 
137 		op = &dss_data.ovl_priv_data_array[i];
138 
139 		op->info.color_mode = OMAP_DSS_COLOR_RGB16;
140 		op->info.rotation_type = OMAP_DSS_ROT_DMA;
141 
142 		op->info.global_alpha = 255;
143 
144 		switch (i) {
145 		case 0:
146 			op->info.zorder = 0;
147 			break;
148 		case 1:
149 			op->info.zorder =
150 				dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 3 : 0;
151 			break;
152 		case 2:
153 			op->info.zorder =
154 				dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 2 : 0;
155 			break;
156 		case 3:
157 			op->info.zorder =
158 				dss_has_feature(FEAT_ALPHA_FREE_ZORDER) ? 1 : 0;
159 			break;
160 		}
161 
162 		op->user_info = op->info;
163 	}
164 
165 	/*
166 	 * Initialize some of the lcd_config fields for TV manager, this lets
167 	 * us prevent checking if the manager is LCD or TV at some places
168 	 */
169 	mp = &dss_data.mgr_priv_data_array[OMAP_DSS_CHANNEL_DIGIT];
170 
171 	mp->lcd_config.video_port_width = 24;
172 	mp->lcd_config.clock_info.lck_div = 1;
173 	mp->lcd_config.clock_info.pck_div = 1;
174 }
175 
176 /*
177  * A LCD manager's stallmode decides whether it is in manual or auto update. TV
178  * manager is always auto update, stallmode field for TV manager is false by
179  * default
180  */
181 static bool ovl_manual_update(struct omap_overlay *ovl)
182 {
183 	struct mgr_priv_data *mp = get_mgr_priv(ovl->manager);
184 
185 	return mp->lcd_config.stallmode;
186 }
187 
188 static bool mgr_manual_update(struct omap_overlay_manager *mgr)
189 {
190 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
191 
192 	return mp->lcd_config.stallmode;
193 }
194 
195 static int dss_check_settings_low(struct omap_overlay_manager *mgr,
196 		bool applying)
197 {
198 	struct omap_overlay_info *oi;
199 	struct omap_overlay_manager_info *mi;
200 	struct omap_overlay *ovl;
201 	struct omap_overlay_info *ois[MAX_DSS_OVERLAYS];
202 	struct ovl_priv_data *op;
203 	struct mgr_priv_data *mp;
204 
205 	mp = get_mgr_priv(mgr);
206 
207 	if (!mp->enabled)
208 		return 0;
209 
210 	if (applying && mp->user_info_dirty)
211 		mi = &mp->user_info;
212 	else
213 		mi = &mp->info;
214 
215 	/* collect the infos to be tested into the array */
216 	list_for_each_entry(ovl, &mgr->overlays, list) {
217 		op = get_ovl_priv(ovl);
218 
219 		if (!op->enabled && !op->enabling)
220 			oi = NULL;
221 		else if (applying && op->user_info_dirty)
222 			oi = &op->user_info;
223 		else
224 			oi = &op->info;
225 
226 		ois[ovl->id] = oi;
227 	}
228 
229 	return dss_mgr_check(mgr, mi, &mp->timings, &mp->lcd_config, ois);
230 }
231 
232 /*
233  * check manager and overlay settings using overlay_info from data->info
234  */
235 static int dss_check_settings(struct omap_overlay_manager *mgr)
236 {
237 	return dss_check_settings_low(mgr, false);
238 }
239 
240 /*
241  * check manager and overlay settings using overlay_info from ovl->info if
242  * dirty and from data->info otherwise
243  */
244 static int dss_check_settings_apply(struct omap_overlay_manager *mgr)
245 {
246 	return dss_check_settings_low(mgr, true);
247 }
248 
249 static bool need_isr(void)
250 {
251 	const int num_mgrs = dss_feat_get_num_mgrs();
252 	int i;
253 
254 	for (i = 0; i < num_mgrs; ++i) {
255 		struct omap_overlay_manager *mgr;
256 		struct mgr_priv_data *mp;
257 		struct omap_overlay *ovl;
258 
259 		mgr = omap_dss_get_overlay_manager(i);
260 		mp = get_mgr_priv(mgr);
261 
262 		if (!mp->enabled)
263 			continue;
264 
265 		if (mgr_manual_update(mgr)) {
266 			/* to catch FRAMEDONE */
267 			if (mp->updating)
268 				return true;
269 		} else {
270 			/* to catch GO bit going down */
271 			if (mp->busy)
272 				return true;
273 
274 			/* to write new values to registers */
275 			if (mp->info_dirty)
276 				return true;
277 
278 			/* to set GO bit */
279 			if (mp->shadow_info_dirty)
280 				return true;
281 
282 			/*
283 			 * NOTE: we don't check extra_info flags for disabled
284 			 * managers, once the manager is enabled, the extra_info
285 			 * related manager changes will be taken in by HW.
286 			 */
287 
288 			/* to write new values to registers */
289 			if (mp->extra_info_dirty)
290 				return true;
291 
292 			/* to set GO bit */
293 			if (mp->shadow_extra_info_dirty)
294 				return true;
295 
296 			list_for_each_entry(ovl, &mgr->overlays, list) {
297 				struct ovl_priv_data *op;
298 
299 				op = get_ovl_priv(ovl);
300 
301 				/*
302 				 * NOTE: we check extra_info flags even for
303 				 * disabled overlays, as extra_infos need to be
304 				 * always written.
305 				 */
306 
307 				/* to write new values to registers */
308 				if (op->extra_info_dirty)
309 					return true;
310 
311 				/* to set GO bit */
312 				if (op->shadow_extra_info_dirty)
313 					return true;
314 
315 				if (!op->enabled)
316 					continue;
317 
318 				/* to write new values to registers */
319 				if (op->info_dirty)
320 					return true;
321 
322 				/* to set GO bit */
323 				if (op->shadow_info_dirty)
324 					return true;
325 			}
326 		}
327 	}
328 
329 	return false;
330 }
331 
332 static bool need_go(struct omap_overlay_manager *mgr)
333 {
334 	struct omap_overlay *ovl;
335 	struct mgr_priv_data *mp;
336 	struct ovl_priv_data *op;
337 
338 	mp = get_mgr_priv(mgr);
339 
340 	if (mp->shadow_info_dirty || mp->shadow_extra_info_dirty)
341 		return true;
342 
343 	list_for_each_entry(ovl, &mgr->overlays, list) {
344 		op = get_ovl_priv(ovl);
345 		if (op->shadow_info_dirty || op->shadow_extra_info_dirty)
346 			return true;
347 	}
348 
349 	return false;
350 }
351 
352 /* returns true if an extra_info field is currently being updated */
353 static bool extra_info_update_ongoing(void)
354 {
355 	const int num_mgrs = dss_feat_get_num_mgrs();
356 	int i;
357 
358 	for (i = 0; i < num_mgrs; ++i) {
359 		struct omap_overlay_manager *mgr;
360 		struct omap_overlay *ovl;
361 		struct mgr_priv_data *mp;
362 
363 		mgr = omap_dss_get_overlay_manager(i);
364 		mp = get_mgr_priv(mgr);
365 
366 		if (!mp->enabled)
367 			continue;
368 
369 		if (!mp->updating)
370 			continue;
371 
372 		if (mp->extra_info_dirty || mp->shadow_extra_info_dirty)
373 			return true;
374 
375 		list_for_each_entry(ovl, &mgr->overlays, list) {
376 			struct ovl_priv_data *op = get_ovl_priv(ovl);
377 
378 			if (op->extra_info_dirty || op->shadow_extra_info_dirty)
379 				return true;
380 		}
381 	}
382 
383 	return false;
384 }
385 
386 /* wait until no extra_info updates are pending */
387 static void wait_pending_extra_info_updates(void)
388 {
389 	bool updating;
390 	unsigned long flags;
391 	unsigned long t;
392 	int r;
393 
394 	spin_lock_irqsave(&data_lock, flags);
395 
396 	updating = extra_info_update_ongoing();
397 
398 	if (!updating) {
399 		spin_unlock_irqrestore(&data_lock, flags);
400 		return;
401 	}
402 
403 	init_completion(&extra_updated_completion);
404 
405 	spin_unlock_irqrestore(&data_lock, flags);
406 
407 	t = msecs_to_jiffies(500);
408 	r = wait_for_completion_timeout(&extra_updated_completion, t);
409 	if (r == 0)
410 		DSSWARN("timeout in wait_pending_extra_info_updates\n");
411 }
412 
413 static struct omap_dss_device *dss_mgr_get_device(struct omap_overlay_manager *mgr)
414 {
415 	struct omap_dss_device *dssdev;
416 
417 	dssdev = mgr->output;
418 	if (dssdev == NULL)
419 		return NULL;
420 
421 	while (dssdev->dst)
422 		dssdev = dssdev->dst;
423 
424 	if (dssdev->driver)
425 		return dssdev;
426 	else
427 		return NULL;
428 }
429 
430 static struct omap_dss_device *dss_ovl_get_device(struct omap_overlay *ovl)
431 {
432 	return ovl->manager ? dss_mgr_get_device(ovl->manager) : NULL;
433 }
434 
435 static int dss_mgr_wait_for_vsync(struct omap_overlay_manager *mgr)
436 {
437 	unsigned long timeout = msecs_to_jiffies(500);
438 	u32 irq;
439 	int r;
440 
441 	if (mgr->output == NULL)
442 		return -ENODEV;
443 
444 	r = dispc_runtime_get();
445 	if (r)
446 		return r;
447 
448 	switch (mgr->output->id) {
449 	case OMAP_DSS_OUTPUT_VENC:
450 		irq = DISPC_IRQ_EVSYNC_ODD;
451 		break;
452 	case OMAP_DSS_OUTPUT_HDMI:
453 		irq = DISPC_IRQ_EVSYNC_EVEN;
454 		break;
455 	default:
456 		irq = dispc_mgr_get_vsync_irq(mgr->id);
457 		break;
458 	}
459 
460 	r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
461 
462 	dispc_runtime_put();
463 
464 	return r;
465 }
466 
467 static int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
468 {
469 	unsigned long timeout = msecs_to_jiffies(500);
470 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
471 	u32 irq;
472 	unsigned long flags;
473 	int r;
474 	int i;
475 
476 	spin_lock_irqsave(&data_lock, flags);
477 
478 	if (mgr_manual_update(mgr)) {
479 		spin_unlock_irqrestore(&data_lock, flags);
480 		return 0;
481 	}
482 
483 	if (!mp->enabled) {
484 		spin_unlock_irqrestore(&data_lock, flags);
485 		return 0;
486 	}
487 
488 	spin_unlock_irqrestore(&data_lock, flags);
489 
490 	r = dispc_runtime_get();
491 	if (r)
492 		return r;
493 
494 	irq = dispc_mgr_get_vsync_irq(mgr->id);
495 
496 	i = 0;
497 	while (1) {
498 		bool shadow_dirty, dirty;
499 
500 		spin_lock_irqsave(&data_lock, flags);
501 		dirty = mp->info_dirty;
502 		shadow_dirty = mp->shadow_info_dirty;
503 		spin_unlock_irqrestore(&data_lock, flags);
504 
505 		if (!dirty && !shadow_dirty) {
506 			r = 0;
507 			break;
508 		}
509 
510 		/* 4 iterations is the worst case:
511 		 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
512 		 * 2 - first VSYNC, dirty = true
513 		 * 3 - dirty = false, shadow_dirty = true
514 		 * 4 - shadow_dirty = false */
515 		if (i++ == 3) {
516 			DSSERR("mgr(%d)->wait_for_go() not finishing\n",
517 					mgr->id);
518 			r = 0;
519 			break;
520 		}
521 
522 		r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
523 		if (r == -ERESTARTSYS)
524 			break;
525 
526 		if (r) {
527 			DSSERR("mgr(%d)->wait_for_go() timeout\n", mgr->id);
528 			break;
529 		}
530 	}
531 
532 	dispc_runtime_put();
533 
534 	return r;
535 }
536 
537 static int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
538 {
539 	unsigned long timeout = msecs_to_jiffies(500);
540 	struct ovl_priv_data *op;
541 	struct mgr_priv_data *mp;
542 	u32 irq;
543 	unsigned long flags;
544 	int r;
545 	int i;
546 
547 	if (!ovl->manager)
548 		return 0;
549 
550 	mp = get_mgr_priv(ovl->manager);
551 
552 	spin_lock_irqsave(&data_lock, flags);
553 
554 	if (ovl_manual_update(ovl)) {
555 		spin_unlock_irqrestore(&data_lock, flags);
556 		return 0;
557 	}
558 
559 	if (!mp->enabled) {
560 		spin_unlock_irqrestore(&data_lock, flags);
561 		return 0;
562 	}
563 
564 	spin_unlock_irqrestore(&data_lock, flags);
565 
566 	r = dispc_runtime_get();
567 	if (r)
568 		return r;
569 
570 	irq = dispc_mgr_get_vsync_irq(ovl->manager->id);
571 
572 	op = get_ovl_priv(ovl);
573 	i = 0;
574 	while (1) {
575 		bool shadow_dirty, dirty;
576 
577 		spin_lock_irqsave(&data_lock, flags);
578 		dirty = op->info_dirty;
579 		shadow_dirty = op->shadow_info_dirty;
580 		spin_unlock_irqrestore(&data_lock, flags);
581 
582 		if (!dirty && !shadow_dirty) {
583 			r = 0;
584 			break;
585 		}
586 
587 		/* 4 iterations is the worst case:
588 		 * 1 - initial iteration, dirty = true (between VFP and VSYNC)
589 		 * 2 - first VSYNC, dirty = true
590 		 * 3 - dirty = false, shadow_dirty = true
591 		 * 4 - shadow_dirty = false */
592 		if (i++ == 3) {
593 			DSSERR("ovl(%d)->wait_for_go() not finishing\n",
594 					ovl->id);
595 			r = 0;
596 			break;
597 		}
598 
599 		r = omap_dispc_wait_for_irq_interruptible_timeout(irq, timeout);
600 		if (r == -ERESTARTSYS)
601 			break;
602 
603 		if (r) {
604 			DSSERR("ovl(%d)->wait_for_go() timeout\n", ovl->id);
605 			break;
606 		}
607 	}
608 
609 	dispc_runtime_put();
610 
611 	return r;
612 }
613 
614 static void dss_ovl_write_regs(struct omap_overlay *ovl)
615 {
616 	struct ovl_priv_data *op = get_ovl_priv(ovl);
617 	struct omap_overlay_info *oi;
618 	bool replication;
619 	struct mgr_priv_data *mp;
620 	int r;
621 
622 	DSSDBG("writing ovl %d regs\n", ovl->id);
623 
624 	if (!op->enabled || !op->info_dirty)
625 		return;
626 
627 	oi = &op->info;
628 
629 	mp = get_mgr_priv(ovl->manager);
630 
631 	replication = dss_ovl_use_replication(mp->lcd_config, oi->color_mode);
632 
633 	r = dispc_ovl_setup(ovl->id, oi, replication, &mp->timings, false);
634 	if (r) {
635 		/*
636 		 * We can't do much here, as this function can be called from
637 		 * vsync interrupt.
638 		 */
639 		DSSERR("dispc_ovl_setup failed for ovl %d\n", ovl->id);
640 
641 		/* This will leave fifo configurations in a nonoptimal state */
642 		op->enabled = false;
643 		dispc_ovl_enable(ovl->id, false);
644 		return;
645 	}
646 
647 	op->info_dirty = false;
648 	if (mp->updating)
649 		op->shadow_info_dirty = true;
650 }
651 
652 static void dss_ovl_write_regs_extra(struct omap_overlay *ovl)
653 {
654 	struct ovl_priv_data *op = get_ovl_priv(ovl);
655 	struct mgr_priv_data *mp;
656 
657 	DSSDBG("writing ovl %d regs extra\n", ovl->id);
658 
659 	if (!op->extra_info_dirty)
660 		return;
661 
662 	/* note: write also when op->enabled == false, so that the ovl gets
663 	 * disabled */
664 
665 	dispc_ovl_enable(ovl->id, op->enabled);
666 	dispc_ovl_set_fifo_threshold(ovl->id, op->fifo_low, op->fifo_high);
667 
668 	mp = get_mgr_priv(ovl->manager);
669 
670 	op->extra_info_dirty = false;
671 	if (mp->updating)
672 		op->shadow_extra_info_dirty = true;
673 }
674 
675 static void dss_mgr_write_regs(struct omap_overlay_manager *mgr)
676 {
677 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
678 	struct omap_overlay *ovl;
679 
680 	DSSDBG("writing mgr %d regs\n", mgr->id);
681 
682 	if (!mp->enabled)
683 		return;
684 
685 	WARN_ON(mp->busy);
686 
687 	/* Commit overlay settings */
688 	list_for_each_entry(ovl, &mgr->overlays, list) {
689 		dss_ovl_write_regs(ovl);
690 		dss_ovl_write_regs_extra(ovl);
691 	}
692 
693 	if (mp->info_dirty) {
694 		dispc_mgr_setup(mgr->id, &mp->info);
695 
696 		mp->info_dirty = false;
697 		if (mp->updating)
698 			mp->shadow_info_dirty = true;
699 	}
700 }
701 
702 static void dss_mgr_write_regs_extra(struct omap_overlay_manager *mgr)
703 {
704 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
705 
706 	DSSDBG("writing mgr %d regs extra\n", mgr->id);
707 
708 	if (!mp->extra_info_dirty)
709 		return;
710 
711 	dispc_mgr_set_timings(mgr->id, &mp->timings);
712 
713 	/* lcd_config parameters */
714 	if (dss_mgr_is_lcd(mgr->id))
715 		dispc_mgr_set_lcd_config(mgr->id, &mp->lcd_config);
716 
717 	mp->extra_info_dirty = false;
718 	if (mp->updating)
719 		mp->shadow_extra_info_dirty = true;
720 }
721 
722 static void dss_write_regs(void)
723 {
724 	const int num_mgrs = omap_dss_get_num_overlay_managers();
725 	int i;
726 
727 	for (i = 0; i < num_mgrs; ++i) {
728 		struct omap_overlay_manager *mgr;
729 		struct mgr_priv_data *mp;
730 		int r;
731 
732 		mgr = omap_dss_get_overlay_manager(i);
733 		mp = get_mgr_priv(mgr);
734 
735 		if (!mp->enabled || mgr_manual_update(mgr) || mp->busy)
736 			continue;
737 
738 		r = dss_check_settings(mgr);
739 		if (r) {
740 			DSSERR("cannot write registers for manager %s: "
741 					"illegal configuration\n", mgr->name);
742 			continue;
743 		}
744 
745 		dss_mgr_write_regs(mgr);
746 		dss_mgr_write_regs_extra(mgr);
747 	}
748 }
749 
750 static void dss_set_go_bits(void)
751 {
752 	const int num_mgrs = omap_dss_get_num_overlay_managers();
753 	int i;
754 
755 	for (i = 0; i < num_mgrs; ++i) {
756 		struct omap_overlay_manager *mgr;
757 		struct mgr_priv_data *mp;
758 
759 		mgr = omap_dss_get_overlay_manager(i);
760 		mp = get_mgr_priv(mgr);
761 
762 		if (!mp->enabled || mgr_manual_update(mgr) || mp->busy)
763 			continue;
764 
765 		if (!need_go(mgr))
766 			continue;
767 
768 		mp->busy = true;
769 
770 		if (!dss_data.irq_enabled && need_isr())
771 			dss_register_vsync_isr();
772 
773 		dispc_mgr_go(mgr->id);
774 	}
775 
776 }
777 
778 static void mgr_clear_shadow_dirty(struct omap_overlay_manager *mgr)
779 {
780 	struct omap_overlay *ovl;
781 	struct mgr_priv_data *mp;
782 	struct ovl_priv_data *op;
783 
784 	mp = get_mgr_priv(mgr);
785 	mp->shadow_info_dirty = false;
786 	mp->shadow_extra_info_dirty = false;
787 
788 	list_for_each_entry(ovl, &mgr->overlays, list) {
789 		op = get_ovl_priv(ovl);
790 		op->shadow_info_dirty = false;
791 		op->shadow_extra_info_dirty = false;
792 	}
793 }
794 
795 static int dss_mgr_connect_compat(struct omap_overlay_manager *mgr,
796 		struct omap_dss_device *dst)
797 {
798 	return mgr->set_output(mgr, dst);
799 }
800 
801 static void dss_mgr_disconnect_compat(struct omap_overlay_manager *mgr,
802 		struct omap_dss_device *dst)
803 {
804 	mgr->unset_output(mgr);
805 }
806 
807 static void dss_mgr_start_update_compat(struct omap_overlay_manager *mgr)
808 {
809 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
810 	unsigned long flags;
811 	int r;
812 
813 	spin_lock_irqsave(&data_lock, flags);
814 
815 	WARN_ON(mp->updating);
816 
817 	r = dss_check_settings(mgr);
818 	if (r) {
819 		DSSERR("cannot start manual update: illegal configuration\n");
820 		spin_unlock_irqrestore(&data_lock, flags);
821 		return;
822 	}
823 
824 	dss_mgr_write_regs(mgr);
825 	dss_mgr_write_regs_extra(mgr);
826 
827 	mp->updating = true;
828 
829 	if (!dss_data.irq_enabled && need_isr())
830 		dss_register_vsync_isr();
831 
832 	dispc_mgr_enable_sync(mgr->id);
833 
834 	spin_unlock_irqrestore(&data_lock, flags);
835 }
836 
837 static void dss_apply_irq_handler(void *data, u32 mask);
838 
839 static void dss_register_vsync_isr(void)
840 {
841 	const int num_mgrs = dss_feat_get_num_mgrs();
842 	u32 mask;
843 	int r, i;
844 
845 	mask = 0;
846 	for (i = 0; i < num_mgrs; ++i)
847 		mask |= dispc_mgr_get_vsync_irq(i);
848 
849 	for (i = 0; i < num_mgrs; ++i)
850 		mask |= dispc_mgr_get_framedone_irq(i);
851 
852 	r = omap_dispc_register_isr(dss_apply_irq_handler, NULL, mask);
853 	WARN_ON(r);
854 
855 	dss_data.irq_enabled = true;
856 }
857 
858 static void dss_unregister_vsync_isr(void)
859 {
860 	const int num_mgrs = dss_feat_get_num_mgrs();
861 	u32 mask;
862 	int r, i;
863 
864 	mask = 0;
865 	for (i = 0; i < num_mgrs; ++i)
866 		mask |= dispc_mgr_get_vsync_irq(i);
867 
868 	for (i = 0; i < num_mgrs; ++i)
869 		mask |= dispc_mgr_get_framedone_irq(i);
870 
871 	r = omap_dispc_unregister_isr(dss_apply_irq_handler, NULL, mask);
872 	WARN_ON(r);
873 
874 	dss_data.irq_enabled = false;
875 }
876 
877 static void dss_apply_irq_handler(void *data, u32 mask)
878 {
879 	const int num_mgrs = dss_feat_get_num_mgrs();
880 	int i;
881 	bool extra_updating;
882 
883 	spin_lock(&data_lock);
884 
885 	/* clear busy, updating flags, shadow_dirty flags */
886 	for (i = 0; i < num_mgrs; i++) {
887 		struct omap_overlay_manager *mgr;
888 		struct mgr_priv_data *mp;
889 
890 		mgr = omap_dss_get_overlay_manager(i);
891 		mp = get_mgr_priv(mgr);
892 
893 		if (!mp->enabled)
894 			continue;
895 
896 		mp->updating = dispc_mgr_is_enabled(i);
897 
898 		if (!mgr_manual_update(mgr)) {
899 			bool was_busy = mp->busy;
900 			mp->busy = dispc_mgr_go_busy(i);
901 
902 			if (was_busy && !mp->busy)
903 				mgr_clear_shadow_dirty(mgr);
904 		}
905 	}
906 
907 	dss_write_regs();
908 	dss_set_go_bits();
909 
910 	extra_updating = extra_info_update_ongoing();
911 	if (!extra_updating)
912 		complete_all(&extra_updated_completion);
913 
914 	/* call framedone handlers for manual update displays */
915 	for (i = 0; i < num_mgrs; i++) {
916 		struct omap_overlay_manager *mgr;
917 		struct mgr_priv_data *mp;
918 
919 		mgr = omap_dss_get_overlay_manager(i);
920 		mp = get_mgr_priv(mgr);
921 
922 		if (!mgr_manual_update(mgr) || !mp->framedone_handler)
923 			continue;
924 
925 		if (mask & dispc_mgr_get_framedone_irq(i))
926 			mp->framedone_handler(mp->framedone_handler_data);
927 	}
928 
929 	if (!need_isr())
930 		dss_unregister_vsync_isr();
931 
932 	spin_unlock(&data_lock);
933 }
934 
935 static void omap_dss_mgr_apply_ovl(struct omap_overlay *ovl)
936 {
937 	struct ovl_priv_data *op;
938 
939 	op = get_ovl_priv(ovl);
940 
941 	if (!op->user_info_dirty)
942 		return;
943 
944 	op->user_info_dirty = false;
945 	op->info_dirty = true;
946 	op->info = op->user_info;
947 }
948 
949 static void omap_dss_mgr_apply_mgr(struct omap_overlay_manager *mgr)
950 {
951 	struct mgr_priv_data *mp;
952 
953 	mp = get_mgr_priv(mgr);
954 
955 	if (!mp->user_info_dirty)
956 		return;
957 
958 	mp->user_info_dirty = false;
959 	mp->info_dirty = true;
960 	mp->info = mp->user_info;
961 }
962 
963 static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
964 {
965 	unsigned long flags;
966 	struct omap_overlay *ovl;
967 	int r;
968 
969 	DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name);
970 
971 	spin_lock_irqsave(&data_lock, flags);
972 
973 	r = dss_check_settings_apply(mgr);
974 	if (r) {
975 		spin_unlock_irqrestore(&data_lock, flags);
976 		DSSERR("failed to apply settings: illegal configuration.\n");
977 		return r;
978 	}
979 
980 	/* Configure overlays */
981 	list_for_each_entry(ovl, &mgr->overlays, list)
982 		omap_dss_mgr_apply_ovl(ovl);
983 
984 	/* Configure manager */
985 	omap_dss_mgr_apply_mgr(mgr);
986 
987 	dss_write_regs();
988 	dss_set_go_bits();
989 
990 	spin_unlock_irqrestore(&data_lock, flags);
991 
992 	return 0;
993 }
994 
995 static void dss_apply_ovl_enable(struct omap_overlay *ovl, bool enable)
996 {
997 	struct ovl_priv_data *op;
998 
999 	op = get_ovl_priv(ovl);
1000 
1001 	if (op->enabled == enable)
1002 		return;
1003 
1004 	op->enabled = enable;
1005 	op->extra_info_dirty = true;
1006 }
1007 
1008 static void dss_apply_ovl_fifo_thresholds(struct omap_overlay *ovl,
1009 		u32 fifo_low, u32 fifo_high)
1010 {
1011 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1012 
1013 	if (op->fifo_low == fifo_low && op->fifo_high == fifo_high)
1014 		return;
1015 
1016 	op->fifo_low = fifo_low;
1017 	op->fifo_high = fifo_high;
1018 	op->extra_info_dirty = true;
1019 }
1020 
1021 static void dss_ovl_setup_fifo(struct omap_overlay *ovl)
1022 {
1023 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1024 	u32 fifo_low, fifo_high;
1025 	bool use_fifo_merge = false;
1026 
1027 	if (!op->enabled && !op->enabling)
1028 		return;
1029 
1030 	dispc_ovl_compute_fifo_thresholds(ovl->id, &fifo_low, &fifo_high,
1031 			use_fifo_merge, ovl_manual_update(ovl));
1032 
1033 	dss_apply_ovl_fifo_thresholds(ovl, fifo_low, fifo_high);
1034 }
1035 
1036 static void dss_mgr_setup_fifos(struct omap_overlay_manager *mgr)
1037 {
1038 	struct omap_overlay *ovl;
1039 	struct mgr_priv_data *mp;
1040 
1041 	mp = get_mgr_priv(mgr);
1042 
1043 	if (!mp->enabled)
1044 		return;
1045 
1046 	list_for_each_entry(ovl, &mgr->overlays, list)
1047 		dss_ovl_setup_fifo(ovl);
1048 }
1049 
1050 static void dss_setup_fifos(void)
1051 {
1052 	const int num_mgrs = omap_dss_get_num_overlay_managers();
1053 	struct omap_overlay_manager *mgr;
1054 	int i;
1055 
1056 	for (i = 0; i < num_mgrs; ++i) {
1057 		mgr = omap_dss_get_overlay_manager(i);
1058 		dss_mgr_setup_fifos(mgr);
1059 	}
1060 }
1061 
1062 static int dss_mgr_enable_compat(struct omap_overlay_manager *mgr)
1063 {
1064 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1065 	unsigned long flags;
1066 	int r;
1067 
1068 	mutex_lock(&apply_lock);
1069 
1070 	if (mp->enabled)
1071 		goto out;
1072 
1073 	spin_lock_irqsave(&data_lock, flags);
1074 
1075 	mp->enabled = true;
1076 
1077 	r = dss_check_settings(mgr);
1078 	if (r) {
1079 		DSSERR("failed to enable manager %d: check_settings failed\n",
1080 				mgr->id);
1081 		goto err;
1082 	}
1083 
1084 	dss_setup_fifos();
1085 
1086 	dss_write_regs();
1087 	dss_set_go_bits();
1088 
1089 	if (!mgr_manual_update(mgr))
1090 		mp->updating = true;
1091 
1092 	if (!dss_data.irq_enabled && need_isr())
1093 		dss_register_vsync_isr();
1094 
1095 	spin_unlock_irqrestore(&data_lock, flags);
1096 
1097 	if (!mgr_manual_update(mgr))
1098 		dispc_mgr_enable_sync(mgr->id);
1099 
1100 out:
1101 	mutex_unlock(&apply_lock);
1102 
1103 	return 0;
1104 
1105 err:
1106 	mp->enabled = false;
1107 	spin_unlock_irqrestore(&data_lock, flags);
1108 	mutex_unlock(&apply_lock);
1109 	return r;
1110 }
1111 
1112 static void dss_mgr_disable_compat(struct omap_overlay_manager *mgr)
1113 {
1114 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1115 	unsigned long flags;
1116 
1117 	mutex_lock(&apply_lock);
1118 
1119 	if (!mp->enabled)
1120 		goto out;
1121 
1122 	wait_pending_extra_info_updates();
1123 
1124 	if (!mgr_manual_update(mgr))
1125 		dispc_mgr_disable_sync(mgr->id);
1126 
1127 	spin_lock_irqsave(&data_lock, flags);
1128 
1129 	mp->updating = false;
1130 	mp->enabled = false;
1131 
1132 	spin_unlock_irqrestore(&data_lock, flags);
1133 
1134 out:
1135 	mutex_unlock(&apply_lock);
1136 }
1137 
1138 static int dss_mgr_set_info(struct omap_overlay_manager *mgr,
1139 		struct omap_overlay_manager_info *info)
1140 {
1141 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1142 	unsigned long flags;
1143 	int r;
1144 
1145 	r = dss_mgr_simple_check(mgr, info);
1146 	if (r)
1147 		return r;
1148 
1149 	spin_lock_irqsave(&data_lock, flags);
1150 
1151 	mp->user_info = *info;
1152 	mp->user_info_dirty = true;
1153 
1154 	spin_unlock_irqrestore(&data_lock, flags);
1155 
1156 	return 0;
1157 }
1158 
1159 static void dss_mgr_get_info(struct omap_overlay_manager *mgr,
1160 		struct omap_overlay_manager_info *info)
1161 {
1162 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1163 	unsigned long flags;
1164 
1165 	spin_lock_irqsave(&data_lock, flags);
1166 
1167 	*info = mp->user_info;
1168 
1169 	spin_unlock_irqrestore(&data_lock, flags);
1170 }
1171 
1172 static int dss_mgr_set_output(struct omap_overlay_manager *mgr,
1173 		struct omap_dss_device *output)
1174 {
1175 	int r;
1176 
1177 	mutex_lock(&apply_lock);
1178 
1179 	if (mgr->output) {
1180 		DSSERR("manager %s is already connected to an output\n",
1181 			mgr->name);
1182 		r = -EINVAL;
1183 		goto err;
1184 	}
1185 
1186 	if ((mgr->supported_outputs & output->id) == 0) {
1187 		DSSERR("output does not support manager %s\n",
1188 			mgr->name);
1189 		r = -EINVAL;
1190 		goto err;
1191 	}
1192 
1193 	output->manager = mgr;
1194 	mgr->output = output;
1195 
1196 	mutex_unlock(&apply_lock);
1197 
1198 	return 0;
1199 err:
1200 	mutex_unlock(&apply_lock);
1201 	return r;
1202 }
1203 
1204 static int dss_mgr_unset_output(struct omap_overlay_manager *mgr)
1205 {
1206 	int r;
1207 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1208 	unsigned long flags;
1209 
1210 	mutex_lock(&apply_lock);
1211 
1212 	if (!mgr->output) {
1213 		DSSERR("failed to unset output, output not set\n");
1214 		r = -EINVAL;
1215 		goto err;
1216 	}
1217 
1218 	spin_lock_irqsave(&data_lock, flags);
1219 
1220 	if (mp->enabled) {
1221 		DSSERR("output can't be unset when manager is enabled\n");
1222 		r = -EINVAL;
1223 		goto err1;
1224 	}
1225 
1226 	spin_unlock_irqrestore(&data_lock, flags);
1227 
1228 	mgr->output->manager = NULL;
1229 	mgr->output = NULL;
1230 
1231 	mutex_unlock(&apply_lock);
1232 
1233 	return 0;
1234 err1:
1235 	spin_unlock_irqrestore(&data_lock, flags);
1236 err:
1237 	mutex_unlock(&apply_lock);
1238 
1239 	return r;
1240 }
1241 
1242 static void dss_apply_mgr_timings(struct omap_overlay_manager *mgr,
1243 		const struct omap_video_timings *timings)
1244 {
1245 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1246 
1247 	mp->timings = *timings;
1248 	mp->extra_info_dirty = true;
1249 }
1250 
1251 static void dss_mgr_set_timings_compat(struct omap_overlay_manager *mgr,
1252 		const struct omap_video_timings *timings)
1253 {
1254 	unsigned long flags;
1255 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1256 
1257 	spin_lock_irqsave(&data_lock, flags);
1258 
1259 	if (mp->updating) {
1260 		DSSERR("cannot set timings for %s: manager needs to be disabled\n",
1261 			mgr->name);
1262 		goto out;
1263 	}
1264 
1265 	dss_apply_mgr_timings(mgr, timings);
1266 out:
1267 	spin_unlock_irqrestore(&data_lock, flags);
1268 }
1269 
1270 static void dss_apply_mgr_lcd_config(struct omap_overlay_manager *mgr,
1271 		const struct dss_lcd_mgr_config *config)
1272 {
1273 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1274 
1275 	mp->lcd_config = *config;
1276 	mp->extra_info_dirty = true;
1277 }
1278 
1279 static void dss_mgr_set_lcd_config_compat(struct omap_overlay_manager *mgr,
1280 		const struct dss_lcd_mgr_config *config)
1281 {
1282 	unsigned long flags;
1283 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1284 
1285 	spin_lock_irqsave(&data_lock, flags);
1286 
1287 	if (mp->enabled) {
1288 		DSSERR("cannot apply lcd config for %s: manager needs to be disabled\n",
1289 			mgr->name);
1290 		goto out;
1291 	}
1292 
1293 	dss_apply_mgr_lcd_config(mgr, config);
1294 out:
1295 	spin_unlock_irqrestore(&data_lock, flags);
1296 }
1297 
1298 static int dss_ovl_set_info(struct omap_overlay *ovl,
1299 		struct omap_overlay_info *info)
1300 {
1301 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1302 	unsigned long flags;
1303 	int r;
1304 
1305 	r = dss_ovl_simple_check(ovl, info);
1306 	if (r)
1307 		return r;
1308 
1309 	spin_lock_irqsave(&data_lock, flags);
1310 
1311 	op->user_info = *info;
1312 	op->user_info_dirty = true;
1313 
1314 	spin_unlock_irqrestore(&data_lock, flags);
1315 
1316 	return 0;
1317 }
1318 
1319 static void dss_ovl_get_info(struct omap_overlay *ovl,
1320 		struct omap_overlay_info *info)
1321 {
1322 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1323 	unsigned long flags;
1324 
1325 	spin_lock_irqsave(&data_lock, flags);
1326 
1327 	*info = op->user_info;
1328 
1329 	spin_unlock_irqrestore(&data_lock, flags);
1330 }
1331 
1332 static int dss_ovl_set_manager(struct omap_overlay *ovl,
1333 		struct omap_overlay_manager *mgr)
1334 {
1335 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1336 	unsigned long flags;
1337 	int r;
1338 
1339 	if (!mgr)
1340 		return -EINVAL;
1341 
1342 	mutex_lock(&apply_lock);
1343 
1344 	if (ovl->manager) {
1345 		DSSERR("overlay '%s' already has a manager '%s'\n",
1346 				ovl->name, ovl->manager->name);
1347 		r = -EINVAL;
1348 		goto err;
1349 	}
1350 
1351 	r = dispc_runtime_get();
1352 	if (r)
1353 		goto err;
1354 
1355 	spin_lock_irqsave(&data_lock, flags);
1356 
1357 	if (op->enabled) {
1358 		spin_unlock_irqrestore(&data_lock, flags);
1359 		DSSERR("overlay has to be disabled to change the manager\n");
1360 		r = -EINVAL;
1361 		goto err1;
1362 	}
1363 
1364 	dispc_ovl_set_channel_out(ovl->id, mgr->id);
1365 
1366 	ovl->manager = mgr;
1367 	list_add_tail(&ovl->list, &mgr->overlays);
1368 
1369 	spin_unlock_irqrestore(&data_lock, flags);
1370 
1371 	dispc_runtime_put();
1372 
1373 	mutex_unlock(&apply_lock);
1374 
1375 	return 0;
1376 
1377 err1:
1378 	dispc_runtime_put();
1379 err:
1380 	mutex_unlock(&apply_lock);
1381 	return r;
1382 }
1383 
1384 static int dss_ovl_unset_manager(struct omap_overlay *ovl)
1385 {
1386 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1387 	unsigned long flags;
1388 	int r;
1389 
1390 	mutex_lock(&apply_lock);
1391 
1392 	if (!ovl->manager) {
1393 		DSSERR("failed to detach overlay: manager not set\n");
1394 		r = -EINVAL;
1395 		goto err;
1396 	}
1397 
1398 	spin_lock_irqsave(&data_lock, flags);
1399 
1400 	if (op->enabled) {
1401 		spin_unlock_irqrestore(&data_lock, flags);
1402 		DSSERR("overlay has to be disabled to unset the manager\n");
1403 		r = -EINVAL;
1404 		goto err;
1405 	}
1406 
1407 	spin_unlock_irqrestore(&data_lock, flags);
1408 
1409 	/* wait for pending extra_info updates to ensure the ovl is disabled */
1410 	wait_pending_extra_info_updates();
1411 
1412 	/*
1413 	 * For a manual update display, there is no guarantee that the overlay
1414 	 * is really disabled in HW, we may need an extra update from this
1415 	 * manager before the configurations can go in. Return an error if the
1416 	 * overlay needed an update from the manager.
1417 	 *
1418 	 * TODO: Instead of returning an error, try to do a dummy manager update
1419 	 * here to disable the overlay in hardware. Use the *GATED fields in
1420 	 * the DISPC_CONFIG registers to do a dummy update.
1421 	 */
1422 	spin_lock_irqsave(&data_lock, flags);
1423 
1424 	if (ovl_manual_update(ovl) && op->extra_info_dirty) {
1425 		spin_unlock_irqrestore(&data_lock, flags);
1426 		DSSERR("need an update to change the manager\n");
1427 		r = -EINVAL;
1428 		goto err;
1429 	}
1430 
1431 	ovl->manager = NULL;
1432 	list_del(&ovl->list);
1433 
1434 	spin_unlock_irqrestore(&data_lock, flags);
1435 
1436 	mutex_unlock(&apply_lock);
1437 
1438 	return 0;
1439 err:
1440 	mutex_unlock(&apply_lock);
1441 	return r;
1442 }
1443 
1444 static bool dss_ovl_is_enabled(struct omap_overlay *ovl)
1445 {
1446 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1447 	unsigned long flags;
1448 	bool e;
1449 
1450 	spin_lock_irqsave(&data_lock, flags);
1451 
1452 	e = op->enabled;
1453 
1454 	spin_unlock_irqrestore(&data_lock, flags);
1455 
1456 	return e;
1457 }
1458 
1459 static int dss_ovl_enable(struct omap_overlay *ovl)
1460 {
1461 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1462 	unsigned long flags;
1463 	int r;
1464 
1465 	mutex_lock(&apply_lock);
1466 
1467 	if (op->enabled) {
1468 		r = 0;
1469 		goto err1;
1470 	}
1471 
1472 	if (ovl->manager == NULL || ovl->manager->output == NULL) {
1473 		r = -EINVAL;
1474 		goto err1;
1475 	}
1476 
1477 	spin_lock_irqsave(&data_lock, flags);
1478 
1479 	op->enabling = true;
1480 
1481 	r = dss_check_settings(ovl->manager);
1482 	if (r) {
1483 		DSSERR("failed to enable overlay %d: check_settings failed\n",
1484 				ovl->id);
1485 		goto err2;
1486 	}
1487 
1488 	dss_setup_fifos();
1489 
1490 	op->enabling = false;
1491 	dss_apply_ovl_enable(ovl, true);
1492 
1493 	dss_write_regs();
1494 	dss_set_go_bits();
1495 
1496 	spin_unlock_irqrestore(&data_lock, flags);
1497 
1498 	mutex_unlock(&apply_lock);
1499 
1500 	return 0;
1501 err2:
1502 	op->enabling = false;
1503 	spin_unlock_irqrestore(&data_lock, flags);
1504 err1:
1505 	mutex_unlock(&apply_lock);
1506 	return r;
1507 }
1508 
1509 static int dss_ovl_disable(struct omap_overlay *ovl)
1510 {
1511 	struct ovl_priv_data *op = get_ovl_priv(ovl);
1512 	unsigned long flags;
1513 	int r;
1514 
1515 	mutex_lock(&apply_lock);
1516 
1517 	if (!op->enabled) {
1518 		r = 0;
1519 		goto err;
1520 	}
1521 
1522 	if (ovl->manager == NULL || ovl->manager->output == NULL) {
1523 		r = -EINVAL;
1524 		goto err;
1525 	}
1526 
1527 	spin_lock_irqsave(&data_lock, flags);
1528 
1529 	dss_apply_ovl_enable(ovl, false);
1530 	dss_write_regs();
1531 	dss_set_go_bits();
1532 
1533 	spin_unlock_irqrestore(&data_lock, flags);
1534 
1535 	mutex_unlock(&apply_lock);
1536 
1537 	return 0;
1538 
1539 err:
1540 	mutex_unlock(&apply_lock);
1541 	return r;
1542 }
1543 
1544 static int dss_mgr_register_framedone_handler_compat(struct omap_overlay_manager *mgr,
1545 		void (*handler)(void *), void *data)
1546 {
1547 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1548 
1549 	if (mp->framedone_handler)
1550 		return -EBUSY;
1551 
1552 	mp->framedone_handler = handler;
1553 	mp->framedone_handler_data = data;
1554 
1555 	return 0;
1556 }
1557 
1558 static void dss_mgr_unregister_framedone_handler_compat(struct omap_overlay_manager *mgr,
1559 		void (*handler)(void *), void *data)
1560 {
1561 	struct mgr_priv_data *mp = get_mgr_priv(mgr);
1562 
1563 	WARN_ON(mp->framedone_handler != handler ||
1564 			mp->framedone_handler_data != data);
1565 
1566 	mp->framedone_handler = NULL;
1567 	mp->framedone_handler_data = NULL;
1568 }
1569 
1570 static const struct dss_mgr_ops apply_mgr_ops = {
1571 	.connect = dss_mgr_connect_compat,
1572 	.disconnect = dss_mgr_disconnect_compat,
1573 	.start_update = dss_mgr_start_update_compat,
1574 	.enable = dss_mgr_enable_compat,
1575 	.disable = dss_mgr_disable_compat,
1576 	.set_timings = dss_mgr_set_timings_compat,
1577 	.set_lcd_config = dss_mgr_set_lcd_config_compat,
1578 	.register_framedone_handler = dss_mgr_register_framedone_handler_compat,
1579 	.unregister_framedone_handler = dss_mgr_unregister_framedone_handler_compat,
1580 };
1581 
1582 static int compat_refcnt;
1583 static DEFINE_MUTEX(compat_init_lock);
1584 
1585 int omapdss_compat_init(void)
1586 {
1587 	struct platform_device *pdev = dss_get_core_pdev();
1588 	int i, r;
1589 
1590 	mutex_lock(&compat_init_lock);
1591 
1592 	if (compat_refcnt++ > 0)
1593 		goto out;
1594 
1595 	apply_init_priv();
1596 
1597 	dss_init_overlay_managers_sysfs(pdev);
1598 	dss_init_overlays(pdev);
1599 
1600 	for (i = 0; i < omap_dss_get_num_overlay_managers(); i++) {
1601 		struct omap_overlay_manager *mgr;
1602 
1603 		mgr = omap_dss_get_overlay_manager(i);
1604 
1605 		mgr->set_output = &dss_mgr_set_output;
1606 		mgr->unset_output = &dss_mgr_unset_output;
1607 		mgr->apply = &omap_dss_mgr_apply;
1608 		mgr->set_manager_info = &dss_mgr_set_info;
1609 		mgr->get_manager_info = &dss_mgr_get_info;
1610 		mgr->wait_for_go = &dss_mgr_wait_for_go;
1611 		mgr->wait_for_vsync = &dss_mgr_wait_for_vsync;
1612 		mgr->get_device = &dss_mgr_get_device;
1613 	}
1614 
1615 	for (i = 0; i < omap_dss_get_num_overlays(); i++) {
1616 		struct omap_overlay *ovl = omap_dss_get_overlay(i);
1617 
1618 		ovl->is_enabled = &dss_ovl_is_enabled;
1619 		ovl->enable = &dss_ovl_enable;
1620 		ovl->disable = &dss_ovl_disable;
1621 		ovl->set_manager = &dss_ovl_set_manager;
1622 		ovl->unset_manager = &dss_ovl_unset_manager;
1623 		ovl->set_overlay_info = &dss_ovl_set_info;
1624 		ovl->get_overlay_info = &dss_ovl_get_info;
1625 		ovl->wait_for_go = &dss_mgr_wait_for_go_ovl;
1626 		ovl->get_device = &dss_ovl_get_device;
1627 	}
1628 
1629 	r = dss_install_mgr_ops(&apply_mgr_ops);
1630 	if (r)
1631 		goto err_mgr_ops;
1632 
1633 	r = display_init_sysfs(pdev);
1634 	if (r)
1635 		goto err_disp_sysfs;
1636 
1637 	dispc_runtime_get();
1638 
1639 	r = dss_dispc_initialize_irq();
1640 	if (r)
1641 		goto err_init_irq;
1642 
1643 	dispc_runtime_put();
1644 
1645 out:
1646 	mutex_unlock(&compat_init_lock);
1647 
1648 	return 0;
1649 
1650 err_init_irq:
1651 	dispc_runtime_put();
1652 	display_uninit_sysfs(pdev);
1653 
1654 err_disp_sysfs:
1655 	dss_uninstall_mgr_ops();
1656 
1657 err_mgr_ops:
1658 	dss_uninit_overlay_managers_sysfs(pdev);
1659 	dss_uninit_overlays(pdev);
1660 
1661 	compat_refcnt--;
1662 
1663 	mutex_unlock(&compat_init_lock);
1664 
1665 	return r;
1666 }
1667 EXPORT_SYMBOL(omapdss_compat_init);
1668 
1669 void omapdss_compat_uninit(void)
1670 {
1671 	struct platform_device *pdev = dss_get_core_pdev();
1672 
1673 	mutex_lock(&compat_init_lock);
1674 
1675 	if (--compat_refcnt > 0)
1676 		goto out;
1677 
1678 	dss_dispc_uninitialize_irq();
1679 
1680 	display_uninit_sysfs(pdev);
1681 
1682 	dss_uninstall_mgr_ops();
1683 
1684 	dss_uninit_overlay_managers_sysfs(pdev);
1685 	dss_uninit_overlays(pdev);
1686 out:
1687 	mutex_unlock(&compat_init_lock);
1688 }
1689 EXPORT_SYMBOL(omapdss_compat_uninit);
1690