Attachment #95893 for bug #127642




theatre_drv_la_SOURCES = \
	theatre.c theatre_module.c

theater_out_drv_la_LTLIBRARIES = theater_out_drv.la
theater_out_drv_la_LDFLAGS = -module -avoid-version
theater_out_drv_ladir = @moduledir@/multimedia
theater_out_drv_la_CFLAGS = \
        $(AM_CFLAGS) -DMICROC_DIR=\"$(theater_out_drv_ladir)\"
theater_out_drv_la_SOURCES = \
        theater_out.c theater_out_module.c


theatre200_drv_la_LTLIBRARIES = theatre200_drv.la
theatre200_drv_la_LDFLAGS = -module -avoid-version
theatre200_drv_ladir = @moduledir@/multimedia

	radeon_sarea.h \
	radeon_version.h \
	radeon_video.h \
	theater_out.h \
	theatre200.h \
	theatre_detect.h \
	theatre.h \

Lines 265-270 Link Here

(-)xf86-video-ati-6.5.8.0/src/Makefile.in (-5 / +129 lines)
265	theatre.c theatre_module.c	265	theatre.c theatre_module.c
266		266
267		267
		268	theater_out_drv_la_LTLIBRARIES = theater_out_drv.la
		269	theater_out_drv_la_LDFLAGS = -module -avoid-version
		270	theater_out_drv_ladir = @moduledir@/multimedia
		271	theater_out_drv_la_CFLAGS = \
		272	$(AM_CFLAGS) -DMICROC_DIR=\"$(theater_out_drv_ladir)\"
		273
		274	theater_out_drv_la_SOURCES = \
		275	theater_out.c theater_out_module.c
		276
		277
268	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la	278	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la
269	theatre200_drv_la_LDFLAGS = -module -avoid-version	279	theatre200_drv_la_LDFLAGS = -module -avoid-version
270	theatre200_drv_ladir = @moduledir@/multimedia	280	theatre200_drv_ladir = @moduledir@/multimedia
Lines 361-366 Link Here
361	radeon_sarea.h \	371	radeon_sarea.h \
362	radeon_version.h \	372	radeon_version.h \
363	radeon_video.h \	373	radeon_video.h \
		374	theater_out.h \
364	theatre200.h \	375	theatre200.h \
365	theatre_detect.h \	376	theatre_detect.h \
366	theatre.h \	377	theatre.h \
Lines 373-378 Link Here
373	CONFIG_CLEAN_FILES =	384	CONFIG_CLEAN_FILES =
374	LTLIBRARIES = $(ati_drv_la_LTLIBRARIES) $(atimisc_drv_la_LTLIBRARIES) \	385	LTLIBRARIES = $(ati_drv_la_LTLIBRARIES) $(atimisc_drv_la_LTLIBRARIES) \
375	$(r128_drv_la_LTLIBRARIES) $(radeon_drv_la_LTLIBRARIES) \	386	$(r128_drv_la_LTLIBRARIES) $(radeon_drv_la_LTLIBRARIES) \
		387	$(theater_out_drv_la_LTLIBRARIES) \
376	$(theatre200_drv_la_LTLIBRARIES) \	388	$(theatre200_drv_la_LTLIBRARIES) \
377	$(theatre_detect_drv_la_LTLIBRARIES) \	389	$(theatre_detect_drv_la_LTLIBRARIES) \
378	$(theatre_drv_la_LTLIBRARIES)	390	$(theatre_drv_la_LTLIBRARIES)
Lines 426-431 Link Here
426	radeon_bios.lo radeon_mm_i2c.lo radeon_vip.lo radeon_misc.lo \	438	radeon_bios.lo radeon_mm_i2c.lo radeon_vip.lo radeon_misc.lo \
427	radeon_exa.lo $(am__objects_6)	439	radeon_exa.lo $(am__objects_6)
428	radeon_drv_la_OBJECTS = $(am_radeon_drv_la_OBJECTS)	440	radeon_drv_la_OBJECTS = $(am_radeon_drv_la_OBJECTS)
		441	theater_out_drv_la_LIBADD =
		442	am_theater_out_drv_la_OBJECTS = theater_out_drv_la-theater_out.lo \
		443	theater_out_drv_la-theater_out_module.lo
		444	theater_out_drv_la_OBJECTS = $(am_theater_out_drv_la_OBJECTS)
429	theatre200_drv_la_LIBADD =	445	theatre200_drv_la_LIBADD =
430	am_theatre200_drv_la_OBJECTS = theatre200_drv_la-theatre200.lo \	446	am_theatre200_drv_la_OBJECTS = theatre200_drv_la-theatre200.lo \
431	theatre200_drv_la-theatre200_module.lo	447	theatre200_drv_la-theatre200_module.lo
Lines 487-493 Link Here
487	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_mm_i2c.Plo \	503	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_mm_i2c.Plo \
488	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_probe.Plo \	504	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_probe.Plo \
489	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_video.Plo \	505	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_video.Plo \
490	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_vip.Plo ./$(DEPDIR)/theatre.Plo \	506	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_vip.Plo \
		507	@AMDEP_TRUE@ ./$(DEPDIR)/theater_out_drv_la-theater_out.Plo \
		508	@AMDEP_TRUE@ ./$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo \
		509	@AMDEP_TRUE@ ./$(DEPDIR)/theatre.Plo \
491	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200.Plo \	510	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200.Plo \
492	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo \	511	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo \
493	@AMDEP_TRUE@ ./$(DEPDIR)/theatre_detect.Plo \	512	@AMDEP_TRUE@ ./$(DEPDIR)/theatre_detect.Plo \
Lines 503-512 Link Here
503	DIST_SOURCES = $(am__ati_drv_la_SOURCES_DIST) \	522	DIST_SOURCES = $(am__ati_drv_la_SOURCES_DIST) \
504	$(am__atimisc_drv_la_SOURCES_DIST) \	523	$(am__atimisc_drv_la_SOURCES_DIST) \
505	$(am__r128_drv_la_SOURCES_DIST) \	524	$(am__r128_drv_la_SOURCES_DIST) \
506	$(am__radeon_drv_la_SOURCES_DIST) $(theatre200_drv_la_SOURCES) \	525	$(am__radeon_drv_la_SOURCES_DIST) $(theater_out_drv_la_SOURCES) \
507	$(theatre_detect_drv_la_SOURCES) $(theatre_drv_la_SOURCES)	526	$(theatre200_drv_la_SOURCES) $(theatre_detect_drv_la_SOURCES) \
		527	$(theatre_drv_la_SOURCES)
508	DIST_COMMON = $(srcdir)/Makefile.in Makefile.am	528	DIST_COMMON = $(srcdir)/Makefile.in Makefile.am
509	SOURCES = $(ati_drv_la_SOURCES) $(atimisc_drv_la_SOURCES) $(r128_drv_la_SOURCES) $(radeon_drv_la_SOURCES) $(theatre200_drv_la_SOURCES) $(theatre_detect_drv_la_SOURCES) $(theatre_drv_la_SOURCES)	529	SOURCES = $(ati_drv_la_SOURCES) $(atimisc_drv_la_SOURCES) $(r128_drv_la_SOURCES) $(radeon_drv_la_SOURCES) $(theater_out_drv_la_SOURCES) $(theatre200_drv_la_SOURCES) $(theatre_detect_drv_la_SOURCES) $(theatre_drv_la_SOURCES)
510		530
511	all: all-am	531	all: all-am
512		532
Lines 629-634 Link Here
629	echo "rm -f \"$${dir}/so_locations\""; \	649	echo "rm -f \"$${dir}/so_locations\""; \
630	rm -f "$${dir}/so_locations"; \	650	rm -f "$${dir}/so_locations"; \
631	done	651	done
		652	theater_out_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
		653	install-theater_out_drv_laLTLIBRARIES: $(theater_out_drv_la_LTLIBRARIES)
		654	@$(NORMAL_INSTALL)
		655	$(mkinstalldirs) $(DESTDIR)$(theater_out_drv_ladir)
		656	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		657	if test -f $$p; then \
		658	f="`echo $$p \| sed -e 's\|^.*/\|\|'`"; \
		659	echo " $(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) $$p $(DESTDIR)$(theater_out_drv_ladir)/$$f"; \
		660	$(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) $$p $(DESTDIR)$(theater_out_drv_ladir)/$$f; \
		661	else :; fi; \
		662	done
		663
		664	uninstall-theater_out_drv_laLTLIBRARIES:
		665	@$(NORMAL_UNINSTALL)
		666	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		667	p="`echo $$p \| sed -e 's\|^.*/\|\|'`"; \
		668	echo " $(LIBTOOL) --mode=uninstall rm -f $(DESTDIR)$(theater_out_drv_ladir)/$$p"; \
		669	$(LIBTOOL) --mode=uninstall rm -f $(DESTDIR)$(theater_out_drv_ladir)/$$p; \
		670	done
		671
		672	clean-theater_out_drv_laLTLIBRARIES:
		673	-test -z "$(theater_out_drv_la_LTLIBRARIES)" \|\| rm -f $(theater_out_drv_la_LTLIBRARIES)
		674	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		675	dir="`echo $$p \| sed -e 's\|/[^/]*$$\|\|'`"; \
		676	test "$$dir" = "$$p" && dir=.; \
		677	echo "rm -f \"$${dir}/so_locations\""; \
		678	rm -f "$${dir}/so_locations"; \
		679	done
632	theatre200_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	680	theatre200_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
633	install-theatre200_drv_laLTLIBRARIES: $(theatre200_drv_la_LTLIBRARIES)	681	install-theatre200_drv_laLTLIBRARIES: $(theatre200_drv_la_LTLIBRARIES)
634	@$(NORMAL_INSTALL)	682	@$(NORMAL_INSTALL)
Lines 721-726 Link Here
721	$(LINK) -rpath $(r128_drv_ladir) $(r128_drv_la_LDFLAGS) $(r128_drv_la_OBJECTS) $(r128_drv_la_LIBADD) $(LIBS)	769	$(LINK) -rpath $(r128_drv_ladir) $(r128_drv_la_LDFLAGS) $(r128_drv_la_OBJECTS) $(r128_drv_la_LIBADD) $(LIBS)
722	radeon_drv.la: $(radeon_drv_la_OBJECTS) $(radeon_drv_la_DEPENDENCIES)	770	radeon_drv.la: $(radeon_drv_la_OBJECTS) $(radeon_drv_la_DEPENDENCIES)
723	$(LINK) -rpath $(radeon_drv_ladir) $(radeon_drv_la_LDFLAGS) $(radeon_drv_la_OBJECTS) $(radeon_drv_la_LIBADD) $(LIBS)	771	$(LINK) -rpath $(radeon_drv_ladir) $(radeon_drv_la_LDFLAGS) $(radeon_drv_la_OBJECTS) $(radeon_drv_la_LIBADD) $(LIBS)
		772	theater_out_drv.la: $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_DEPENDENCIES)
		773	$(LINK) -rpath $(theater_out_drv_ladir) $(theater_out_drv_la_LDFLAGS) $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_LIBADD) $(LIBS)
724	theatre200_drv.la: $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_DEPENDENCIES)	774	theatre200_drv.la: $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_DEPENDENCIES)
725	$(LINK) -rpath $(theatre200_drv_ladir) $(theatre200_drv_la_LDFLAGS) $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_LIBADD) $(LIBS)	775	$(LINK) -rpath $(theatre200_drv_ladir) $(theatre200_drv_la_LDFLAGS) $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_LIBADD) $(LIBS)
726	theatre_detect_drv.la: $(theatre_detect_drv_la_OBJECTS) $(theatre_detect_drv_la_DEPENDENCIES)	776	theatre_detect_drv.la: $(theatre_detect_drv_la_OBJECTS) $(theatre_detect_drv_la_DEPENDENCIES)
Lines 801-806 Link Here
801	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_probe.Plo@am__quote@	851	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_probe.Plo@am__quote@
802	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_video.Plo@am__quote@	852	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_video.Plo@am__quote@
803	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_vip.Plo@am__quote@	853	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_vip.Plo@am__quote@
		854	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out.Plo@am__quote@
		855	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo@am__quote@
804	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre.Plo@am__quote@	856	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre.Plo@am__quote@
805	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200.Plo@am__quote@	857	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200.Plo@am__quote@
806	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo@am__quote@	858	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo@am__quote@
Lines 841-846 Link Here
841	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@	893	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
842	@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ `test -f '$<' \|\| echo '$(srcdir)/'`$<	894	@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ `test -f '$<' \|\| echo '$(srcdir)/'`$<
843		895
		896	theater_out_drv_la-theater_out.o: theater_out.c
		897	@am__fastdepCC_TRUE@ if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -MT theater_out_drv_la-theater_out.o -MD -MP -MF "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" \
		898	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out.o `test -f 'theater_out.c' \|\| echo '$(srcdir)/'`theater_out.c; \
		899	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Po"; \
		900	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; \
		901	@am__fastdepCC_TRUE@ fi
		902	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out.c' object='theater_out_drv_la-theater_out.o' libtool=no @AMDEPBACKSLASH@
		903	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out.Po' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out.TPo' @AMDEPBACKSLASH@
		904	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		905	@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -c -o theater_out_drv_la-theater_out.o `test -f 'theater_out.c' \|\| echo '$(srcdir)/'`theater_out.c
		906
		907	theater_out_drv_la-theater_out.obj: theater_out.c
		908	@am__fastdepCC_TRUE@ if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -MT theater_out_drv_la-theater_out.obj -MD -MP -MF "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" \
		909	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out.obj `if test -f 'theater_out.c'; then $(CYGPATH_W) 'theater_out.c'; else $(CYGPATH_W) '$(srcdir)/theater_out.c'; fi`; \
		910	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Po"; \
		911	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; \
		912	@am__fastdepCC_TRUE@ fi
		913	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out.c' object='theater_out_drv_la-theater_out.obj' libtool=no @AMDEPBACKSLASH@
		914	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out.Po' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out.TPo' @AMDEPBACKSLASH@
		915	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		916	@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -c -o theater_out_drv_la-theater_out.obj `if test -f 'theater_out.c'; then $(CYGPATH_W) 'theater_out.c'; else $(CYGPATH_W) '$(srcdir)/theater_out.c'; fi`
		917
		918	theater_out_drv_la-theater_out.lo: theater_out.c
		919	@am__fastdepCC_TRUE@ if $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -MT theater_out_drv_la-theater_out.lo -MD -MP -MF "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" \
		920	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out.lo `test -f 'theater_out.c' \|\| echo '$(srcdir)/'`theater_out.c; \
		921	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Plo"; \
		922	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; \
		923	@am__fastdepCC_TRUE@ fi
		924	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out.c' object='theater_out_drv_la-theater_out.lo' libtool=yes @AMDEPBACKSLASH@
		925	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out.Plo' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out.TPlo' @AMDEPBACKSLASH@
		926	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		927	@am__fastdepCC_FALSE@ $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -c -o theater_out_drv_la-theater_out.lo `test -f 'theater_out.c' \|\| echo '$(srcdir)/'`theater_out.c
		928
		929	theater_out_drv_la-theater_out_module.o: theater_out_module.c
		930	@am__fastdepCC_TRUE@ if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -MT theater_out_drv_la-theater_out_module.o -MD -MP -MF "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" \
		931	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out_module.o `test -f 'theater_out_module.c' \|\| echo '$(srcdir)/'`theater_out_module.c; \
		932	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Po"; \
		933	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; \
		934	@am__fastdepCC_TRUE@ fi
		935	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.o' libtool=no @AMDEPBACKSLASH@
		936	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out_module.Po' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out_module.TPo' @AMDEPBACKSLASH@
		937	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		938	@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -c -o theater_out_drv_la-theater_out_module.o `test -f 'theater_out_module.c' \|\| echo '$(srcdir)/'`theater_out_module.c
		939
		940	theater_out_drv_la-theater_out_module.obj: theater_out_module.c
		941	@am__fastdepCC_TRUE@ if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -MT theater_out_drv_la-theater_out_module.obj -MD -MP -MF "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" \
		942	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out_module.obj `if test -f 'theater_out_module.c'; then $(CYGPATH_W) 'theater_out_module.c'; else $(CYGPATH_W) '$(srcdir)/theater_out_module.c'; fi`; \
		943	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Po"; \
		944	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; \
		945	@am__fastdepCC_TRUE@ fi
		946	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.obj' libtool=no @AMDEPBACKSLASH@
		947	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out_module.Po' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out_module.TPo' @AMDEPBACKSLASH@
		948	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		949	@am__fastdepCC_FALSE@ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -c -o theater_out_drv_la-theater_out_module.obj `if test -f 'theater_out_module.c'; then $(CYGPATH_W) 'theater_out_module.c'; else $(CYGPATH_W) '$(srcdir)/theater_out_module.c'; fi`
		950
		951	theater_out_drv_la-theater_out_module.lo: theater_out_module.c
		952	@am__fastdepCC_TRUE@ if $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -MT theater_out_drv_la-theater_out_module.lo -MD -MP -MF "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" \
		953	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out_module.lo `test -f 'theater_out_module.c' \|\| echo '$(srcdir)/'`theater_out_module.c; \
		954	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo"; \
		955	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; \
		956	@am__fastdepCC_TRUE@ fi
		957	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.lo' libtool=yes @AMDEPBACKSLASH@
		958	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out_module.TPlo' @AMDEPBACKSLASH@
		959	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
960	@am__fastdepCC_FALSE@ $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theater_out_drv_la_CFLAGS) $(CFLAGS) -c -o theater_out_drv_la-theater_out_module.lo `test -f 'theater_out_module.c' \|\| echo '$(srcdir)/'`theater_out_module.c
961
844	theatre200_drv_la-theatre200.o: theatre200.c	962	theatre200_drv_la-theatre200.o: theatre200.c
845	@am__fastdepCC_TRUE@ if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theatre200_drv_la_CFLAGS) $(CFLAGS) -MT theatre200_drv_la-theatre200.o -MD -MP -MF "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" \	963	@am__fastdepCC_TRUE@ if $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theatre200_drv_la_CFLAGS) $(CFLAGS) -MT theatre200_drv_la-theatre200.o -MD -MP -MF "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" \
846	@am__fastdepCC_TRUE@ -c -o theatre200_drv_la-theatre200.o `test -f 'theatre200.c' \|\| echo '$(srcdir)/'`theatre200.c; \	964	@am__fastdepCC_TRUE@ -c -o theatre200_drv_la-theatre200.o `test -f 'theatre200.c' \|\| echo '$(srcdir)/'`theatre200.c; \
Lines 1007-1013 Link Here
1007	all-am: Makefile $(LTLIBRARIES)	1125	all-am: Makefile $(LTLIBRARIES)
1008		1126
1009	installdirs:	1127	installdirs:
1010	$(mkinstalldirs) $(DESTDIR)$(ati_drv_ladir) $(DESTDIR)$(atimisc_drv_ladir) $(DESTDIR)$(r128_drv_ladir) $(DESTDIR)$(radeon_drv_ladir) $(DESTDIR)$(theatre200_drv_ladir) $(DESTDIR)$(theatre_detect_drv_ladir) $(DESTDIR)$(theatre_drv_ladir)	1128	$(mkinstalldirs) $(DESTDIR)$(ati_drv_ladir) $(DESTDIR)$(atimisc_drv_ladir) $(DESTDIR)$(r128_drv_ladir) $(DESTDIR)$(radeon_drv_ladir) $(DESTDIR)$(theater_out_drv_ladir) $(DESTDIR)$(theatre200_drv_ladir) $(DESTDIR)$(theatre_detect_drv_ladir) $(DESTDIR)$(theatre_drv_ladir)
1011	install: install-am	1129	install: install-am
1012	install-exec: install-exec-am	1130	install-exec: install-exec-am
1013	install-data: install-data-am	1131	install-data: install-data-am
Lines 1037-1042 Link Here
1037	clean-am: clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \	1155	clean-am: clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
1038	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \	1156	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
1039	clean-radeon_drv_laLTLIBRARIES \	1157	clean-radeon_drv_laLTLIBRARIES \
		1158	clean-theater_out_drv_laLTLIBRARIES \
1040	clean-theatre200_drv_laLTLIBRARIES \	1159	clean-theatre200_drv_laLTLIBRARIES \
1041	clean-theatre_detect_drv_laLTLIBRARIES \	1160	clean-theatre_detect_drv_laLTLIBRARIES \
1042	clean-theatre_drv_laLTLIBRARIES mostlyclean-am	1161	clean-theatre_drv_laLTLIBRARIES mostlyclean-am
Lines 1058-1063 Link Here
1058	install-data-am: install-ati_drv_laLTLIBRARIES \	1177	install-data-am: install-ati_drv_laLTLIBRARIES \
1059	install-atimisc_drv_laLTLIBRARIES \	1178	install-atimisc_drv_laLTLIBRARIES \
1060	install-r128_drv_laLTLIBRARIES install-radeon_drv_laLTLIBRARIES \	1179	install-r128_drv_laLTLIBRARIES install-radeon_drv_laLTLIBRARIES \
		1180	install-theater_out_drv_laLTLIBRARIES \
1061	install-theatre200_drv_laLTLIBRARIES \	1181	install-theatre200_drv_laLTLIBRARIES \
1062	install-theatre_detect_drv_laLTLIBRARIES \	1182	install-theatre_detect_drv_laLTLIBRARIES \
1063	install-theatre_drv_laLTLIBRARIES	1183	install-theatre_drv_laLTLIBRARIES
Lines 1092-1097 Link Here
1092	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \	1212	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
1093	uninstall-r128_drv_laLTLIBRARIES \	1213	uninstall-r128_drv_laLTLIBRARIES \
1094	uninstall-radeon_drv_laLTLIBRARIES \	1214	uninstall-radeon_drv_laLTLIBRARIES \
		1215	uninstall-theater_out_drv_laLTLIBRARIES \
1095	uninstall-theatre200_drv_laLTLIBRARIES \	1216	uninstall-theatre200_drv_laLTLIBRARIES \
1096	uninstall-theatre_detect_drv_laLTLIBRARIES \	1217	uninstall-theatre_detect_drv_laLTLIBRARIES \
1097	uninstall-theatre_drv_laLTLIBRARIES	1218	uninstall-theatre_drv_laLTLIBRARIES
Lines 1100-1105 Link Here
1100	clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \	1221	clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
1101	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \	1222	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
1102	clean-radeon_drv_laLTLIBRARIES \	1223	clean-radeon_drv_laLTLIBRARIES \
		1224	clean-theater_out_drv_laLTLIBRARIES \
1103	clean-theatre200_drv_laLTLIBRARIES \	1225	clean-theatre200_drv_laLTLIBRARIES \
1104	clean-theatre_detect_drv_laLTLIBRARIES \	1226	clean-theatre_detect_drv_laLTLIBRARIES \
1105	clean-theatre_drv_laLTLIBRARIES ctags distclean \	1227	clean-theatre_drv_laLTLIBRARIES ctags distclean \
Lines 1110-1115 Link Here
1110	install-exec install-exec-am install-info install-info-am \	1232	install-exec install-exec-am install-info install-info-am \
1111	install-man install-r128_drv_laLTLIBRARIES \	1233	install-man install-r128_drv_laLTLIBRARIES \
1112	install-radeon_drv_laLTLIBRARIES install-strip \	1234	install-radeon_drv_laLTLIBRARIES install-strip \
		1235	install-theater_out_drv_laLTLIBRARIES \
1113	install-theatre200_drv_laLTLIBRARIES \	1236	install-theatre200_drv_laLTLIBRARIES \
1114	install-theatre_detect_drv_laLTLIBRARIES \	1237	install-theatre_detect_drv_laLTLIBRARIES \
1115	install-theatre_drv_laLTLIBRARIES installcheck installcheck-am \	1238	install-theatre_drv_laLTLIBRARIES installcheck installcheck-am \
Lines 1120-1125 Link Here
1120	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \	1243	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
1121	uninstall-r128_drv_laLTLIBRARIES \	1244	uninstall-r128_drv_laLTLIBRARIES \
1122	uninstall-radeon_drv_laLTLIBRARIES \	1245	uninstall-radeon_drv_laLTLIBRARIES \
		1246	uninstall-theater_out_drv_laLTLIBRARIES \
1123	uninstall-theatre200_drv_laLTLIBRARIES \	1247	uninstall-theatre200_drv_laLTLIBRARIES \
1124	uninstall-theatre_detect_drv_laLTLIBRARIES \	1248	uninstall-theatre_detect_drv_laLTLIBRARIES \
1125	uninstall-theatre_drv_laLTLIBRARIES	1249	uninstall-theatre_drv_laLTLIBRARIES




#include "radeon_macros.h"
#include "radeon_probe.h"
#include "radeon_version.h"
#include "theater_out.h"
#include "radeon_mergedfb.h"

#ifdef XF86DRI

    OPTION_RAGE_THEATRE_COMPOSITE_PORT,
    OPTION_RAGE_THEATRE_SVIDEO_PORT,
    OPTION_TUNER_TYPE,
    OPTION_TV_OUTPUT, 
    OPTION_RAGE_THEATRE_MICROC_PATH,
    OPTION_RAGE_THEATRE_MICROC_TYPE,
#endif

    { OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE },
    { OPTION_RAGE_THEATRE_SVIDEO_PORT,    "RageTheatreSVideoPort",    OPTV_INTEGER, {0}, FALSE },
    { OPTION_TUNER_TYPE,                  "TunerType",                OPTV_INTEGER, {0}, FALSE },
    { OPTION_TV_OUTPUT,                   "TVOutput",                 OPTV_ANYSTR,  {0}, FALSE },
	{ OPTION_RAGE_THEATRE_MICROC_PATH,	"RageTheatreMicrocPath",	 OPTV_STRING, {0}, FALSE },
	{ OPTION_RAGE_THEATRE_MICROC_TYPE, 	"RageTheatreMicrocType",	 OPTV_STRING, {0}, FALSE },
#endif


    info->PaletteSavedOnVT = FALSE;

    RADEONTRACE(("Allocating VIP interface"));
    info->VIP = RADEONAllocateVIP(pScrn);

    if ((s = xf86GetOptValString(info->Options , OPTION_TV_OUTPUT)) != NULL && xf86NameCmp(s , "NOLOAD") != 0)
    {
	RADEONTRACE(("TVOutput opt = %s\n" , s));
	if(!xf86LoadSubModule(pScrn , "theater_out"))
	{
		RADEONTRACE(("Failed to find theater_out module\n"));
	        xf86DrvMsg(pScrn->scrnIndex , X_ERROR , "Unable to load TV output module\n");
        	info->theaterOut = NULL;
	}
	else
	{
	    RADEONTRACE(("Found theater_out module\n"));
	    xf86LoaderReqSymbols(THEATER_OUT_SYMBOLS , NULL);

	    info->theaterOut = xf86_detectTheaterOut(pScrn , FALSE,info->VIP);
	    if (info->theaterOut != NULL)
	    	xf86_initTheaterOut(info->theaterOut , s);
	}

    }


    RADEONSave(pScrn);

    if ((!info->IsSecondary) && info->IsMobility) {


    /* Init Xv */
    RADEONTRACE(("Initializing Xv\n"));
//    RADEONInitVideo(pScreen);
    RADEONInitVideo(pScreen , info->VIP , TRUE);

    if(info->MergedFB)
	/* need this here to fix up sarea values */

    OUTREG(RADEON_OVR_WID_TOP_BOTTOM, restore->ovr_wid_top_bottom);
    OUTREG(RADEON_OV0_SCALE_CNTL,     restore->ov0_scale_cntl);
    OUTREG(RADEON_SUBPIC_CNTL,        restore->subpic_cntl);
//    OUTREG(RADEON_VIPH_CONTROL,       restore->viph_control);
  /*
   * fulivi: removed. It messes the VIP access up
   */

    OUTREG(RADEON_I2C_CNTL_1,         restore->i2c_cntl_1);
    OUTREG(RADEON_GEN_INT_CNTL,       restore->gen_int_cntl);
    OUTREG(RADEON_CAP0_TRIG_CNTL,     restore->cap0_trig_cntl);

    OUTREG(RADEON_CRTC_OFFSET,          restore->crtc_offset);
    OUTREG(RADEON_CRTC_OFFSET_CNTL,     restore->crtc_offset_cntl);
    OUTREG(RADEON_CRTC_PITCH,           restore->crtc_pitch);
    OUTREG(RADEON_DISP_OUTPUT_CNTL,     restore->disp_output_cntl);
    OUTREG(RADEON_DISP_MERGE_CNTL,      restore->disp_merge_cntl);
    OUTREG(RADEON_CRTC_MORE_CNTL,       restore->crtc_more_cntl);


	    ~(RADEON_P2PLL_ATOMIC_UPDATE_W));
}

static CARD8 RADEONComputePLLGain(CARD16 reference_freq,
	                          CARD16 ref_div,
        		          CARD16 fb_div)
{
  unsigned vcoFreq;

  vcoFreq = ((unsigned)reference_freq * fb_div) / ref_div;

  /*
   * This is orribly crude: the VCO frequency range is divided into
   * 3 parts, each part having a fixed PLL gain value.
   */
  if (vcoFreq >= 30000)
    /*
     * [300..max] MHz : 7
     */
    return 7;
  else if (vcoFreq >= 18000)
    /*
     * [180..300) MHz : 4
     */
    return 4;
  else
    /*
     * [0..180) MHz : 1
     */
    return 1;
}


/* Write PLL registers */
static void RADEONRestorePLLRegisters(ScrnInfoPtr pScrn,
				      RADEONSavePtr restore)
{
    RADEONInfoPtr  info       = RADEONPTR(pScrn);
    unsigned char *RADEONMMIO = info->MMIO;
    CARD8 pllGain;

    if (info->IsMobility) {
        /* A temporal workaround for the occational blanking on certain laptop panels.

    OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,
	    RADEON_VCLK_SRC_SEL_CPUCLK,
	    ~(RADEON_VCLK_SRC_SEL_MASK));
    pllGain = RADEONComputePLLGain(info->pll.reference_freq,
                                  restore->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
                                  restore->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK);



    OUTPLLP(pScrn,
	    RADEON_PPLL_CNTL,
	    RADEON_PPLL_RESET
	    | RADEON_PPLL_ATOMIC_UPDATE_EN
	    | RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
	    | ((CARD32)pllGain << RADEON_PPLL_PVG_SHIFT),
	    ~(RADEON_PPLL_RESET
	      | RADEON_PPLL_ATOMIC_UPDATE_EN
	      | RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
	      | RADEON_PPLL_PVG_MASK));


    OUTREGP(RADEON_CLOCK_CNTL_INDEX,
	    RADEON_PLL_DIV_SEL,


    usleep(50000); /* Let the clock to lock */

    OUTPLL(pScrn, RADEON_VCLK_ECP_CNTL , restore->vclk_ecp_cntl);

    RADEONTRACE(("VCLK_ECP_CNTL = %08X\n" , restore->vclk_ecp_cntl));

}



    save->crtc_offset          = INREG(RADEON_CRTC_OFFSET);
    save->crtc_offset_cntl     = INREG(RADEON_CRTC_OFFSET_CNTL);
    save->crtc_pitch           = INREG(RADEON_CRTC_PITCH);
    save->disp_output_cntl     = INREG(RADEON_DISP_OUTPUT_CNTL);
    save->disp_merge_cntl      = INREG(RADEON_DISP_MERGE_CNTL);
    save->crtc_more_cntl       = INREG(RADEON_CRTC_MORE_CNTL);


    save->ppll_ref_div = INPLL(pScrn, RADEON_PPLL_REF_DIV);
    save->ppll_div_3   = INPLL(pScrn, RADEON_PPLL_DIV_3);
    save->htotal_cntl  = INPLL(pScrn, RADEON_HTOTAL_CNTL);
    save->vclk_ecp_cntl= INPLL(pScrn, RADEON_VCLK_ECP_CNTL);

    RADEONTRACE(("Read: 0x%08x 0x%08x 0x%08x\n",
		 save->ppll_ref_div,

		 save->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
		 save->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK,
		 (save->ppll_div_3 & RADEON_PPLL_POST3_DIV_MASK) >> 16));
    RADEONTRACE(("Read VCLK_ECP_CNTL = %08x\n" , save->vclk_ecp_cntl));
}

/* Read PLL registers */

    RADEONSaveMode(pScrn, save);
    if (!info->IsSecondary)
	RADEONSaveSurfaces(pScrn, save);

    /*
     * Save initial RT state
     */
    if(info->theaterOut != NULL)
      xf86_theaterOutSave(info->theaterOut , pScrn);
}

/* Restore the original (text) mode */

    if (!info->IsSecondary)
	RADEONRestoreSurfaces(pScrn, restore);

    /*
     * Restore RT state
     */
    if (info->theaterOut != NULL)
      xf86_theaterOutRestore(info->theaterOut , pScrn);
#if 0
    /* Temp fix to "solve" VT switch problems.  When switching VTs on
     * some systems, the console can either hang or the fonts can be

	save->crtc2_gen_cntl      = (RADEON_CRTC2_EN | (format << 8));
	save->fp2_h_sync_strt_wid = save->crtc2_h_sync_strt_wid;
	save->fp2_v_sync_strt_wid = save->crtc2_v_sync_strt_wid;
	save->fp2_gen_cntl        = info->SavedReg.fp2_gen_cntl
				    | RADEON_FP2_SRC_SEL_CRTC2
				    | RADEON_FP2_ON;

	save->fp2_gen_cntl	  &= ~(RADEON_FP2_BLANK_EN);

	if ((info->ChipFamily == CHIP_FAMILY_R200) ||

				     pll->reference_freq);
    save->post_div       = post_div->divider;

/*    RADEONTRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",
	       save->dot_clock_freq,
	       save->pll_output_freq,
	       save->feedback_div,
	       save->post_div));
*/

    save->ppll_ref_div   = pll->reference_div;
    save->ppll_div_3     = (save->feedback_div | (post_div->bitvalue << 16));
    save->htotal_cntl    = 0;
    save->vclk_ecp_cntl  = (save->vclk_ecp_cntl & ~RADEON_VCLK_SRC_SEL_MASK) | RADEON_VCLK_SRC_SEL_PPLLCLK;
}

/* Define PLL2 registers for requested video mode */

				       pll->reference_freq);
    save->post_div_2       = post_div->divider;

/*
    RADEONTRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",
	       save->dot_clock_freq_2,
	       save->pll_output_freq_2,
	       save->feedback_div_2,
	       save->post_div_2));
*/

    save->p2pll_ref_div    = pll->reference_div;
    save->p2pll_div_0      = (save->feedback_div_2 |

#endif

    info->Flags = mode->Flags;
    /*
     * Some registers are initialized from text mode state
     */
    save->disp_output_cntl = RADEONPTR(pScrn)->SavedReg.disp_output_cntl;
    save->vclk_ecp_cntl    = RADEONPTR(pScrn)->SavedReg.vclk_ecp_cntl;


    RADEONInitMemMapRegisters(pScrn, save, info);
    RADEONInitCommonRegisters(save, info);


    if (!RADEONInit(pScrn, mode, &info->ModeReg)) return FALSE;

    /*
     * Define RT state
     */
    if (info->theaterOut != NULL)
      {
         Bool res = xf86_theaterOutInit(info->theaterOut , mode , &info->ModeReg);
         RADEONTRACE(("theaterOutInit returns %d\n" , res));
      }

    pScrn->vtSema = TRUE;
    RADEONBlank(pScrn);
    RADEONRestoreMode(pScrn, &info->ModeReg);

    /*
     * Set RT to new mode
     */
    if (info->theaterOut != NULL)
      xf86_theaterOutRestoreMode(info->theaterOut , pScrn);

    RADEONUnblank(pScrn);

    info->CurrentLayout.mode = mode;

    pScrn->FreeScreen    = RADEONFreeScreen;
    pScrn->ValidMode     = RADEONValidMode;
}


/*
 * fulivi: interface functions between RADEONSet/GetPortAttribute (in radeon_video.c) and
 * theater_out module.
 */
static void RADEONRedoSwitchMode(ScrnInfoPtr pScrn)
{
  int scrnIndex = pScrn->scrnIndex;

  /*
   * It seems that last parameter (flags) is not used
   */
  RADEONSwitchMode(scrnIndex , pScrn->currentMode , 0);
}

void RADEONTheaterOutSetStandard(ScrnInfoPtr pScrn,
                        	 TVStd std)
{
  RADEONInfoPtr info = RADEONPTR(pScrn);

  RADEONTRACE(("RADEONTheaterOutSetStandard std = %d" , std));

  if (info->theaterOut != NULL && xf86_theaterOutSetStandard(info->theaterOut , std))
    RADEONRedoSwitchMode(pScrn);
}

TVStd RADEONTheaterOutGetStandard(ScrnInfoPtr pScrn)
{
  RADEONInfoPtr info = RADEONPTR(pScrn);

  if (info->theaterOut != NULL)
    return xf86_theaterOutGetStandard(info->theaterOut);
  else
    return TV_STD_KEEP_OFF;
}

Bool RADEONTheaterOutGetCompatMode(ScrnInfoPtr pScrn)
{
  RADEONInfoPtr info = RADEONPTR(pScrn);

  if (info->theaterOut != NULL)
    return xf86_theaterOutGetCompatMode(info->theaterOut);
  else
    return FALSE;
}

void RADEONTheaterOutSetAttr(ScrnInfoPtr pScrn,
                    	     TheaterOutAttr attr,
                    	     int value)
{
  RADEONInfoPtr info = RADEONPTR(pScrn);

  if (info->theaterOut != NULL)
    xf86_theaterOutSetAttr(info->theaterOut , attr , value);
}

int RADEONTheaterOutGetAttr(ScrnInfoPtr pScrn,
                	    TheaterOutAttr attr)
{
  RADEONInfoPtr info = RADEONPTR(pScrn);

  if (info->theaterOut != NULL)
    return xf86_theaterOutGetAttr(info->theaterOut , attr);
  else
    return 0;
}

void RADEONTheaterOutGetAttrLimits(ScrnInfoPtr pScrn,
                                   TheaterOutAttr attr,
                                   int *maxValue,
                                   int *minValue)
{
  RADEONInfoPtr info = RADEONPTR(pScrn);

  if (info->theaterOut != NULL)
    xf86_theaterOutGetAttrLimits(info->theaterOut , attr , maxValue , minValue);
}

Lines 38-48 Link Here

(-)xf86-video-ati-6.5.8.0/src/radeon.h (-1 / +18 lines)
38	#ifndef _RADEON_H_	38	#ifndef _RADEON_H_
39	#define _RADEON_H_	39	#define _RADEON_H_
40		40
		41	#include "radeon_version.h"
41	#include "xf86str.h"	42	#include "xf86str.h"
42	#include "xf86_ansic.h"	43	#include "xf86_ansic.h"
43	#include "compiler.h"	44	#include "compiler.h"
44	#include "xf86fbman.h"	45	#include "xf86fbman.h"
45		46
		47	#include "generic_bus.h"
46	/* PCI support */	48	/* PCI support */
47	#include "xf86Pci.h"	49	#include "xf86Pci.h"
48		50
Lines 223-228 Link Here
223	unsigned ppll_div_3;	225	unsigned ppll_div_3;
224	CARD32 htotal_cntl;	226	CARD32 htotal_cntl;
225		227
		228	CARD32 vclk_ecp_cntl;
		229
226	/* Computed values for PLL2 */	230	/* Computed values for PLL2 */
227	CARD32 dot_clock_freq_2;	231	CARD32 dot_clock_freq_2;
228	CARD32 pll_output_freq_2;	232	CARD32 pll_output_freq_2;
Lines 638-643 Link Here
638	char* RageTheatreMicrocPath;	642	char* RageTheatreMicrocPath;
639	char* RageTheatreMicrocType;	643	char* RageTheatreMicrocType;
640	Bool MM_TABLE_valid;	644	Bool MM_TABLE_valid;
		645	GENERIC_BUS_Ptr VIP;
		646	struct TheaterOut *theaterOut;
641	struct {	647	struct {
642	CARD8 table_revision;	648	CARD8 table_revision;
643	CARD8 table_size;	649	CARD8 table_size;
Lines 729-734 Link Here
729	info->fifo_slots -= entries; \	735	info->fifo_slots -= entries; \
730	} while (0)	736	} while (0)
731		737
		738	#include "theater_out.h"
		739
732	extern RADEONEntPtr RADEONEntPriv(ScrnInfoPtr pScrn);	740	extern RADEONEntPtr RADEONEntPriv(ScrnInfoPtr pScrn);
733	extern void RADEONWaitForFifoFunction(ScrnInfoPtr pScrn, int entries);	741	extern void RADEONWaitForFifoFunction(ScrnInfoPtr pScrn, int entries);
734	extern void RADEONWaitForIdleMMIO(ScrnInfoPtr pScrn);	742	extern void RADEONWaitForIdleMMIO(ScrnInfoPtr pScrn);
Lines 739-744 Link Here
739	extern void RADEONDoAdjustFrame(ScrnInfoPtr pScrn, int x, int y,	747	extern void RADEONDoAdjustFrame(ScrnInfoPtr pScrn, int x, int y,
740	int clone);	748	int clone);
741		749
		750	extern void RADEONTheaterOutSetStandard(ScrnInfoPtr, TVStd);
		751	extern TVStd RADEONTheaterOutGetStandard(ScrnInfoPtr);
		752	extern Bool RADEONTheaterOutGetCompatMode(ScrnInfoPtr);
		753	extern void RADEONTheaterOutSetAttr(ScrnInfoPtr, TheaterOutAttr, int);
		754	extern int RADEONTheaterOutGetAttr(ScrnInfoPtr, TheaterOutAttr);
		755	extern void RADEONTheaterOutGetAttrLimits(ScrnInfoPtr, TheaterOutAttr, int , int );
		756
742	extern void RADEONEngineReset(ScrnInfoPtr pScrn);	757	extern void RADEONEngineReset(ScrnInfoPtr pScrn);
743	extern void RADEONEngineFlush(ScrnInfoPtr pScrn);	758	extern void RADEONEngineFlush(ScrnInfoPtr pScrn);
744	extern void RADEONEngineRestore(ScrnInfoPtr pScrn);	759	extern void RADEONEngineRestore(ScrnInfoPtr pScrn);
Lines 770-776 Link Here
770		785
771	extern int RADEONMinBits(int val);	786	extern int RADEONMinBits(int val);
772		787
773	extern void RADEONInitVideo(ScreenPtr pScreen);	788	extern GENERIC_BUS_Ptr RADEONAllocateVIP(ScrnInfoPtr pScrn);
		789
		790	extern void RADEONInitVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre);
774	extern void RADEONResetVideo(ScrnInfoPtr pScrn);	791	extern void RADEONResetVideo(ScrnInfoPtr pScrn);
775	extern void R300CGWorkaround(ScrnInfoPtr pScrn);	792	extern void R300CGWorkaround(ScrnInfoPtr pScrn);
776		793

Lines 1223-1228 Link Here

(-)xf86-video-ati-6.5.8.0/src/radeon_reg.h (+3 lines)
1223	# define RADEON_PPLL_SLEEP (1 << 1)	1223	# define RADEON_PPLL_SLEEP (1 << 1)
1224	# define RADEON_PPLL_ATOMIC_UPDATE_EN (1 << 16)	1224	# define RADEON_PPLL_ATOMIC_UPDATE_EN (1 << 16)
1225	# define RADEON_PPLL_VGA_ATOMIC_UPDATE_EN (1 << 17)	1225	# define RADEON_PPLL_VGA_ATOMIC_UPDATE_EN (1 << 17)
		1226	# define RADEON_PPLL_PVG_MASK (7 << 11)
		1227	# define RADEON_PPLL_PVG_SHIFT 11
		1228
1226	# define RADEON_PPLL_ATOMIC_UPDATE_VSYNC (1 << 18)	1229	# define RADEON_PPLL_ATOMIC_UPDATE_VSYNC (1 << 18)
1227	#define RADEON_PPLL_DIV_0 0x0004 /* PLL */	1230	#define RADEON_PPLL_DIV_0 0x0004 /* PLL */
1228	#define RADEON_PPLL_DIV_1 0x0005 /* PLL */	1231	#define RADEON_PPLL_DIV_1 0x0005 /* PLL */





static void RADEONInitOffscreenImages(ScreenPtr);

static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr , GENERIC_BUS_Ptr , Bool);
static int  RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);
static int  RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);
static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);

	     
static Atom xvOvAlpha, xvGrAlpha, xvAlphaMode;

static Atom xvTvoStandard , xvTvoModeCompat;

typedef struct
{
  char *name;
  TheaterOutAttr attr;
  Atom atom;
} TVOAttr;

static
TVOAttr theaterOutAttrs[] =
{
  {"XV_TVO_HPOS" , THEATER_OUT_HPOS , 0 },
  {"XV_TVO_VPOS" , THEATER_OUT_VPOS , 0 },
  {"XV_TVO_HSIZE" , THEATER_OUT_HSIZE , 0 }
};
#define N_TVO_ATTRS (sizeof(theaterOutAttrs) / sizeof(theaterOutAttrs[ 0 ]))

#define GET_PORT_PRIVATE(pScrn) \
   (RADEONPortPrivPtr)((RADEONPTR(pScrn))->adaptor->pPortPrivates[0].ptr)

}
#endif /* USE_EXA */

void RADEONInitVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL;
    XF86VideoAdaptorPtr newAdaptor = NULL;
    int num_adaptors;

    newAdaptor = RADEONSetupImageVideo(pScreen , VIP , loadTheatre);
    RADEONInitOffscreenImages(pScreen);
    num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);



#endif

//#define NUM_ATTRIBUTES 22
#define NUM_ATTRIBUTES 22+5
#define NUM_DEC_ATTRIBUTES (NUM_ATTRIBUTES+12)

static XF86AttributeRec Attributes[NUM_DEC_ATTRIBUTES+1] =

   {XvSettable | XvGettable,     0,  255, "XV_OVERLAY_ALPHA"},
   {XvSettable | XvGettable,     0,  255, "XV_GRAPHICS_ALPHA"},
   {XvSettable | XvGettable,     0,    1, "XV_ALPHA_MODE"},

   {XvSettable | XvGettable,     0, TV_STD_N_STANDARDS-1, "XV_TVO_STANDARD"},
   {             XvGettable,     0,   ~0,   "XV_TVO_MODE_COMPAT"},
   {XvSettable | XvGettable, -1000, 1000, "XV_TVO_HPOS"},
   {XvSettable | XvGettable, -1000, 1000, "XV_TVO_VPOS"},
   {XvSettable | XvGettable, -1000, 1000, "XV_TVO_HSIZE"},

   {XvSettable | XvGettable, -1000, 1000, "XV_BRIGHTNESS"},
   {XvSettable | XvGettable, -1000, 1000, "XV_CONTRAST"},
   {XvSettable | XvGettable, -1000, 1000, "XV_SATURATION"},

    RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;
    char tmp[200];

    unsigned i;
    /* this function is called from ScreenInit. pScreen is used 
       by XAA internally, but not valid until ScreenInit finishs.
    */

    xvLocationID = MAKE_ATOM("XV_LOCATION_ID");
    xvDumpStatus = MAKE_ATOM("XV_DUMP_STATUS");
 
    xvTvoStandard = MAKE_ATOM("XV_TVO_STANDARD");
    xvTvoModeCompat = MAKE_ATOM("XV_TVO_MODE_COMPAT");

    for (i = 0; i < N_TVO_ATTRS; i++)
    {
        char *name;
        name = theaterOutAttrs[ i ].name;
        theaterOutAttrs[ i ].atom = MakeAtom(name, strlen(name), TRUE);

        RADEONTRACE(("RADEONResetVideo,name=%s,atom=%d\n",name,theaterOutAttrs[ i ].atom));
    }

    xvBrightness   = MAKE_ATOM("XV_BRIGHTNESS");
    xvSaturation   = MAKE_ATOM("XV_SATURATION");
    xvColor        = MAKE_ATOM("XV_COLOR");

}

static XF86VideoAdaptorPtr
RADEONAllocAdaptor(ScrnInfoPtr pScrn, GENERIC_BUS_Ptr VIP)
{
    XF86VideoAdaptorPtr adapt;
    RADEONInfoPtr info = RADEONPTR(pScrn);

    #endif

    /* Initialize VIP bus */
//    RADEONVIP_init(pScrn, pPriv);
    pPriv->VIP = VIP;

    info->adaptor = adapt;

	if(!xf86LoadSubModule(pScrn,"theatre_detect")) 

}

static XF86VideoAdaptorPtr
RADEONSetupImageVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    RADEONPortPrivPtr pPriv;
    XF86VideoAdaptorPtr adapt;
    unsigned i;

    if(!(adapt = RADEONAllocAdaptor(pScrn, VIP)))
	return NULL;

    adapt->type = XvWindowMask | XvInputMask | XvImageMask;

    adapt->PutImage = RADEONPutImage;
    adapt->QueryImageAttributes = RADEONQueryImageAttributes;

    /*
     * fulivi: set limits of theater_out attributes
     */
    for (i = 0; i < N_TVO_ATTRS; i++)
      {
        int maxValue;
        int minValue;
        unsigned j;

        RADEONTheaterOutGetAttrLimits(pScrn , theaterOutAttrs[ i ].attr , &maxValue , &minValue);

        for (j = 0; i < NUM_DEC_ATTRIBUTES; j++)
          if (strcmp(theaterOutAttrs[ i ].name , Attributes[ j ].name) == 0)
            {
              Attributes[ j ].min_value = minValue;
              Attributes[ j ].max_value = maxValue;
              break;
            }
      }

    pPriv = (RADEONPortPrivPtr)(adapt->pPortPrivates[0].ptr);
    REGION_NULL(pScreen, &(pPriv->clip));


		RADEON_TDA9885_SetEncoding(pPriv);
		}
   }
   else if (attribute == xvTvoStandard)
      {
        value = ClipValue(value , 0 , TV_STD_N_STANDARDS-1);
        RADEONTheaterOutSetStandard(pScrn , (TVStd)value);
      }
    else
      {
        unsigned i;

	for (i = 0; i < N_TVO_ATTRS; i++)
        if (theaterOutAttrs[ i ].atom == attribute)
          {
            RADEONTheaterOutSetAttr(pScrn , theaterOutAttrs[ i ].attr , value);
            break;
          }
      if (i == N_TVO_ATTRS)
 	return BadMatch;
    }

    if (setTransform)
    {

        *value = pPriv->instance_id;
    else if(attribute == xvAdjustment)
  	*value = pPriv->adjustment;
    else if(attribute == xvTvoStandard)
        *value = (INT32)RADEONTheaterOutGetStandard(pScrn);
    else if(attribute == xvTvoModeCompat)
        *value = (INT32)RADEONTheaterOutGetCompatMode(pScrn);
    else {
        unsigned i;

        for (i = 0; i < N_TVO_ATTRS; i++) {
            if (theaterOutAttrs[ i ].atom == attribute) {
                *value = (INT32)RADEONTheaterOutGetAttr(pScrn , theaterOutAttrs[ i].attr);
                break;
            }
        }
        if (i == N_TVO_ATTRS)
	    return BadMatch;
    }

    return Success;
}

Lines 47-52 Link Here

(-)xf86-video-ati-6.5.8.0/src/radeon_video.h (+2 lines)
47	GENERIC_BUS_Ptr VIP;	47	GENERIC_BUS_Ptr VIP;
48	TheatrePtr theatre;	48	TheatrePtr theatre;
49		49
		50	/* TheaterOutPtr theaterOut; */
		51
50	Bool video_stream_active;	52	Bool video_stream_active;
51	int encoding;	53	int encoding;
52	CARD32 frequency;	54	CARD32 frequency;

Lines 340-345 Link Here

(-)xf86-video-ati-6.5.8.0/src/radeon_vip.c (-1 / +29 lines)
340		340
341	void RADEONVIP_init(ScrnInfoPtr pScrn, RADEONPortPrivPtr pPriv)	341	void RADEONVIP_init(ScrnInfoPtr pScrn, RADEONPortPrivPtr pPriv)
342	{	342	{
		343	/*
343	pPriv->VIP=xcalloc(1,sizeof(GENERIC_BUS_Rec));	344	pPriv->VIP=xcalloc(1,sizeof(GENERIC_BUS_Rec));
344	pPriv->VIP->scrnIndex=pScrn->scrnIndex;	345	pPriv->VIP->scrnIndex=pScrn->scrnIndex;
345	pPriv->VIP->DriverPrivate.ptr=pPriv;	346	pPriv->VIP->DriverPrivate.ptr=pPriv;
Lines 348-353 Link Here
348	pPriv->VIP->write=RADEONVIP_write;	349	pPriv->VIP->write=RADEONVIP_write;
349	pPriv->VIP->fifo_read=RADEONVIP_fifo_read;	350	pPriv->VIP->fifo_read=RADEONVIP_fifo_read;
350	pPriv->VIP->fifo_write=RADEONVIP_fifo_write;	351	pPriv->VIP->fifo_write=RADEONVIP_fifo_write;
351
352	RADEONVIP_reset(pScrn, pPriv);	352	RADEONVIP_reset(pScrn, pPriv);
		353	*/
		354	pPriv->VIP = RADEONAllocateVIP(pScrn);
353	}	355	}
		356
		357	/*
		358	* fulivi: This new function was created because I needed VIP access from radeon_driver module
		359	* (where port private data doesn't exist)
		360	*/
		361	GENERIC_BUS_Ptr
		362	RADEONAllocateVIP(
		363	ScrnInfoPtr pScrn
		364	)
		365	{
		366	GENERIC_BUS_Ptr VIP=NULL;
		367
		368	VIP = xcalloc(1 , sizeof(GENERIC_BUS_Rec));
		369	VIP->DriverPrivate.ptr = NULL; /* Nobody seems to use this */
		370	VIP->scrnIndex = pScrn->scrnIndex;
		371	VIP->ioctl = RADEONVIP_ioctl;
		372	VIP->read = RADEONVIP_read;
		373	VIP->write = RADEONVIP_write;
		374	VIP->fifo_read=RADEONVIP_fifo_read;
		375	VIP->fifo_write=RADEONVIP_fifo_write;
		376
		377	RADEONVIP_reset(pScrn,NULL);
		378
		379	return VIP;
		380	}
		381





      *******************************************************
      **  XFree86 driver for TV output on ATI Radeon cards **
      *******************************************************

Copyright (c) 2003-2004, by Federico Ulivi <fulivi@lycos.com>
Released under the GNU General Public License, version 2.

1. About this driver
--------------------

This driver was developped as a part of ati.2 project. Its purpose
is to enable the TV output of ATI Radeon cards when running the
XFree86 graphical environment.

2. Status of the driver
-----------------------

The driver is in early development stage. It currently works with
those cards having a Rage Theater chip for TV output or with cards
having the tv module inside the Radeon chip (ERT, Embedded Rage
Theater, is my name for the latter).
The driver was successfully tested on these cards:
- Radeon 7200 / European model (TV out hw: RT 100)
- Radeon 9000 (TV out hw: ERT)
- Radeon 9200SE (TV out hw: ERT)
- Radeon 7000 (TV out hw: ERT)

3. Making it work
-----------------

The driver is always loaded by the Radeon driver. If you need to
disable this auto-loading mechanism, just set the "TVOutput" option
(see below) to "NOLOAD".
In principle the driver should coexist with video grabbing functions,
especially on those AIW cards where TV output is done by ERT
inside Radeon.

Principle of operation of the driver is very simple. Driver enables 
tv output whenever the current screen resolution and tv standard match
one of a set of pre-computed combinations. In all other cases tv output
is simply kept disabled.
The driver currently works in the so-called "clone" mode only. This means
that the image on the TV screen is exactly the same as the one on the
monitor.

The driver is enabled by adding a "TVOutput" line in the "device"
section of XF86Config-4 file (this file is usually located in /etc/X11
directory). Syntax of this option is very simple:

Section "Device"
 ..
 ..
 Option "TVOuput" "<name of tv standard>"
EndSection

Names of recognized TV standards are:
"NTSC"
"NTSC-J"
"PAL"
"PAL-CN"
"PAL-M"
"PAL-N"
"PAL-60"

If "TVOutput" is not present or its value is invalid, TV output is kept disabled.

In the current version of the driver these are the recognized TV standard &
resolution combinations:

PAL	800x600
NTSC	800x600

More combinations will be added in future releases.

4. XV Interface
---------------

The driver has an external interface through some Xv attributes. 
You can change the value of these attributes by using the tvo_set utility
(see below).

XV_TVO_STANDARD		Settable/Gettable
	This is the tv standard in use by the driver. Its value is encoded
	according to this table:

	0	NTSC
	1	PAL
	2	PAL-M
	3	PAL-60
	4	NTSC-J
	5	PAL-CN
	6	PAL-N
	7	Keep TV off

XV_TVO_MODE_COMPAT	Gettable
	This attribute is set to 1 whenever TV output is enabled, i.e.
	whenever the current resolution & tv standard combination is 
	recognized by the driver. 

XV_TVO_HPOS	Settable/Gettable
	Horizontal position, valid range is [-5..+5]. 
	This attribute defines the horizontal position of the TV image.
	Higher values shift the image to the right, lower values to the left.

XV_TVO_VPOS	Settable/Gettable
	Vertical position, valid range is [-5..+5]. 
	This attribute defines the vertical position of the TV image.
	Higher values shift the image upward, lower values downward.

XV_TVO_HSIZE	Settable/Gettable
	Horizontal size, valid range is [-5..+5]. 
	This attribute is used to set the horizontal size of TV image.
	Higher values enlarge TV lines, lower values reduce them.

Default value for XV_TVO_HPOS, XV_TVO_VPOS & XV_TVO_HSIZE just after
X Window start is 0.

You might ask where a vertical size attribute has gone. It was not included
because it's quite hard to implement (it requires changing many timings in
the CRTC). For the moment I'm not planning to work on it.

5. tvo_set utility
------------------

tvo_set is a command line utility that is used to change TV output
attributes while X Window is running. It offers a somewhat more
friendly interface to XV_TVO_* attributes.

This is how to compile tvo_set:
- cd to tvo_set directory
- xmkmf
- make
- make install
Last step should place the executable (tvo_set) in /usr/X11R6/bin.

This is the invocation syntax:
tvo_set [-display host:dpy] [<cmd> <attribute> [<value>]]

tvo_set is not case sensitive for <cmd>, <attribute> & <value>
fields.
When no <cmd> is given, tvo_set just dumps the current state of
TV attributes.

Recognized commands:
set <attribute> <value>   Set <attribute> to <value>
inc <attribute>           Increment <attribute> by 1
dec <attribute>           Decrement <attribute> by 1
zero <attribute>          Set <attribute> to 0

Recognized values for <attribute> field:
hpos	Horizontal position
vpos	Vertical position
hsize	Horizontal size
std	TV Standard

When setting "std" attribute, both the numeric value and the name of the 
standard are valid, see following table.

Table of TV standards:
0	NTSC
1	PAL
2	PAL-M
3	PAL-60
4	NTSC-J
5	PAL-CN
6	PAL-N
7	OFF

Examples:
"tvo_set set std ntsc"
	Set standard to NTSC

"tvo_set set std off"
	Turn off TV output

"tvo_set set hsize 5"
	Set hsize to 5

"tvo_set inc hpos"
	Shift image a bit to the right (increment hpos by 1)

"tvo_set zero vpos"
	Restore default value for vpos


6. WARNING
----------

It's important that you are aware of the fact that, when TV output is active,
the monitor is driven at the same vertical refresh frequency as that of the
TV output. This means 50 or 60 Hz according to the standard you're using.
NO CHECK IS DONE IN THE DRIVER ABOUT THE CAPABILITY OF THE MONITOR TO
SUSTAIN THESE FREQUENCIES. You should look up in the monitor manual
and check that 50/60 Hz is within the limits. IT IS POTENTIALLY HARMFUL
TO THE MONITOR TO BE DRIVEN AT A FREQUENCY OUTSIDE ITS OPERATING RANGE.

Note, however, that most monitors should accept a 60 Hz vertical frequency,
since this is used in standard VGA modes. You should really check for 50 Hz 
compatibility if you are going to use any related standard (PAL mostly).
ATI manuals recommend checking for 50 Hz compatibility (they take
60 Hz for granted).

One last thing: I did no testing on cards having DVI/LCD outputs
so I'm not sure about the driver behaviour with this kind of displays. 
Be warned.

6. Credits
----------

Vladimir Dergachev	For leading the GATOS project, for all the good
			advices he gave me about dealing with ATI and for
			all his precious technical hints.

ATI external developer office
			For providing me the Rage Theater documentation.

7.  Revision history
--------------------


2003-09-23
==========

Initial release

2003-11-26
==========

Support for ERT added

2004-01-27
==========

Support for sizing/positioning of TV image added





/*********************************************************************
 *
 * $Id: theater_out.c,v 1.1.2.3 2004/01/27 22:50:35 fulivi Exp $
 *
 * Main file for tv output handling of ATI Rage Theater chip 
 *
 * Copyright (C) 2003 Federico Ulivi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * AUTHORS: F.Ulivi
 * NOTES:
 * $Log: theater_out.c,v $
 * Revision 1.1.2.3  2004/01/27 22:50:35  fulivi
 * Support for positioning/sizing of image added
 *
 * Revision 1.1.1.1.2.12  2004/01/18 22:59:29  fede
 * hSize handling added
 * Functions for get/setting h/v pos/size replaced by
 * theaterOutSetAttr/theaterOutGetAttr/theaterOutGetAttrLimits
 *
 * Revision 1.1.1.1.2.11  2004/01/11 21:29:04  fede
 * Fixes in H/V position handling
 *
 * Revision 1.1.1.1.2.10  2004/01/05 00:08:16  fede
 * Functions for setting H/V position added
 * Functions for setting/getting on/off attribute removed
 *
 * Revision 1.1.2.2  2003/11/26 19:50:10  fulivi
 * Support for ERT added
 *
 * Revision 1.1.1.1.2.9  2003/11/25 20:46:44  fede
 * "enabled" state removed
 * Handling of disabled tv output fixed
 *
 * Revision 1.1.1.1.2.8  2003/11/23 00:47:28  fede
 * Major cleanup of #define names
 *
 * Revision 1.1.1.1.2.7  2003/11/17 22:26:12  fede
 * Support for tv standards added
 * Support for NTSC added
 *
 * Revision 1.1.1.1.2.6  2003/10/14 18:40:34  fede
 * Autodetection of ERT moved to front
 * Some minor cleanups
 *
 * Revision 1.1.1.1.2.5  2003/10/11 12:29:50  fede
 * Support for ERT added
 *
 * Revision 1.1  2003/09/28 21:42:37  fulivi
 * Theater_out module added
 *
 * Revision 1.1.1.1.2.4  2003/09/28 15:11:57  fede
 * Some minor aesthetic changes
 *
 * Revision 1.1.1.1.2.2  2003/08/31 13:35:58  fede
 * Adapted for XFree86
 *
 * Revision 1.1.1.1.2.1  2003/08/09 23:20:46  fede
 * Switched to memory mapped IO
 * Some magic numbers turned into named constants
 *
 * Revision 1.1.1.1  2003/07/24 15:37:27  fede
 * Initial version
 *
 *
 *********************************************************************/

#include "xf86.h"
#include "generic_bus.h"
#include "theatre_reg.h"
#include "radeon_reg.h"
#include "radeon_macros.h"
#include "theater_out.h"
#define RADEON_NAME "RADEON"

#undef read
#undef write
#undef ioctl

#if RADEON_DEBUG
#define RTTRACE(x)							\
do {									\
    ErrorF("(**) %s(%d): ", RADEON_NAME, 0);		\
    ErrorF x;								\
} while (0);
#else
#define RTTRACE(x)
#endif

/**********************************************************************
 *
 * MASK_N_BIT
 *
 **********************************************************************/

#define MASK_N_BIT(n)	(1UL << (n))

/**********************************************************************
 *
 * Constants
 *
 **********************************************************************/

/*
 * Reference frequency
 * FIXME: This should be extracted from BIOS data
 */
#define REF_FREQUENCY		27000

#define TV_PLL_FINE_INI			0X10000000

/*
 * VIP_TV_PLL_CNTL
 */
#define VIP_TV_PLL_CNTL_M_SHIFT		0
#define VIP_TV_PLL_CNTL_NLO		0x1ff
#define VIP_TV_PLL_CNTL_NLO_SHIFT	8
#define VIP_TV_PLL_CNTL_NHI		0x600
#define VIP_TV_PLL_CNTL_NHI_SHIFT	(21-9)
#define VIP_TV_PLL_CNTL_P_SHIFT		24

/*
 * VIP_CRT_PLL_CNTL
 */
#define VIP_CRT_PLL_CNTL_M		0xff
#define VIP_CRT_PLL_CNTL_M_SHIFT	0
#define VIP_CRT_PLL_CNTL_NLO		0x1ff
#define VIP_CRT_PLL_CNTL_NLO_SHIFT	8
#define VIP_CRT_PLL_CNTL_NHI		0x600
#define VIP_CRT_PLL_CNTL_NHI_SHIFT	(21-9)
#define VIP_CRT_PLL_CNTL_CLKBY2		MASK_N_BIT(25)

/*
 * Value for VIP_PLL_CNTL0
 */
#define VIP_PLL_CNTL0_INI		0x00acac18
#define VIP_PLL_CNTL0_TVSLEEPB		MASK_N_BIT(3)
#define VIP_PLL_CNTL0_CRTSLEEPB		MASK_N_BIT(4)

/*
 * Value for VIP_PLL_TEST_CNTL
 */
#define VIP_PLL_TEST_CNTL_INI		0

/*
 * VIP_CLOCK_SEL_CNTL
 */
#define VIP_CLOCK_SEL_CNTL_INI		0x33
#define VIP_CLOCK_SEL_CNTL_BYTCLK_SHIFT	2
#define VIP_CLOCK_SEL_CNTL_BYTCLK	0xc
#define VIP_CLOCK_SEL_CNTL_REGCLK	MASK_N_BIT(5)
#define VIP_CLOCK_SEL_CNTL_BYTCLKD_SHIFT 8

/*
 * Value for VIP_CLKOUT_CNTL
 */
#define VIP_CLKOUT_CNTL_INI		0x29

/*
 * Value for VIP_SYNC_LOCK_CNTL
 */
#define VIP_SYNC_LOCK_CNTL_INI		0x01000000

/*
 * Value for VIP_TVO_SYNC_PAT_EXPECT
 */
#define VIP_TVO_SYNC_PAT_EXPECT_INI	0x00000001

/*
 * VIP_RGB_CNTL
 */
#define VIP_RGB_CNTL_RGB_IS_888_PACK	MASK_N_BIT(0)

/*
 * Value for VIP_VSCALER_CNTL2
 */
#define VIP_VSCALER_CNTL2_INI		0x10000000

/*
 * Value for VIP_Y_FALL_CNTL
 */
/* #define VIP_Y_FALL_CNTL_INI		0x00010200 */
#define VIP_Y_FALL_CNTL_INI		0x80030400

/*
 * VIP_UV_ADR
 */
#define VIP_UV_ADR_INI			0xc8
#define VIP_UV_ADR_HCODE_TABLE_SEL	0x06000000
#define VIP_UV_ADR_HCODE_TABLE_SEL_SHIFT 25
#define VIP_UV_ADR_VCODE_TABLE_SEL	0x18000000
#define VIP_UV_ADR_VCODE_TABLE_SEL_SHIFT 27
#define VIP_UV_ADR_MAX_UV_ADR		0x000000ff
#define VIP_UV_ADR_MAX_UV_ADR_SHIFT	0
#define VIP_UV_ADR_TABLE1_BOT_ADR	0x0000ff00
#define VIP_UV_ADR_TABLE1_BOT_ADR_SHIFT	8
#define VIP_UV_ADR_TABLE3_TOP_ADR	0x00ff0000
#define VIP_UV_ADR_TABLE3_TOP_ADR_SHIFT	16
#define MAX_FIFO_ADDR_RT		0x1a7
#define MAX_FIFO_ADDR_ERT		0x1ff

/*
 * VIP_HOST_RD_WT_CNTL
 */
#define VIP_HOST_RD_WT_CNTL_RD		MASK_N_BIT(12)
#define VIP_HOST_RD_WT_CNTL_RD_ACK	MASK_N_BIT(13)
#define VIP_HOST_RD_WT_CNTL_WT		MASK_N_BIT(14)
#define VIP_HOST_RD_WT_CNTL_WT_ACK	MASK_N_BIT(15)

/*
 * Value for VIP_SYNC_CNTL
 */
#define VIP_SYNC_CNTL_INI		0x28

/*
 * VIP_VSCALER_CNTL1
 */
#define VIP_VSCALER_CNTL1_UV_INC	0xffff
#define VIP_VSCALER_CNTL1_UV_INC_SHIFT	0

/*
 * VIP_TIMING_CNTL
 */
#define VIP_TIMING_CNTL_UV_OUT_POST_SCALE_SHIFT	24
#define VIP_TIMING_CNTL_INI		0x000b0000
#define VIP_TIMING_CNTL_H_INC_SHIFT	0
#define VIP_TIMING_CNTL_H_INC		0xfff

/*
 * Value for VIP_PRE_DAC_MUX_CNTL
 */
#define VIP_PRE_DAC_MUX_CNTL_INI	0x0000000f

/*
 * VIP_TV_DAC_CNTL
 */
#define VIP_TV_DAC_CNTL_NBLANK		MASK_N_BIT(0)
#define VIP_TV_DAC_CNTL_DASLEEP		MASK_N_BIT(3)
#define VIP_TV_DAC_CNTL_BGSLEEP		MASK_N_BIT(6)

/*
 * Value for VIP_FRAME_LOCK_CNTL
 */
#define VIP_FRAME_LOCK_CNTL_INI		0x0000000f

/*
 * Value for VIP_HW_DEBUG
 */
#define VIP_HW_DEBUG_INI 		0x00000200

/*
 * VIP_MASTER_CNTL
 */
#define VIP_MASTER_CNTL_TV_ASYNC_RST	MASK_N_BIT(0)
#define VIP_MASTER_CNTL_CRT_ASYNC_RST	MASK_N_BIT(1)
#define VIP_MASTER_CNTL_RESTART_PHASE_FIX	MASK_N_BIT(3)
#define VIP_MASTER_CNTL_TV_FIFO_ASYNC_RST	MASK_N_BIT(4)
#define VIP_MASTER_CNTL_VIN_ASYNC_RST	MASK_N_BIT(5)
#define VIP_MASTER_CNTL_AUD_ASYNC_RST	MASK_N_BIT(6)
#define VIP_MASTER_CNTL_DVS_ASYNC_RST	MASK_N_BIT(7)
#define VIP_MASTER_CNTL_CRT_FIFO_CE_EN	MASK_N_BIT(9)
#define VIP_MASTER_CNTL_TV_FIFO_CE_EN	MASK_N_BIT(10)
#define VIP_MASTER_CNTL_ON_INI		(VIP_MASTER_CNTL_RESTART_PHASE_FIX | \
					 VIP_MASTER_CNTL_VIN_ASYNC_RST | \
					 VIP_MASTER_CNTL_AUD_ASYNC_RST | \
					 VIP_MASTER_CNTL_DVS_ASYNC_RST | \
					 VIP_MASTER_CNTL_CRT_FIFO_CE_EN | \
					 VIP_MASTER_CNTL_TV_FIFO_CE_EN)
#define VIP_MASTER_CNTL_OFF_INI		(VIP_MASTER_CNTL_TV_ASYNC_RST | \
					 VIP_MASTER_CNTL_CRT_ASYNC_RST | \
					 VIP_MASTER_CNTL_RESTART_PHASE_FIX | \
					 VIP_MASTER_CNTL_TV_FIFO_ASYNC_RST | \
					 VIP_MASTER_CNTL_VIN_ASYNC_RST | \
					 VIP_MASTER_CNTL_AUD_ASYNC_RST | \
					 VIP_MASTER_CNTL_DVS_ASYNC_RST | \
					 VIP_MASTER_CNTL_CRT_FIFO_CE_EN | \
					 VIP_MASTER_CNTL_TV_FIFO_CE_EN)

/*
 * Value for VIP_LINEAR_GAIN_SETTINGS
 */
#define VIP_LINEAR_GAIN_SETTINGS_INI	0x01000100

/*
 * Value for VIP_GAIN_LIMIT_SETTINGS_INI
 */
#define VIP_GAIN_LIMIT_SETTINGS_INI	0x017f05ff

/*
 * Value for VIP_UPSAMP_AND_GAIN_CNTL 
 */
#define VIP_UPSAMP_AND_GAIN_CNTL_INI	0x00000005

/*
 * RADEON_VCLK_ECP_CNTL
 */
#define RADEON_VCLK_ECP_CNTL_BYTECLK_POSTDIV	0x00030000
#define RADEON_VCLK_ECP_CNTL_BYTECLK_NODIV	0x00000000

/*
 * RADEON_PLL_TEST_CNTL
 */
#define RADEON_PLL_TEST_CNTL_PLL_MASK_READ_B	MASK_N_BIT(9)

/*
 * RADEON_DAC_CNTL
 */
#define RADEON_DAC_CNTL_DAC_TVO_EN	MASK_N_BIT(10)

#define RADEON_PPLL_POST3_DIV_BY_2	0x10000
#define RADEON_PPLL_POST3_DIV_BY_3	0x40000
#define RADEON_PPLL_FB3_DIV_SHIFT	0
#define RADEON_PPLL_POST3_DIV_SHIFT	16

/*
 * RADEON_DISP_MERGE_CNTL
 */
//#define RADEON_DISP_MERGE_CNTL		0xd60
#define	RADEON_DISP_MERGE_CNTL_INI	0xffff0000

/*
 * RADEON_HTOTAL_CNTL
 */
#define RADEON_HTOTAL_CNTL_HTOT_PIX_SLIP_SHIFT	0
#define RADEON_HTOTAL_CNTL_HTOT_CNTL_VGA_EN	MASK_N_BIT(28)

/*
 * RADEON_DISP_OUTPUT_CNTL
 */
#define RADEON_DISP_TV_SOURCE		MASK_N_BIT(16)
#define RADEON_DISP_TV_MODE_MASK	(3 << 17)
#define RADEON_DISP_TV_MODE_888		(0 << 17)
#define RADEON_DISP_TV_MODE_565		(1 << 17)
#define RADEON_DISP_TV_YG_DITH_EN	MASK_N_BIT(19)
#define RADEON_DISP_TV_CBB_CRR_DITH_EN	MASK_N_BIT(20)
#define RADEON_DISP_TV_BIT_WIDTH	MASK_N_BIT(21)
#define RADEON_DISP_TV_SYNC_MODE_MASK	(3 << 22)
#define RADEON_DISP_TV_SYNC_COLOR_MASK	(3 << 25)

/*
 * ERT registers
 */
#define TV_MASTER_CNTL		0x0800
#define		TV_MASTER_CNTL_TVCLK_ALWAYS_ON	MASK_N_BIT(30)
#define		TV_MASTER_CNTL_TV_ON	MASK_N_BIT(31)
#define		TV_MASTER_CNTL_ON_INI	(VIP_MASTER_CNTL_VIN_ASYNC_RST | \
					 VIP_MASTER_CNTL_CRT_FIFO_CE_EN | \
					 VIP_MASTER_CNTL_TV_FIFO_CE_EN | \
					 TV_MASTER_CNTL_TVCLK_ALWAYS_ON | \
					 TV_MASTER_CNTL_TV_ON)
#define		TV_MASTER_CNTL_OFF_INI	(VIP_MASTER_CNTL_TV_ASYNC_RST | \
					 VIP_MASTER_CNTL_CRT_ASYNC_RST | \
					 VIP_MASTER_CNTL_TV_FIFO_ASYNC_RST | \
					 VIP_MASTER_CNTL_CRT_FIFO_CE_EN | \
					 VIP_MASTER_CNTL_TV_FIFO_CE_EN | \
					 TV_MASTER_CNTL_TVCLK_ALWAYS_ON)
#define TV_RGB_CNTL		0x0804
#define		TV_RGB_CNTL_INI	0x007b0004
#define TV_SYNC_CNTL		0x0808
#define TV_HTOTAL		0x080c
#define TV_HDISP		0x0810
#define TV_HSTART		0x0818
#define TV_HCOUNT		0x081c
#define TV_VTOTAL		0x0820
#define TV_VDISP		0x0824
#define TV_VCOUNT		0x0828
#define TV_FTOTAL		0x082c
#define TV_FCOUNT		0x0830
#define TV_FRESTART		0x0834
#define TV_HRESTART		0x0838
#define TV_VRESTART		0x083c
#define TV_HOST_READ_DATA	0x0840
#define TV_HOST_WRITE_DATA	0x0844
#define TV_HOST_RD_WT_CNTL	0x0848
#define TV_VSCALER_CNTL1	0x084c
#define		TV_VSCALER_CNTL1_RESTART_FIELD	MASK_N_BIT(29)
#define TV_TIMING_CNTL		0x0850
#define TV_VSCALER_CNTL2	0x0854
#define TV_Y_FALL_CNTL		0x0858
#define TV_Y_RISE_CNTL		0x085c
#define TV_Y_SAWTOOTH_CNTL	0x0860
#define TV_UPSAMP_AND_GAIN_CNTL 0x0864
#define TV_GAIN_LIMIT_SETTINGS	0x0868
#define TV_LINEAR_GAIN_SETTINGS 0x086c
#define TV_MODULATOR_CNTL1	0x0870
#define TV_MODULATOR_CNTL2	0x0874
#define TV_PRE_DAC_MUX_CNTL	0x0888
#define TV_DAC_CNTL		0x088c
#define		TV_DAC_CNTL_NBLANK	MASK_N_BIT(0)
#define		TV_DAC_CNTL_NHOLD	MASK_N_BIT(1)
#define		TV_DAC_CNTL_BGSLEEP	MASK_N_BIT(6)
#define		TV_DAC_CNTL_RDACPD	MASK_N_BIT(24)
#define		TV_DAC_CNTL_GDACPD	MASK_N_BIT(25)
#define		TV_DAC_CNTL_BDACPD	MASK_N_BIT(26)
#define TV_CRC_CNTL		0x0890
#define TV_UV_ADR		0x08ac

/*
 * ERT PLL registers
 */
#define TV_PLL_CNTL		0x21
#define TV_PLL_CNTL1		0x22
#define		TV_PLL_CNTL1_TVPLL_RESET	MASK_N_BIT(1)
#define		TV_PLL_CNTL1_TVPLL_SLEEP	MASK_N_BIT(3)
#define		TV_PLL_CNTL1_TVPDC_SHIFT	14
#define		TV_PLL_CNTL1_TVPDC_MASK		(3 << 14)
#define		TV_PLL_CNTL1_TVCLK_SRC_SEL	MASK_N_BIT(30)

/*
 * Constant upsampler coefficients
 */
static
const
CARD32 upsamplerCoeffs[] =
{
  0x3f010000,
  0x7b008002,
  0x00003f01,
  0x341b7405,
  0x7f3a7617,
  0x00003d04,
  0x2d296c0a,
  0x0e316c2c,
  0x00003e7d,
  0x2d1f7503,
  0x2927643b,
  0x0000056f,
  0x29257205,
  0x25295050,
  0x00000572
};
#define N_UPSAMPLER_COEFFS	(sizeof(upsamplerCoeffs) / sizeof(upsamplerCoeffs[ 0 ]))

/*
 * Maximum length of horizontal/vertical code timing tables for state storage
 */
#define MAX_H_CODE_TIMING_LEN	32
#define MAX_V_CODE_TIMING_LEN	32

/*
 * Type of VIP bus
 */
#define VIP_TYPE	"ATI VIP BUS"

/*
 * Limits of h/v positions (hPos & vPos in TheaterOutRec)
 */
#define MAX_H_POSITION		5	/* Range: [-5..5], negative is on the left, 0 is default, positive is on the right */
#define MAX_V_POSITION		5	/* Range: [-5..5], negative is up, 0 is default, positive is down */

/*
 * Unit for hPos (in TV clock periods)
 */
#define H_POS_UNIT		10

/*
 * Indexes in h. code timing table for horizontal line position adjustment
 */
#define H_TABLE_POS1		6
#define H_TABLE_POS2		8

/*
 * Limits of hor. size (hSize in TheaterOutRec)
 */
#define MAX_H_SIZE		5	/* Range: [-5..5], negative is smaller, positive is larger */

/**********************************************************************
 *
 * TimingTableEl
 *
 * Elements of H/V code timing tables
 *
 **********************************************************************/

typedef CARD16 TimingTableEl;	/* Bits 0 to 13 only are actually used */

/**********************************************************************
 *
 * ModeConstants
 *
 * Storage of constants related to a single video mode
 *
 **********************************************************************/

typedef struct
{
  CARD16 horResolution;	
  CARD16 verResolution;
  TVStd  standard;
  CARD16 horTotal;
  CARD16 verTotal;
  CARD16 horStart;
  CARD16 horSyncStart;
  CARD16 verSyncStart;
  unsigned defRestart;
  CARD32 vScalerCntl1;
  CARD32 yRiseCntl;
  CARD32 ySawtoothCntl;
  CARD16 crtcPLL_N;
  CARD8  crtcPLL_M;
  Bool   crtcPLL_divBy2;
  CARD8  crtcPLL_byteClkDiv;
  CARD8	 crtcPLL_postDiv;
  Bool   use888RGB;		/* False: RGB data is 565 packed (2 bytes/pixel) */
				/* True : RGB data is 888 packed (3 bytes/pixel) */
  unsigned pixToTV;
  CARD8	 byteClkDelay;
  CARD32 tvoDataDelayA;
  CARD32 tvoDataDelayB;
  const TimingTableEl *horTimingTable;
  const TimingTableEl *verTimingTable;
} ModeConstants;

/**********************************************************************
 *
 * TheaterState
 *
 * Storage of RT state
 *
 **********************************************************************/

typedef struct
{
  CARD32 clkout_cntl;
  CARD32 clock_sel_cntl;
  CARD32 crc_cntl;
  CARD32 crt_pll_cntl;
  CARD32 dfrestart;
  CARD32 dhrestart;
  CARD32 dvrestart;
  CARD32 frame_lock_cntl;
  CARD32 gain_limit_settings;
  CARD32 hdisp;
  CARD32 hstart;
  CARD32 htotal;
  CARD32 hw_debug;
  CARD32 linear_gain_settings;
  CARD32 master_cntl;
  CARD32 modulator_cntl1;
  CARD32 modulator_cntl2;
  CARD32 pll_cntl0;
  CARD32 pll_test_cntl;
  CARD32 pre_dac_mux_cntl;
  CARD32 rgb_cntl;
  CARD32 sync_cntl;
  CARD32 sync_lock_cntl;
  CARD32 sync_size;
  CARD32 timing_cntl;
  CARD32 tvo_data_delay_a;
  CARD32 tvo_data_delay_b;
  CARD32 tvo_sync_pat_expect;
  CARD32 tvo_sync_threshold;
  CARD32 tv_dac_cntl;
  CARD32 tv_pll_cntl;
  CARD32 tv_pll_fine_cntl;
  CARD32 upsamp_and_gain_cntl;
  CARD32 upsamp_coeffs[ N_UPSAMPLER_COEFFS ];
  CARD32 uv_adr;
  CARD32 vdisp;
  CARD32 vftotal;
  CARD32 vscaler_cntl1;
  CARD32 vscaler_cntl2;
  CARD32 vtotal;
  CARD32 y_fall_cntl;
  CARD32 y_rise_cntl;
  CARD32 y_saw_tooth_cntl;
  CARD32 disp_merge_cntl;

  TimingTableEl h_code_timing[ MAX_H_CODE_TIMING_LEN ];
  TimingTableEl v_code_timing[ MAX_V_CODE_TIMING_LEN ];
} TheaterState , *TheaterStatePtr;

/**********************************************************************
 *
 * TheaterOutRec , TheaterOutPtr
 *
 * Global state of module
 *
 **********************************************************************/

typedef struct TheaterOut
{
  GENERIC_BUS_Ptr VIP;
  unsigned char   *MMIO;

  int theatre_num;	/* Negative when driving an ERT */
			/* Positive or null: index of RT on VIP bus */
  
  TVStd standard;
  Bool compatibleMode;

  const ModeConstants *currentMode;
    
  int hPos;
  int vPos;
  int hSize;

  TheaterState savedState;
  TheaterState modeState;
} TheaterOutRec;

/**********************************************************************
 *
 * TVConstants
 *
 * Constants that depend on tv standard only
 *
 **********************************************************************/

typedef struct
{
  CARD8  tvPLL_M;
  CARD16 tvPLL_N;
  CARD8  tvPLL_postDiv;
  CARD32 tvClockT;	/* Period of TV clock (unit = 100 psec) */
  CARD32 modulatorCntl1;
  CARD32 modulatorCntl2;
  CARD32 vip_tvDAC_Cntl;
  CARD32 ert_tvDAC_Cntl;
  CARD32 vftotal;
  unsigned linesFrame;
  unsigned zeroHSize;	/* Length of the picture part of a hor. line for hSize = 0 (unit = 100 psec) */
  unsigned hSizeUnit;	/* Value of hSize = 1 (unit = 100 psec) */
} TVConstants;

/**********************************************************************
 *
 * tvStdConsts
 *
 * Table of constants for tv standards (index is a TVStd)
 *
 **********************************************************************/

static
const
TVConstants tvStdConsts[] =
  {
    /*
     * NTSC
     */
    {
      22,	/* tvPLL_M */
      175,	/* tvPLL_N */
      5,	/* tvPLL_postDiv */
      233,	/* tvClockT */
      0x60bb468c, /* modulatorCntl1 */
      0x00000191, /* modulatorCntl2 */
      0x00000113, /* vip_tvDAC_Cntl */
      0x00680113, /* ert_tvDAC_Cntl */
      1,	/* vftotal */
      525,	/* linesFrame */
      479166,	/* zeroHSize */
      9478	/* hSizeUnit */
    },
    /*
     * PAL
     */
    {
      113,	/* tvPLL_M */
      668,	/* tvPLL_N */
      3,	/* tvPLL_postDiv */
      188,	/* tvClockT */
      0x60bb3bcc, /* modulatorCntl1 */
      0x003e01b2, /* modulatorCntl2 */
      0x00000013, /* vip_tvDAC_Cntl */
      0x00680013, /* ert_tvDAC_Cntl */
      3,	/* vftotal */
      625,	/* linesFrame */
      473200,	/* zeroHSize */
      9360	/* hSizeUnit */
    }
  };

/**********************************************************************
 *
 * availableModes
 *
 * Table of all allowed modes for tv output
 *
 **********************************************************************/

static
const
TimingTableEl horTimingNTSC_BIOS[] =
  {
    0x0007,
    0x003f,
    0x0263,
    0x0a24,
    0x2a6b,
    0x0a36,
    0x126d,	/* H_TABLE_POS1 */
    0x1bfe,
    0x1a8f,	/* H_TABLE_POS2 */
    0x1ec7,
    0x3863,
    0x1bfe,
    0x1bfe,
    0x1a2a,
    0x1e95,
    0x0e31,
    0x201b,
    0
  };

static
const
TimingTableEl verTimingNTSC_BIOS[] =
  {
    0x2001,
    0x200d,
    0x1006,
    0x0c06,
    0x1006,
    0x1818,
    0x21e3,
    0x1006,
    0x0c06,
    0x1006,
    0x1817,
    0x21d4,
    0x0002,
    0
  };

static
const
TimingTableEl horTimingPAL_BIOS[] =
  {
    0x0007,
    0x0058,
    0x027c,
    0x0a31,
    0x2a77,
    0x0a95,
    0x124f,	/* H_TABLE_POS1 */
    0x1bfe,
    0x1b22,	/* H_TABLE_POS2 */
    0x1ef9,
    0x387c,
    0x1bfe,
    0x1bfe,
    0x1b31,
    0x1eb5,
    0x0e43,
    0x201b,
    0
  };

static
const
TimingTableEl verTimingPAL_BIOS[] =
  {
    0x2001,
    0x200c,
    0x1005,
    0x0c05,
    0x1005,
    0x1401,
    0x1821,
    0x2240,
    0x1005,
    0x0c05,
    0x1005,
    0x1401,
    0x1822,
    0x2230,
    0x0002,
    0
  };

static
const
ModeConstants availableModes[] =
  {
    { 
      800,		/* horResolution */
      600,		/* verResolution */
      TV_STD_NTSC,	/* standard */
      990,		/* horTotal */
      740,		/* verTotal */
      813,		/* horStart */
      824,		/* horSyncStart */
      632,		/* verSyncStart */
      625592,		/* defRestart */
      0x0900b46b,	/* vScalerCntl1 */
      0x00012c00,	/* yRiseCntl */
      0x10002d1a,	/* ySawtoothCntl */
      592,		/* crtcPLL_N */
      91,		/* crtcPLL_M */
      TRUE,		/* crtcPLL_divBy2 */
      0,		/* crtcPLL_byteClkDiv */
      4,		/* crtcPLL_postDiv */
      FALSE,		/* use888RGB */
      1022,		/* pixToTV */
      1,		/* byteClkDelay */
      0x0a0b0907,	/* tvoDataDelayA */
      0x060a090a,	/* tvoDataDelayB */
      horTimingNTSC_BIOS,/* horTimingTable */
      verTimingNTSC_BIOS/* verTimingTable */
    },
    { 
      800,		/* horResolution */
      600,		/* verResolution */
      TV_STD_PAL,	/* standard */
      1144,		/* horTotal */
      706,		/* verTotal */
      812,		/* horStart */
      824,		/* horSyncStart */
      669,		/* verSyncStart */
      696700,		/* defRestart */
      0x09009097,	/* vScalerCntl1 */
      0x000007da,	/* yRiseCntl */
      0x10002426,	/* ySawtoothCntl */
      1382,		/* crtcPLL_N */
      231,		/* crtcPLL_M */
      TRUE,		/* crtcPLL_divBy2 */
      0,		/* crtcPLL_byteClkDiv */
      4,		/* crtcPLL_postDiv */
      FALSE,		/* use888RGB */
      759,		/* pixToTV */
      1,		/* byteClkDelay */
      0x0a0b0907,	/* tvoDataDelayA */
      0x060a090a,	/* tvoDataDelayB */
      horTimingPAL_BIOS,/* horTimingTable */
      verTimingPAL_BIOS	/* verTimingTable */
    }
  };

#define N_AVAILABLE_MODES	(sizeof(availableModes) / sizeof(availableModes[ 0 ]))

/**********************************************************************
 *
 * theatre_read
 *
 * Read from a RT register
 *
 **********************************************************************/

static 
Bool 
theatre_read(
	     TheaterOutPtr t,
	     CARD32 reg,
	     CARD32 *data
	     )
{
  if (t->theatre_num < 0)
    return FALSE;
  
  return t->VIP->read(t->VIP, ((t->theatre_num & 0x3) << 14) | reg , 4 , (CARD8*)data);
}

/**********************************************************************
 *
 * theatre_write
 *
 * Write to a RT register
 *
 **********************************************************************/

static
Bool 
theatre_write(
	      TheaterOutPtr t,
	      CARD32 reg,
	      CARD32 data
	      )
{
  if (t->theatre_num < 0)
    return FALSE;

  return t->VIP->write(t->VIP , ((t->theatre_num & 0x03) << 14) | reg , 4 , (CARD8*)&data);
}

/**********************************************************************
 *
 * ert_read
 *
 * Read from an ERT register
 *
 **********************************************************************/

static 
void 
ert_read(
	 TheaterOutPtr t,
	 CARD32 reg,
	 CARD32 *data
	 )
{
  unsigned char *RADEONMMIO = t->MMIO;

  if (t->theatre_num < 0)
    *data = INREG(reg);
}

/**********************************************************************
 *
 * ert_write
 *
 * Write to an ERT register
 *
 **********************************************************************/
static
void 
ert_write(
	  TheaterOutPtr t,
	  CARD32 reg,
	  CARD32 data
	  )
{
  unsigned char *RADEONMMIO = t->MMIO;

  if (t->theatre_num < 0)
    OUTREG(reg , data);
}

/**********************************************************************
 *
 * waitPLL_lock
 *
 * Wait for PLLs to lock
 *
 **********************************************************************/

static
void
waitPLL_lock(
	     TheaterOutPtr t,
	     ScrnInfoPtr pScrn,
	     unsigned nTests,
	     unsigned nWaitLoops,
	     unsigned cntThreshold
	     )
{
  unsigned char *RADEONMMIO = t->MMIO;
  CARD32 savePLLTest;
  unsigned i;
  unsigned j;

  OUTREG(RADEON_TEST_DEBUG_MUX , (INREG(RADEON_TEST_DEBUG_MUX) & 0xffff60ff) | 0x100);

  savePLLTest = INPLL(pScrn , RADEON_PLL_TEST_CNTL);

  OUTPLL(pScrn , RADEON_PLL_TEST_CNTL , savePLLTest & ~RADEON_PLL_TEST_CNTL_PLL_MASK_READ_B);

  OUTREG8(RADEON_CLOCK_CNTL_INDEX , RADEON_PLL_TEST_CNTL);

  for (i = 0; i < nTests; i++)
    {
      OUTREG8(RADEON_CLOCK_CNTL_DATA + 3 , 0);
      
      for (j = 0; j < nWaitLoops; j++)
	if (INREG8(RADEON_CLOCK_CNTL_DATA + 3) >= cntThreshold)
	  break;
    }

  OUTPLL(pScrn , RADEON_PLL_TEST_CNTL , savePLLTest);

  OUTREG(RADEON_TEST_DEBUG_MUX , INREG(RADEON_TEST_DEBUG_MUX) & 0xffffe0ff);
}

/**********************************************************************
 *
 * restorePLL
 *
 * Set PLLs for CRTC pixel clock & TV color burst generation
 *
 **********************************************************************/

static
void
restorePLL(
	   TheaterOutPtr t,
	   ScrnInfoPtr pScrn,
	   TheaterStatePtr restore
	   )
{
  unsigned i;

  /*
   * Set TV PLL
   */
  RTTRACE(("restorePLL: TV_PLL_CNTL = %08x\n" , restore->tv_pll_cntl));
  theatre_write(t , VIP_TV_PLL_CNTL , restore->tv_pll_cntl);
  theatre_write(t , VIP_TV_PLL_FINE_CNTL , restore->tv_pll_fine_cntl);

  /*
   * Set CRT PLL (for byte and pixel clock generation)
   */
  RTTRACE(("restorePLL: CRT_PLL_CNTL = %08x\n" , restore->crt_pll_cntl));
  theatre_write(t , VIP_CRT_PLL_CNTL , restore->crt_pll_cntl);
  
  theatre_write(t , VIP_PLL_CNTL0 , restore->pll_cntl0);

  theatre_write(t , VIP_PLL_TEST_CNTL , restore->pll_test_cntl);

  /*
   * Set coefficients for upsampler
   */
  for (i = 0; i < N_UPSAMPLER_COEFFS; i++)
    theatre_write(t , VIP_UPSAMP_COEFF0_0 + i * 4 , restore->upsamp_coeffs[ i ]);

  /*
   * Waiting for PLLs to settle is skipped when restoring a state with stopped PLLs
   */
  if ((~restore->pll_cntl0 & (VIP_PLL_CNTL0_TVSLEEPB | VIP_PLL_CNTL0_CRTSLEEPB)) == 0)
    {
      waitPLL_lock(t , pScrn , 3000 , 160 , 27);

      theatre_write(t , VIP_CLOCK_SEL_CNTL , restore->clock_sel_cntl & ~VIP_CLOCK_SEL_CNTL_REGCLK);

      waitPLL_lock(t , pScrn , 3000 , 160 , 27);
    }

  RTTRACE(("restorePLL: CLOCK_SEL_CNTL = %08x\n" , restore->clock_sel_cntl));
  theatre_write(t , VIP_CLOCK_SEL_CNTL , restore->clock_sel_cntl);

  theatre_write(t , VIP_CLKOUT_CNTL , restore->clkout_cntl);
}

/**********************************************************************
 *
 * restoreTVO_SYNC
 *
 * Set TVO_SYNC_* registers
 *
 **********************************************************************/

static
void
restoreTVO_SYNC(
		TheaterOutPtr t,
		TheaterStatePtr restore
		)
{
  theatre_write(t , VIP_SYNC_LOCK_CNTL , restore->sync_lock_cntl);
  theatre_write(t , VIP_TVO_SYNC_THRESHOLD , restore->tvo_sync_threshold);
  theatre_write(t , VIP_TVO_SYNC_PAT_EXPECT , restore->tvo_sync_pat_expect);
}

/**********************************************************************
 *
 * restoreTVO_DataDelay
 *
 * Set TVO_DATA_DELAY_* registers
 *
 **********************************************************************/

static
void
restoreTVO_DataDelay(
		     TheaterOutPtr t,
		     TheaterStatePtr restore
		     )
{
  theatre_write(t , VIP_TVO_DATA_DELAY_A , restore->tvo_data_delay_a);
  theatre_write(t , VIP_TVO_DATA_DELAY_B , restore->tvo_data_delay_b);
}

/**********************************************************************
 *
 * restoreRT_HV
 *
 * Set RT horizontal/vertical settings
 *
 **********************************************************************/

static
void
restoreRT_HV(
	     TheaterOutPtr t,
	     TheaterStatePtr restore
	     )
{
  theatre_write(t , VIP_RGB_CNTL , restore->rgb_cntl);

  theatre_write(t , VIP_HTOTAL , restore->htotal);
  theatre_write(t , VIP_HDISP  , restore->hdisp);
  theatre_write(t , VIP_HSTART , restore->hstart);
  
  theatre_write(t , VIP_VTOTAL , restore->vtotal);
  theatre_write(t , VIP_VDISP  , restore->vdisp);
  
  theatre_write(t , VIP_VFTOTAL , restore->vftotal);

  theatre_write(t , VIP_SYNC_SIZE , restore->sync_size);

  theatre_write(t , VIP_VSCALER_CNTL1 , restore->vscaler_cntl1);
  theatre_write(t , VIP_VSCALER_CNTL2 , restore->vscaler_cntl2);
  
  theatre_write(t , VIP_Y_FALL_CNTL , restore->y_fall_cntl);
  theatre_write(t , VIP_Y_RISE_CNTL , restore->y_rise_cntl);
  theatre_write(t , VIP_Y_SAW_TOOTH_CNTL , restore->y_saw_tooth_cntl);
}

/**********************************************************************
 *
 * restoreRestarts
 *
 * Set RT D*RESTART registers
 *
 **********************************************************************/

static
void
restoreRestarts(	 
		TheaterOutPtr t,
		TheaterStatePtr restore
		)
{
  theatre_write(t , VIP_DFRESTART , restore->dfrestart);
  theatre_write(t , VIP_DHRESTART , restore->dhrestart);
  theatre_write(t , VIP_DVRESTART , restore->dvrestart);
}

/**********************************************************************
 *
 * writeFIFO
 *
 * Write to RT FIFO RAM
 *
 **********************************************************************/

static
void
writeFIFO(
	  TheaterOutPtr t,
	  CARD16 addr,
	  CARD32 value
	  )
{
  CARD32 tmp;

  if (t->theatre_num >= 0)
    {
      theatre_write(t , VIP_HOST_WRITE_DATA , value);

      theatre_write(t , VIP_HOST_RD_WT_CNTL , addr | VIP_HOST_RD_WT_CNTL_WT);

      do
	{
	  if (!theatre_read(t , VIP_HOST_RD_WT_CNTL , &tmp))
	    break;
	} 
      while ((tmp & VIP_HOST_RD_WT_CNTL_WT_ACK) == 0);

      theatre_write(t , VIP_HOST_RD_WT_CNTL , 0);
    }
  else
    {
      ert_write(t , TV_HOST_WRITE_DATA , value);

      ert_write(t , TV_HOST_RD_WT_CNTL , addr | VIP_HOST_RD_WT_CNTL_WT);

      do
	{
	  ert_read(t , TV_HOST_RD_WT_CNTL , &tmp);
	} 
      while ((tmp & VIP_HOST_RD_WT_CNTL_WT_ACK) == 0);

      ert_write(t , TV_HOST_RD_WT_CNTL , 0);
    }
}

/**********************************************************************
 *
 * readFIFO
 *
 * Read from RT FIFO RAM
 *
 **********************************************************************/

static
void
readFIFO(
	 TheaterOutPtr t,
	 CARD16 addr,
	 CARD32 *value
	 )
{
  CARD32 tmp;
  
  if (t->theatre_num >= 0)
    {
      theatre_write(t , VIP_HOST_RD_WT_CNTL , addr | VIP_HOST_RD_WT_CNTL_RD);

      do
	{
	  if (!theatre_read(t , VIP_HOST_RD_WT_CNTL , &tmp))
	    break;
	} 
      while ((tmp & VIP_HOST_RD_WT_CNTL_RD_ACK) == 0);

      theatre_write(t , VIP_HOST_RD_WT_CNTL , 0);

      theatre_read(t , VIP_HOST_READ_DATA , value);
    }
  else
    {
      ert_write(t , TV_HOST_RD_WT_CNTL , addr | VIP_HOST_RD_WT_CNTL_RD);

      do
	{
	  ert_read(t , TV_HOST_RD_WT_CNTL , &tmp);
	} 
      while ((tmp & VIP_HOST_RD_WT_CNTL_RD_ACK) == 0);

      ert_write(t , TV_HOST_RD_WT_CNTL , 0);

      ert_read(t , TV_HOST_READ_DATA , value);
    }
}

/**********************************************************************
 *
 * getTimingTablesAddr
 *
 * Get FIFO addresses of horizontal & vertical code timing tables from
 * settings of uv_adr register.
 *
 **********************************************************************/

static
void
getTimingTablesAddr(
		    CARD32 uv_adr,
		    Bool isERT,
		    CARD16 *hTable,
		    CARD16 *vTable
		    )
{
  switch ((uv_adr & VIP_UV_ADR_HCODE_TABLE_SEL) >> VIP_UV_ADR_HCODE_TABLE_SEL_SHIFT)
    {
    case 0:
      *hTable = isERT ? MAX_FIFO_ADDR_ERT : MAX_FIFO_ADDR_RT;
      break;

    case 1:
      *hTable = ((uv_adr & VIP_UV_ADR_TABLE1_BOT_ADR) >> VIP_UV_ADR_TABLE1_BOT_ADR_SHIFT) * 2;
      break;

    case 2:
      *hTable = ((uv_adr & VIP_UV_ADR_TABLE3_TOP_ADR) >> VIP_UV_ADR_TABLE3_TOP_ADR_SHIFT) * 2;
      break;

    default:
      /*
       * Of course, this should never happen
       */
      *hTable = 0;
      break;
    }

  switch ((uv_adr & VIP_UV_ADR_VCODE_TABLE_SEL) >> VIP_UV_ADR_VCODE_TABLE_SEL_SHIFT)
    {
    case 0:
      *vTable = ((uv_adr & VIP_UV_ADR_MAX_UV_ADR) >> VIP_UV_ADR_MAX_UV_ADR_SHIFT) * 2 + 1;
      break;

    case 1:
      *vTable = ((uv_adr & VIP_UV_ADR_TABLE1_BOT_ADR) >> VIP_UV_ADR_TABLE1_BOT_ADR_SHIFT) * 2 + 1;
      break;

    case 2:
      *vTable = ((uv_adr & VIP_UV_ADR_TABLE3_TOP_ADR) >> VIP_UV_ADR_TABLE3_TOP_ADR_SHIFT) * 2 + 1;
      break;

    default:
      /*
       * Of course, this should never happen
       */
      *vTable = 0;
      break;
    }
}

/**********************************************************************
 *
 * saveTimingTables
 *
 * Save horizontal/vertical timing code tables
 *
 **********************************************************************/
static
void
saveTimingTables(
		 TheaterOutPtr t,
		 TheaterStatePtr save
		 )
{
  CARD16 hTable;
  CARD16 vTable;
  CARD32 tmp;
  unsigned i;

  if (t->theatre_num >= 0)
    {
      theatre_read(t , VIP_UV_ADR , &save->uv_adr);
      getTimingTablesAddr(save->uv_adr , FALSE , &hTable , &vTable);
    }
  else
    {
      ert_read(t , TV_UV_ADR , &save->uv_adr);
      getTimingTablesAddr(save->uv_adr , TRUE , &hTable , &vTable);
    }

  /*
   * Reset FIFO arbiter in order to be able to access FIFO RAM
   */
  if (t->theatre_num >= 0)
    {
      theatre_write(t , 
		    VIP_MASTER_CNTL , 
		    save->master_cntl | 
		    VIP_MASTER_CNTL_CRT_ASYNC_RST |
		    VIP_MASTER_CNTL_TV_FIFO_ASYNC_RST |
		    VIP_MASTER_CNTL_TV_ASYNC_RST);
      theatre_write(t , 
		    VIP_MASTER_CNTL , 
		    save->master_cntl |
		    VIP_MASTER_CNTL_TV_ASYNC_RST |
		    VIP_MASTER_CNTL_CRT_ASYNC_RST);
    }
  else
    {
      ert_write(t , 
		TV_MASTER_CNTL , 
		save->master_cntl | TV_MASTER_CNTL_TV_ON);
    }

  RTTRACE(("saveTimingTables: reading timing tables\n"));

  for (i = 0; i < MAX_H_CODE_TIMING_LEN; i += 2)
    {
      readFIFO(t , hTable-- , &tmp);
      save->h_code_timing[ i     ] = (CARD16)((tmp >> 14) & 0x3fff);
      save->h_code_timing[ i + 1 ] = (CARD16)(tmp & 0x3fff);

      if (save->h_code_timing[ i ] == 0 || save->h_code_timing[ i + 1 ] == 0)
	break;
    }

  for (i = 0; i < MAX_V_CODE_TIMING_LEN; i += 2)
    {
      readFIFO(t , vTable++ , &tmp);
      save->v_code_timing[ i     ] = (CARD16)(tmp & 0x3fff);
      save->v_code_timing[ i + 1 ] = (CARD16)((tmp >> 14) & 0x3fff);

      if (save->v_code_timing[ i ] == 0 || save->v_code_timing[ i + 1 ] == 0)
	break;
    }
}
		 
/**********************************************************************
 *
 * restoreTimingTables
 *
 * Load horizontal/vertical timing code tables
 *
 **********************************************************************/

static
void
restoreTimingTables(
		    TheaterOutPtr t,
		    TheaterStatePtr restore
		    )
{
  CARD16 hTable;
  CARD16 vTable;
  CARD32 tmp;
  unsigned i;

  if (t->theatre_num >= 0)
    {
      theatre_write(t , VIP_UV_ADR , restore->uv_adr);
      getTimingTablesAddr(restore->uv_adr , FALSE , &hTable , &vTable);
    }
  else
    {
      ert_write(t , TV_UV_ADR , restore->uv_adr);
      getTimingTablesAddr(restore->uv_adr , TRUE , &hTable , &vTable);
    }

  for (i = 0; i < MAX_H_CODE_TIMING_LEN; i += 2 , hTable--)
    {
      tmp = ((CARD32)restore->h_code_timing[ i ] << 14) | ((CARD32)restore->h_code_timing[ i + 1 ]);
      writeFIFO(t , hTable , tmp);
      if (restore->h_code_timing[ i ] == 0 || restore->h_code_timing[ i + 1 ] == 0)
	break;
    }

  for (i = 0; i < MAX_V_CODE_TIMING_LEN; i += 2 , vTable++)
    {
      tmp = ((CARD32)restore->v_code_timing[ i + 1 ] << 14) | ((CARD32)restore->v_code_timing[ i ]);
      writeFIFO(t , vTable , tmp);
      if (restore->v_code_timing[ i ] == 0 || restore->v_code_timing[ i + 1 ] == 0)
	break;
    }
}

/**********************************************************************
 *
 * restoreOutputStd
 *
 * Set tv standard & output muxes
 *
 **********************************************************************/

static
void
restoreOutputStd(
		 TheaterOutPtr t,
		 TheaterStatePtr restore
		 )
{
  theatre_write(t , VIP_SYNC_CNTL , restore->sync_cntl);
  
  theatre_write(t , VIP_TIMING_CNTL , restore->timing_cntl);

  theatre_write(t , VIP_MODULATOR_CNTL1 , restore->modulator_cntl1);
  theatre_write(t , VIP_MODULATOR_CNTL2 , restore->modulator_cntl2);
 
  theatre_write(t , VIP_PRE_DAC_MUX_CNTL , restore->pre_dac_mux_cntl);

  theatre_write(t , VIP_CRC_CNTL , restore->crc_cntl);

  theatre_write(t , VIP_FRAME_LOCK_CNTL , restore->frame_lock_cntl);

  theatre_write(t , VIP_HW_DEBUG , restore->hw_debug);
}

/**********************************************************************
 *
 * enableTV_DAC
 *
 * Enable/disable tv output DAC
 *
 **********************************************************************/

static
void
enableTV_DAC(
	     TheaterOutPtr t,
	     Bool enable
	     )
{
  CARD32 tmp;

  theatre_read(t , VIP_TV_DAC_CNTL , &tmp);

  if (enable)
    {
      tmp |= VIP_TV_DAC_CNTL_NBLANK;
      tmp &= ~VIP_TV_DAC_CNTL_DASLEEP;
      tmp &= ~VIP_TV_DAC_CNTL_BGSLEEP;
    }
  else
    {
      tmp &= ~VIP_TV_DAC_CNTL_NBLANK;
      tmp |= VIP_TV_DAC_CNTL_DASLEEP;
      tmp |= VIP_TV_DAC_CNTL_BGSLEEP;
    }

  theatre_write(t , VIP_TV_DAC_CNTL , tmp);
}

/**********************************************************************
 *
 * ERT_RestorePLL
 *
 * Set ERT PLLs
 *
 **********************************************************************/
static
void
ERT_RestorePLL(
	       TheaterOutPtr t,
	       ScrnInfoPtr pScrn,
	       TheaterStatePtr restore
	       )
{
  unsigned char *RADEONMMIO = t->MMIO;

  OUTPLLP(pScrn , TV_PLL_CNTL1 , 0 , ~TV_PLL_CNTL1_TVCLK_SRC_SEL);
  OUTPLL(pScrn , TV_PLL_CNTL , restore->tv_pll_cntl);
  OUTPLLP(pScrn , TV_PLL_CNTL1 , TV_PLL_CNTL1_TVPLL_RESET , ~TV_PLL_CNTL1_TVPLL_RESET);

  waitPLL_lock(t , pScrn , 200 , 800 , 135);
  
  OUTPLLP(pScrn , TV_PLL_CNTL1 , 0 , ~TV_PLL_CNTL1_TVPLL_RESET);

  waitPLL_lock(t , pScrn , 300 , 160 , 27);
  waitPLL_lock(t , pScrn , 200 , 800 , 135);
  
  OUTPLLP(pScrn , TV_PLL_CNTL1 , 0 , ~0xf);
  OUTPLLP(pScrn , TV_PLL_CNTL1 , TV_PLL_CNTL1_TVCLK_SRC_SEL , ~TV_PLL_CNTL1_TVCLK_SRC_SEL);
  
  OUTPLLP(pScrn , TV_PLL_CNTL1 , (1 << TV_PLL_CNTL1_TVPDC_SHIFT) , ~TV_PLL_CNTL1_TVPDC_MASK);
  OUTPLLP(pScrn , TV_PLL_CNTL1 , 0 , ~TV_PLL_CNTL1_TVPLL_SLEEP);
}

/**********************************************************************
 *
 * ERT_RestoreHV
 *
 * Set ERT horizontal/vertical settings
 *
 **********************************************************************/

static
void
ERT_RestoreHV(
	      TheaterOutPtr t,
	      TheaterStatePtr restore
	      )
{
  ert_write(t , TV_RGB_CNTL , restore->rgb_cntl);

  ert_write(t , TV_HTOTAL , restore->htotal);
  ert_write(t , TV_HDISP  , restore->hdisp);
  ert_write(t , TV_HSTART , restore->hstart);

  ert_write(t , TV_VTOTAL , restore->vtotal);
  ert_write(t , TV_VDISP  , restore->vdisp);

  ert_write(t , TV_FTOTAL , restore->vftotal);

  ert_write(t , TV_VSCALER_CNTL1 , restore->vscaler_cntl1);
  ert_write(t , TV_VSCALER_CNTL2 , restore->vscaler_cntl2);

  ert_write(t , TV_Y_FALL_CNTL , restore->y_fall_cntl);
  ert_write(t , TV_Y_RISE_CNTL , restore->y_rise_cntl);
  ert_write(t , TV_Y_SAWTOOTH_CNTL , restore->y_saw_tooth_cntl);
}

/**********************************************************************
 *
 * ERT_RestoreRestarts
 *
 * Set ERT TV_*RESTART registers
 *
 **********************************************************************/

static
void
ERT_RestoreRestarts(	 
		    TheaterOutPtr t,
		    TheaterStatePtr restore
		    )
{
  ert_write(t , TV_FRESTART , restore->dfrestart);
  ert_write(t , TV_HRESTART , restore->dhrestart);
  ert_write(t , TV_VRESTART , restore->dvrestart);
}

/**********************************************************************
 *
 * ERT_RestoreOutputStd
 *
 * Set tv standard & output muxes
 *
 **********************************************************************/
static
void
ERT_RestoreOutputStd(
		     TheaterOutPtr t,
		     TheaterStatePtr restore
		     )
{
  ert_write(t , TV_SYNC_CNTL , restore->sync_cntl);
  
  ert_write(t , TV_TIMING_CNTL , restore->timing_cntl);

  ert_write(t , TV_MODULATOR_CNTL1 , restore->modulator_cntl1);
  ert_write(t , TV_MODULATOR_CNTL2 , restore->modulator_cntl2);
 
  ert_write(t , TV_PRE_DAC_MUX_CNTL , restore->pre_dac_mux_cntl);

  ert_write(t , TV_CRC_CNTL , restore->crc_cntl);
}

/**********************************************************************
 *
 * ERT_IsOn
 *
 * Test if tv output would be enabled with a given value in TV_DAC_CNTL
 *
 **********************************************************************/
static
Bool
ERT_IsOn(
	 CARD32 tv_dac_cntl
	 )
{
  if (tv_dac_cntl & TV_DAC_CNTL_BGSLEEP)
    return FALSE;
  else if ((tv_dac_cntl & (TV_DAC_CNTL_RDACPD | TV_DAC_CNTL_GDACPD | TV_DAC_CNTL_BDACPD)) ==
	   (TV_DAC_CNTL_RDACPD | TV_DAC_CNTL_GDACPD | TV_DAC_CNTL_BDACPD))
    return FALSE;
  else
    return TRUE;
}

/**********************************************************************
 *
 * ERT_Restore
 *
 * Restore state of ERT
 *
 **********************************************************************/
static
void
ERT_Restore(
	    TheaterOutPtr t,
	    ScrnInfoPtr pScrn,
	    TheaterStatePtr restore
	    )
{
  RTTRACE(("Entering ERT_Restore\n"));

  ert_write(t , 
	    TV_MASTER_CNTL , 
	    restore->master_cntl | TV_MASTER_CNTL_TV_ON);

  ert_write(t,
	    TV_MASTER_CNTL ,
	    restore->master_cntl | 
	    VIP_MASTER_CNTL_TV_ASYNC_RST |
	    VIP_MASTER_CNTL_CRT_ASYNC_RST |
	    VIP_MASTER_CNTL_RESTART_PHASE_FIX |
	    VIP_MASTER_CNTL_TV_FIFO_ASYNC_RST);

  /*
   * Temporarily turn the TV DAC off
   */
  ert_write(t ,
	    TV_DAC_CNTL ,
	    (restore->tv_dac_cntl & ~TV_DAC_CNTL_NBLANK) |
	    TV_DAC_CNTL_BGSLEEP |
	    TV_DAC_CNTL_RDACPD |
	    TV_DAC_CNTL_GDACPD |
	    TV_DAC_CNTL_BDACPD);

  RTTRACE(("ERT_Restore: checkpoint 1\n"));
  ERT_RestorePLL(t , pScrn , restore);

  RTTRACE(("ERT_Restore: checkpoint 2\n"));
  ERT_RestoreHV(t , restore);

  ert_write(t,
	    TV_MASTER_CNTL ,
	    restore->master_cntl | 
	    VIP_MASTER_CNTL_TV_ASYNC_RST |
	    VIP_MASTER_CNTL_CRT_ASYNC_RST |
	    VIP_MASTER_CNTL_RESTART_PHASE_FIX);

  RTTRACE(("ERT_Restore: checkpoint 3\n"));
  ERT_RestoreRestarts(t , restore);
  
  RTTRACE(("ERT_Restore: checkpoint 4\n"));

  /*
   * Timing tables are only restored when tv output is active
   */
  if (ERT_IsOn(restore->tv_dac_cntl))
    restoreTimingTables(t , restore);
  
  ert_write(t,
	    TV_MASTER_CNTL ,
	    restore->master_cntl | 
	    VIP_MASTER_CNTL_TV_ASYNC_RST |
	    VIP_MASTER_CNTL_RESTART_PHASE_FIX);

  RTTRACE(("ERT_Restore: checkpoint 5\n"));
  ERT_RestoreOutputStd(t , restore);

  ert_write(t , 
	    TV_MASTER_CNTL , 
	    restore->master_cntl);

  ert_write(t , RADEON_DISP_MERGE_CNTL , restore->disp_merge_cntl);

  ert_write(t , TV_GAIN_LIMIT_SETTINGS , restore->gain_limit_settings);
  ert_write(t , TV_LINEAR_GAIN_SETTINGS , restore->linear_gain_settings);

  ert_write(t , TV_DAC_CNTL , restore->tv_dac_cntl);

  RTTRACE(("Leaving ERT_Restore\n"));
}

/**********************************************************************
 *
 * RT_Restore
 *
 * Restore state of RT
 *
 **********************************************************************/

static
void
RT_Restore(
	   TheaterOutPtr t,
	   ScrnInfoPtr pScrn,
	   TheaterStatePtr restore
	   )
{
  if (t->theatre_num < 0)
    {
      ERT_Restore(t , pScrn , restore);
      return;
    }

  RTTRACE(("Entering RT_Restore\n"));

  theatre_write(t , 
		VIP_MASTER_CNTL , 
		restore->master_cntl | 
		VIP_MASTER_CNTL_TV_ASYNC_RST |
		VIP_MASTER_CNTL_CRT_ASYNC_RST |
		VIP_MASTER_CNTL_TV_FIFO_ASYNC_RST);

  /*
   * Temporarily turn the TV DAC off
   */
  theatre_write(t ,
		VIP_TV_DAC_CNTL ,
		(restore->tv_dac_cntl & ~VIP_TV_DAC_CNTL_NBLANK) |
		VIP_TV_DAC_CNTL_DASLEEP | 
		VIP_TV_DAC_CNTL_BGSLEEP);

  RTTRACE(("RT_Restore: checkpoint 1\n"));
  restoreTVO_SYNC(t , restore);

  RTTRACE(("RT_Restore: checkpoint 2\n"));
  restorePLL(t , pScrn , restore);

  RTTRACE(("RT_Restore: checkpoint 3\n"));
  restoreTVO_DataDelay(t , restore);

  RTTRACE(("RT_Restore: checkpoint 4\n"));
  restoreRT_HV(t , restore);
  
  theatre_write(t , 
		VIP_MASTER_CNTL , 
		restore->master_cntl |
		VIP_MASTER_CNTL_TV_ASYNC_RST |
		VIP_MASTER_CNTL_CRT_ASYNC_RST);

  RTTRACE(("RT_Restore: checkpoint 5\n"));
  restoreRestarts(t , restore);

  RTTRACE(("RT_Restore: checkpoint 6\n"));

  /*
   * Timing tables are restored when tv output is active
   */
  if ((restore->tv_dac_cntl & (VIP_TV_DAC_CNTL_DASLEEP | VIP_TV_DAC_CNTL_BGSLEEP)) == 0)
    restoreTimingTables(t , restore);
  
  theatre_write(t , 
		VIP_MASTER_CNTL , 
		restore->master_cntl |
		VIP_MASTER_CNTL_TV_ASYNC_RST);

  RTTRACE(("RT_Restore: checkpoint 7\n"));
  restoreOutputStd(t , restore);

  theatre_write(t , 
		VIP_MASTER_CNTL , 
		restore->master_cntl);

  theatre_write(t , VIP_GAIN_LIMIT_SETTINGS , restore->gain_limit_settings);
  theatre_write(t , VIP_LINEAR_GAIN_SETTINGS , restore->linear_gain_settings);

  theatre_write(t , VIP_TV_DAC_CNTL , restore->tv_dac_cntl);

  RTTRACE(("Leaving RT_Restore\n"));
}

/**********************************************************************
 *
 * RT_Save
 *
 * Save state of RT
 *
 **********************************************************************/

static
void
RT_Save(
	TheaterOutPtr t,
	ScrnInfoPtr pScrn,
	TheaterStatePtr save
	)
{
  unsigned i;

  RTTRACE(("Entering RT_Save\n"));

  if (t->theatre_num >= 0)
    {
      theatre_read(t , VIP_CLKOUT_CNTL         , &save->clkout_cntl);
      theatre_read(t , VIP_CLOCK_SEL_CNTL      , &save->clock_sel_cntl);
      theatre_read(t , VIP_CRC_CNTL            , &save->crc_cntl);
      theatre_read(t , VIP_CRT_PLL_CNTL        , &save->crt_pll_cntl);
      theatre_read(t , VIP_DFRESTART           , &save->dfrestart);
      theatre_read(t , VIP_DHRESTART           , &save->dhrestart);
      theatre_read(t , VIP_DVRESTART           , &save->dvrestart);
      theatre_read(t , VIP_FRAME_LOCK_CNTL     , &save->frame_lock_cntl);
      theatre_read(t , VIP_GAIN_LIMIT_SETTINGS , &save->gain_limit_settings);
      theatre_read(t , VIP_HDISP               , &save->hdisp);
      theatre_read(t , VIP_HSTART              , &save->hstart);
      theatre_read(t , VIP_HTOTAL              , &save->htotal);
      theatre_read(t , VIP_HW_DEBUG            , &save->hw_debug);
      theatre_read(t , VIP_LINEAR_GAIN_SETTINGS, &save->linear_gain_settings);
      theatre_read(t , VIP_MASTER_CNTL         , &save->master_cntl);
      theatre_read(t , VIP_MODULATOR_CNTL1     , &save->modulator_cntl1);
      theatre_read(t , VIP_MODULATOR_CNTL2     , &save->modulator_cntl2);
      theatre_read(t , VIP_PLL_CNTL0           , &save->pll_cntl0);
      theatre_read(t , VIP_PLL_TEST_CNTL       , &save->pll_test_cntl);
      theatre_read(t , VIP_PRE_DAC_MUX_CNTL    , &save->pre_dac_mux_cntl);
      theatre_read(t , VIP_RGB_CNTL            , &save->rgb_cntl);
      theatre_read(t , VIP_SYNC_CNTL           , &save->sync_cntl);
      theatre_read(t , VIP_SYNC_LOCK_CNTL      , &save->sync_lock_cntl);
      theatre_read(t , VIP_SYNC_SIZE           , &save->sync_size);
      theatre_read(t , VIP_TIMING_CNTL         , &save->timing_cntl);
      theatre_read(t , VIP_TVO_DATA_DELAY_A    , &save->tvo_data_delay_a);
      theatre_read(t , VIP_TVO_DATA_DELAY_B    , &save->tvo_data_delay_b);
      theatre_read(t , VIP_TVO_SYNC_PAT_EXPECT , &save->tvo_sync_pat_expect);
      theatre_read(t , VIP_TVO_SYNC_THRESHOLD  , &save->tvo_sync_threshold);
      theatre_read(t , VIP_TV_DAC_CNTL         , &save->tv_dac_cntl);
      theatre_read(t , VIP_TV_PLL_CNTL         , &save->tv_pll_cntl);
      theatre_read(t , VIP_TV_PLL_FINE_CNTL    , &save->tv_pll_fine_cntl);
      theatre_read(t , VIP_UPSAMP_AND_GAIN_CNTL, &save->upsamp_and_gain_cntl);
      theatre_read(t , VIP_VDISP               , &save->vdisp);
      theatre_read(t , VIP_VFTOTAL             , &save->vftotal);
      theatre_read(t , VIP_VSCALER_CNTL1       , &save->vscaler_cntl1);
      theatre_read(t , VIP_VSCALER_CNTL2       , &save->vscaler_cntl2);
      theatre_read(t , VIP_VTOTAL              , &save->vtotal);
      theatre_read(t , VIP_Y_FALL_CNTL         , &save->y_fall_cntl);
      theatre_read(t , VIP_Y_RISE_CNTL         , &save->y_rise_cntl);
      theatre_read(t , VIP_Y_SAW_TOOTH_CNTL    , &save->y_saw_tooth_cntl);

      for (i = 0; i < N_UPSAMPLER_COEFFS; i++)
	theatre_read(t , VIP_UPSAMP_COEFF0_0 + i * 4 , &save->upsamp_coeffs[ i ]);

      /*
       * Read H/V code timing tables (current tables only are saved)
       * This step is skipped when tv output is disabled in current RT state
       * (see RT_Restore)
       */
      if ((save->tv_dac_cntl & (VIP_TV_DAC_CNTL_DASLEEP | VIP_TV_DAC_CNTL_BGSLEEP)) == 0)
	saveTimingTables(t , save);
    }
  else
    {
      /*
       * ERT
       */
      ert_read(t , TV_CRC_CNTL             , &save->crc_cntl);
      ert_read(t , TV_FRESTART             , &save->dfrestart);
      ert_read(t , TV_HRESTART             , &save->dhrestart);
      ert_read(t , TV_VRESTART             , &save->dvrestart);
      ert_read(t , TV_GAIN_LIMIT_SETTINGS  , &save->gain_limit_settings);
      ert_read(t , TV_HDISP                , &save->hdisp);
      ert_read(t , TV_HSTART               , &save->hstart);
      ert_read(t , TV_HTOTAL               , &save->htotal);
      ert_read(t , TV_LINEAR_GAIN_SETTINGS , &save->linear_gain_settings);
      ert_read(t , TV_MASTER_CNTL          , &save->master_cntl);
      ert_read(t , TV_RGB_CNTL             , &save->rgb_cntl);
      ert_read(t , TV_MODULATOR_CNTL1      , &save->modulator_cntl1);
      ert_read(t , TV_MODULATOR_CNTL2      , &save->modulator_cntl2);
      ert_read(t , TV_PRE_DAC_MUX_CNTL     , &save->pre_dac_mux_cntl);
      ert_read(t , TV_SYNC_CNTL            , &save->sync_cntl);
      ert_read(t , TV_TIMING_CNTL          , &save->timing_cntl);
      ert_read(t , TV_DAC_CNTL             , &save->tv_dac_cntl);
      ert_read(t , TV_UPSAMP_AND_GAIN_CNTL , &save->upsamp_and_gain_cntl);
      ert_read(t , TV_VDISP                , &save->vdisp);
      ert_read(t , TV_FTOTAL               , &save->vftotal);
      ert_read(t , TV_VSCALER_CNTL1        , &save->vscaler_cntl1);
      ert_read(t , TV_VSCALER_CNTL2        , &save->vscaler_cntl2);
      ert_read(t , TV_VTOTAL               , &save->vtotal);
      ert_read(t , TV_Y_FALL_CNTL          , &save->y_fall_cntl);
      ert_read(t , TV_Y_RISE_CNTL          , &save->y_rise_cntl);
      ert_read(t , TV_Y_SAWTOOTH_CNTL      , &save->y_saw_tooth_cntl);

      ert_read(t , RADEON_DISP_MERGE_CNTL  , &save->disp_merge_cntl);

      save->tv_pll_cntl = INPLL(pScrn , TV_PLL_CNTL);
      
      /*
       * Read H/V code timing tables (current tables only are saved)
       * This step is skipped when tv output is disabled in current RT state
       * (see RT_Restore)
       */
      if (ERT_IsOn(save->tv_dac_cntl))
	saveTimingTables(t , save);
    }


  RTTRACE(("RT_Save returning\n"));
}

/**********************************************************************
 *
 * computeRestarts
 *
 * Compute F,V,H restarts from default restart position and 
 * hPos & vPos
 * Return TRUE when code timing table was changed
 *
 **********************************************************************/

static
Bool
computeRestarts(
		const ModeConstants *constPtr,
		TVStd tvStd,
		int hPos,
		int vPos,
		int hSize,
		TheaterStatePtr save
		)
{
  int restart;
  const TVConstants *pTvStd = &tvStdConsts[ tvStd ];
  unsigned hTotal;
  unsigned vTotal;
  unsigned fTotal;
  int vOffset;
  int hOffset;
  TimingTableEl p1;
  TimingTableEl p2;
  Bool hChanged;
  CARD16 hInc;

  hTotal = constPtr->horTotal;
  vTotal = constPtr->verTotal;
  fTotal = pTvStd->vftotal + 1;

  /*
   * Adjust positions 1&2 in hor. code timing table
   */
  hOffset = hPos * H_POS_UNIT;

  p1 = constPtr->horTimingTable[ H_TABLE_POS1 ];
  p2 = constPtr->horTimingTable[ H_TABLE_POS2 ];

  p1 = (TimingTableEl)((int)p1 + hOffset);
  p2 = (TimingTableEl)((int)p2 - hOffset);

  hChanged = (p1 != save->h_code_timing[ H_TABLE_POS1 ] || 
	      p2 != save->h_code_timing[ H_TABLE_POS2 ]);

  save->h_code_timing[ H_TABLE_POS1 ] = p1;
  save->h_code_timing[ H_TABLE_POS2 ] = p2;

  /*
   * Convert hOffset from n. of TV clock periods to n. of CRTC clock periods (CRTC pixels)
   */
  hOffset = (hOffset * (int)(constPtr->pixToTV)) / 1000;

  /*
   * Adjust restart
   */
  restart = constPtr->defRestart;
 
  /*
   * Convert vPos TV lines to n. of CRTC pixels
   * Be verrrrry careful when mixing signed & unsigned values in C..
   */
  vOffset = ((int)(vTotal * hTotal) * 2 * vPos) / (int)(pTvStd->linesFrame);

  restart -= vOffset + hOffset;

  RTTRACE(("computeRestarts: def = %u, h = %d , v = %d , p1=%04x , p2=%04x , restart = %d\n" , constPtr->defRestart , hPos , vPos , p1 , p2 , restart));

  save->dhrestart = restart % hTotal;
  restart /= hTotal;
  save->dvrestart = restart % vTotal;
  restart /= vTotal;
  save->dfrestart = restart % fTotal;

  RTTRACE(("computeRestarts: F/H/V=%u,%u,%u\n" , save->dfrestart , save->dvrestart , save->dhrestart));

  /*
   * Compute H_INC from hSize
   */
  hInc = (CARD16)((int)(constPtr->horResolution * 4096 * pTvStd->tvClockT) / 
		  (hSize * (int)(pTvStd->hSizeUnit) + (int)(pTvStd->zeroHSize)));
  save->timing_cntl = (save->timing_cntl & ~VIP_TIMING_CNTL_H_INC) |
    ((CARD32)hInc << VIP_TIMING_CNTL_H_INC_SHIFT);

  RTTRACE(("computeRestarts: hSize=%d,hInc=%u\n" , hSize , hInc));

  return hChanged;
}

/**********************************************************************
 *
 * RT_Init
 *
 * Define RT state for a given standard/resolution combination
 *
 **********************************************************************/

static
void
RT_Init(
	const ModeConstants *constPtr,
	TVStd tvStd,
	Bool isErt,
	Bool enable,
	int hPos,
	int vPos,
	int hSize,
	TheaterStatePtr save
	)
{
  unsigned i;
  CARD32 tmp;
  const TVConstants *pTvStd = &tvStdConsts[ tvStd ];

  save->clkout_cntl = VIP_CLKOUT_CNTL_INI;

  save->clock_sel_cntl = VIP_CLOCK_SEL_CNTL_INI |  
    (constPtr->crtcPLL_byteClkDiv << VIP_CLOCK_SEL_CNTL_BYTCLK_SHIFT) |
    (constPtr->byteClkDelay << VIP_CLOCK_SEL_CNTL_BYTCLKD_SHIFT);

  save->crc_cntl = 0;

  tmp = ((CARD32)constPtr->crtcPLL_M << VIP_CRT_PLL_CNTL_M_SHIFT) |
    (((CARD32)constPtr->crtcPLL_N & VIP_CRT_PLL_CNTL_NLO) << VIP_CRT_PLL_CNTL_NLO_SHIFT) |
    (((CARD32)constPtr->crtcPLL_N & VIP_CRT_PLL_CNTL_NHI) << VIP_CRT_PLL_CNTL_NHI_SHIFT);
  if (constPtr->crtcPLL_divBy2)
    tmp |= VIP_CRT_PLL_CNTL_CLKBY2;
  save->crt_pll_cntl = tmp;

  save->frame_lock_cntl = VIP_FRAME_LOCK_CNTL_INI;

  save->gain_limit_settings = VIP_GAIN_LIMIT_SETTINGS_INI;

  save->hdisp = constPtr->horResolution - 1;
  save->hstart = constPtr->horStart;
  save->htotal = constPtr->horTotal - 1;

  save->hw_debug = VIP_HW_DEBUG_INI;

  save->linear_gain_settings = VIP_LINEAR_GAIN_SETTINGS_INI;

  /*
   * TEST   TEST   TEST   TEST   TEST   TEST   TEST   TEST   TEST   
   */
  if (isErt)
    save->master_cntl = enable ? TV_MASTER_CNTL_ON_INI : TV_MASTER_CNTL_OFF_INI;
  else
    save->master_cntl = enable ? VIP_MASTER_CNTL_ON_INI : VIP_MASTER_CNTL_OFF_INI;

  save->modulator_cntl1 = pTvStd->modulatorCntl1;
  save->modulator_cntl2 = pTvStd->modulatorCntl2;

  save->pll_cntl0 = VIP_PLL_CNTL0_INI;
  save->pll_test_cntl = VIP_PLL_TEST_CNTL_INI;

  save->pre_dac_mux_cntl = VIP_PRE_DAC_MUX_CNTL_INI;

  if (isErt)
    save->rgb_cntl = TV_RGB_CNTL_INI;
  else
    /*
     * Instruct RT to accept either 565 or 888 packed pixels
     */
    save->rgb_cntl = constPtr->use888RGB ? VIP_RGB_CNTL_RGB_IS_888_PACK : 0;

  save->sync_cntl = VIP_SYNC_CNTL_INI;

  save->sync_lock_cntl = VIP_SYNC_LOCK_CNTL_INI;

  save->sync_size = constPtr->horResolution + 8;
  
  tmp = (constPtr->vScalerCntl1 >> VIP_VSCALER_CNTL1_UV_INC_SHIFT) & VIP_VSCALER_CNTL1_UV_INC;
  tmp = ((16384 * 256 * 10) / tmp + 5) / 10;
  tmp = (tmp << VIP_TIMING_CNTL_UV_OUT_POST_SCALE_SHIFT) | 
    VIP_TIMING_CNTL_INI;
  save->timing_cntl = tmp;

  save->tvo_data_delay_a = constPtr->tvoDataDelayA;
  save->tvo_data_delay_b = constPtr->tvoDataDelayB;

  save->tvo_sync_pat_expect = VIP_TVO_SYNC_PAT_EXPECT_INI;

  if (constPtr->use888RGB)
    save->tvo_sync_threshold = constPtr->horResolution + constPtr->horResolution / 2;
  else
    save->tvo_sync_threshold = constPtr->horResolution;

  if (isErt)
    {
      if (enable)
	save->tv_dac_cntl = pTvStd->ert_tvDAC_Cntl;
      else
	save->tv_dac_cntl = (pTvStd->ert_tvDAC_Cntl & ~(TV_DAC_CNTL_NBLANK | TV_DAC_CNTL_NHOLD)) |
	  (TV_DAC_CNTL_BGSLEEP | TV_DAC_CNTL_RDACPD | TV_DAC_CNTL_GDACPD | TV_DAC_CNTL_BDACPD);
    }
  else
    {
      if (enable)
	save->tv_dac_cntl = pTvStd->vip_tvDAC_Cntl;
      else
	save->tv_dac_cntl = (pTvStd->vip_tvDAC_Cntl & ~VIP_TV_DAC_CNTL_NBLANK) | 
	  (VIP_TV_DAC_CNTL_DASLEEP | VIP_TV_DAC_CNTL_BGSLEEP);
    }

  tmp = ((CARD32)(pTvStd->tvPLL_M) << VIP_TV_PLL_CNTL_M_SHIFT) |
    (((CARD32)(pTvStd->tvPLL_N) & VIP_TV_PLL_CNTL_NLO) << VIP_TV_PLL_CNTL_NLO_SHIFT) |
    (((CARD32)(pTvStd->tvPLL_N) & VIP_TV_PLL_CNTL_NHI) << VIP_TV_PLL_CNTL_NHI_SHIFT) |
    ((CARD32)(pTvStd->tvPLL_postDiv) << VIP_TV_PLL_CNTL_P_SHIFT);
  save->tv_pll_cntl = tmp;
  save->tv_pll_fine_cntl = TV_PLL_FINE_INI;

  save->upsamp_and_gain_cntl = VIP_UPSAMP_AND_GAIN_CNTL_INI;

  memcpy(&save->upsamp_coeffs[ 0 ] , upsamplerCoeffs , sizeof(save->upsamp_coeffs));

  save->uv_adr = VIP_UV_ADR_INI;

  save->vdisp = constPtr->verResolution - 1;
  save->vftotal = pTvStd->vftotal;

  save->vscaler_cntl1 = constPtr->vScalerCntl1;
  if (isErt)
    save->vscaler_cntl1 |= TV_VSCALER_CNTL1_RESTART_FIELD;
  save->vscaler_cntl2 = VIP_VSCALER_CNTL2_INI;

  save->vtotal = constPtr->verTotal - 1;

  save->y_fall_cntl = VIP_Y_FALL_CNTL_INI;
  save->y_rise_cntl = constPtr->yRiseCntl;
  save->y_saw_tooth_cntl = constPtr->ySawtoothCntl;

  save->disp_merge_cntl = RADEON_DISP_MERGE_CNTL_INI;

  for (i = 0; i < MAX_H_CODE_TIMING_LEN; i++)
    {
      if ((save->h_code_timing[ i ] = constPtr->horTimingTable[ i ]) == 0)
	break;
    }

  for (i = 0; i < MAX_V_CODE_TIMING_LEN; i++)
    {
      if ((save->v_code_timing[ i ] = constPtr->verTimingTable[ i ]) == 0)
	break;
    }

  /*
   * This must be called AFTER loading timing tables as they are modified by this function
   */
  computeRestarts(constPtr , tvStd , hPos , vPos , hSize , save);
}

/**********************************************************************
 *
 * RT_InitCRTC
 *
 **********************************************************************/
static
void
RT_InitCRTC(
	    const ModeConstants *constPtr,
	    Bool isErt,
	    RADEONSavePtr save
	    )
{
  save->crtc_h_total_disp = (((constPtr->horResolution / 8) - 1) << RADEON_CRTC_H_DISP_SHIFT) |
    (((constPtr->horTotal / 8) - 1) << RADEON_CRTC_H_TOTAL_SHIFT);

  save->crtc_h_sync_strt_wid = (save->crtc_h_sync_strt_wid & ~(RADEON_CRTC_H_SYNC_STRT_PIX | RADEON_CRTC_H_SYNC_STRT_CHAR)) |
    (((constPtr->horSyncStart / 8) - 1) << RADEON_CRTC_H_SYNC_STRT_CHAR_SHIFT) |
    (constPtr->horSyncStart & 7);

  save->crtc_v_total_disp = ((constPtr->verResolution - 1) << RADEON_CRTC_V_DISP_SHIFT) |
    ((constPtr->verTotal - 1) << RADEON_CRTC_V_TOTAL_SHIFT);

  save->crtc_v_sync_strt_wid = (save->crtc_v_sync_strt_wid & ~RADEON_CRTC_V_SYNC_STRT) |
    ((constPtr->verSyncStart - 1) << RADEON_CRTC_V_SYNC_STRT_SHIFT);

  save->htotal_cntl = ((constPtr->horTotal & 7) << RADEON_HTOTAL_CNTL_HTOT_PIX_SLIP_SHIFT) | RADEON_HTOTAL_CNTL_HTOT_CNTL_VGA_EN;

  if (isErt)
    {
      unsigned postDiv;

      save->ppll_ref_div = constPtr->crtcPLL_M;

      switch (constPtr->crtcPLL_postDiv)
	{
	case 1:
	  postDiv = 0;
	  break;

	case 2:
	  postDiv = 1;
	  break;

	case 3:
	  postDiv = 4;
	  break;

	case 4:
	  postDiv = 2;
	  break;

	case 6:
	  postDiv = 6;
	  break;

	case 8:
	  postDiv = 3;
	  break;

	case 12:
	  postDiv = 7;
	  break;

	case 16:
	default:
	  postDiv = 5;
	  break;
	}

      save->ppll_div_3 = (constPtr->crtcPLL_N << RADEON_PPLL_FB3_DIV_SHIFT) | 
	(postDiv << RADEON_PPLL_POST3_DIV_SHIFT);

      save->vclk_ecp_cntl &= ~RADEON_VCLK_SRC_SEL_MASK;
      save->vclk_ecp_cntl |= RADEON_VCLK_SRC_SEL_PPLLCLK;
    }
  else
    {
      save->ppll_div_3 &= ~RADEON_PPLL_POST3_DIV_MASK;
      save->ppll_div_3 |= (constPtr->use888RGB ? RADEON_PPLL_POST3_DIV_BY_3 : RADEON_PPLL_POST3_DIV_BY_2);

      /*
       * Set Radeon to be clocked from RT
       */
      save->vclk_ecp_cntl &= ~RADEON_VCLK_SRC_SEL_MASK;
      save->vclk_ecp_cntl |= RADEON_VCLK_SRC_SEL_BYTECLK;

      save->vclk_ecp_cntl &= ~RADEON_VCLK_ECP_CNTL_BYTECLK_POSTDIV;
      save->vclk_ecp_cntl |= RADEON_VCLK_ECP_CNTL_BYTECLK_NODIV;

      /*
       * Instruct Radeon to output either 565 or 888 packed pixels
       */
      save->disp_output_cntl &= 
	~(RADEON_DISP_TV_SOURCE |
	  RADEON_DISP_TV_MODE_MASK |
	  RADEON_DISP_TV_CBB_CRR_DITH_EN |
	  RADEON_DISP_TV_BIT_WIDTH |
	  RADEON_DISP_TV_SYNC_MODE_MASK |
	  RADEON_DISP_TV_SYNC_COLOR_MASK);
      save->disp_output_cntl |= (constPtr->use888RGB ? 
				 RADEON_DISP_TV_YG_DITH_EN | RADEON_DISP_TV_MODE_888 : 
				 RADEON_DISP_TV_YG_DITH_EN | RADEON_DISP_TV_MODE_565);

      save->crtc_ext_cntl |= RADEON_CRTC_VGA_XOVERSCAN;
      save->dac_cntl |= RADEON_DAC_CNTL_DAC_TVO_EN;
    }
}

/**********************************************************************
 *
 * ERTAutoDetect
 *
 **********************************************************************/
static
Bool
ERTAutoDetect(
	      ScrnInfoPtr pScrn
	      )
{
  RADEONInfoPtr  info       = RADEONPTR(pScrn);
  unsigned char *RADEONMMIO = info->MMIO;
  CARD32 saveReg = INREG(TV_LINEAR_GAIN_SETTINGS);
  Bool detected = FALSE;

  /*
   * Ultra-dumb way of detecting an ERT: check that a register is present 
   * @ TV_LINEAR_GAIN_SETTINGS (this is probably one of the most harmless
   * register to touch)
   */
  OUTREG(TV_LINEAR_GAIN_SETTINGS , 0x15500aa);

  if (INREG(TV_LINEAR_GAIN_SETTINGS) == 0x15500aa)
    {
      OUTREG(TV_LINEAR_GAIN_SETTINGS , 0x0aa0155);
      if (INREG(TV_LINEAR_GAIN_SETTINGS) == 0x0aa0155)
	detected = TRUE;
    }

  OUTREG(TV_LINEAR_GAIN_SETTINGS , saveReg);
  
  return detected;
}

/**********************************************************************
 *
 * detectTheaterOut
 *
 * Detect presence of a RT chip
 *
 **********************************************************************/

TheaterOutPtr 
detectTheaterOut(
		 ScrnInfoPtr pScrn,
		 Bool forceVIP,
		GENERIC_BUS_Ptr b
		 )
{
  RADEONInfoPtr info = RADEONPTR(pScrn);
  //GENERIC_BUS_Ptr b = info->VIP;
  TheaterOutPtr t;  
  int i;
  CARD32 val;
  char s[20];
   
  b->ioctl(b , GB_IOCTL_GET_TYPE , 20 , s);

  if (strcmp(VIP_TYPE , s))
    {
      xf86DrvMsg(b->scrnIndex , X_ERROR , "detectTheaterOut must be called with bus of type \"%s\", not \"%s\"\n",
		 VIP_TYPE , s);
      return NULL;
    }
   
  t = xcalloc(1 , sizeof(TheaterOutRec));
  t->theatre_num = -1;
  t->MMIO = info->MMIO;
  t->VIP = b;

  if (!forceVIP && ERTAutoDetect(pScrn))
    xf86DrvMsg(b->scrnIndex , X_INFO , "Embedded Rage Theater detected\n");
  else
    {
      //
      // Is this really needed?
      // 
      b->read(b , VIP_VIP_VENDOR_DEVICE_ID , 4 , (CARD8*)&val);

      for (i = 0; i < 4; i++)
	{
	  if(b->read(b , ((i & 0x03) << 14) | VIP_VIP_VENDOR_DEVICE_ID , 4 , (CARD8*)&val))
	    {
	      if (val)
		xf86DrvMsg(b->scrnIndex , X_INFO , "Device %d on VIP bus ids as 0x%08x\n" , i , (int)val);
	      if (t->theatre_num >= 0)
		continue;	// already found one instance
	      if (val == RT100_ATI_ID)
		t->theatre_num = i;
	    } 
	  else 
	    {
	      xf86DrvMsg(b->scrnIndex , X_INFO , "No response from device %d on VIP bus\n" , i);	
	    }
	}
      if (t->theatre_num >= 0)
	{
	  xf86DrvMsg(b->scrnIndex , X_INFO , 
		     "Detected Rage Theatre as device %d on VIP bus\n" , t->theatre_num);
	  theatre_read(t , VIP_VIP_REVISION_ID , &val);
	  xf86DrvMsg(b->scrnIndex , X_INFO , "Detected Rage Theatre revision %8.8X\n" , (int)val);
	}
      else
	{
	  xfree(t);
	  return NULL;
	}
    }
    
  return t;
}

/**********************************************************************
 *
 * initTheaterOut
 *
 * Initialization of module
 *
 * 's' should be the value of TV_Output option (i.e. the initial TV
 * standard)
 *
 **********************************************************************/

void
initTheaterOut(
	       TheaterOutPtr t,
	       const char *s
	       )
{
  RTTRACE(("Entering initTheaterOut, s = %s\n" , s));
  /*
   * TEST   TEST   TEST   TEST   TEST   TEST   TEST   TEST   TEST   
   */
  if (xf86NameCmp(s , "NTSC") == 0)
    t->standard = TV_STD_NTSC;
  else if (xf86NameCmp(s , "PAL") == 0)
    t->standard = TV_STD_PAL;
  else if (xf86NameCmp(s , "PAL-M") == 0)
    t->standard = TV_STD_PAL_M;
  else if (xf86NameCmp(s , "PAL-60") == 0)
    t->standard = TV_STD_PAL_60;
  else if (xf86NameCmp(s , "NTSC-J") == 0)
    t->standard = TV_STD_NTSC_J;
  else if (xf86NameCmp(s , "PAL-CN") == 0)
    t->standard = TV_STD_PAL_CN;
  else if (xf86NameCmp(s , "PAL-N") == 0)
    t->standard = TV_STD_PAL_N;
  else
    {
      xf86DrvMsg(0 , X_WARNING , "Unrecognized TV standard in TVOutput option (%s), TV output is disabled\n" , s);
      t->standard = TV_STD_KEEP_OFF;
    }
  t->compatibleMode = FALSE;

  t->hPos = 0;
  t->vPos = 0;
  t->hSize = 0;
}

/**********************************************************************
 *
 * theaterOutSave
 *
 * Save current state of RT as initial state (the one that is restored
 * when switching back to text mode)
 *
 **********************************************************************/

void
theaterOutSave(
	       TheaterOutPtr t,
	       ScrnInfoPtr pScrn
	       )
{
  RTTRACE(("Entering theaterOutSave\n"));
  RT_Save(t , pScrn , &t->savedState);
}

/**********************************************************************
 *
 * theaterOutRestore
 *
 * Restore state of RT from initial state (the one saved through 
 * theaterOutSave)
 *
 **********************************************************************/

void
theaterOutRestore(
		  TheaterOutPtr t,
		  ScrnInfoPtr pScrn
		  )
{
  RTTRACE(("Entering theaterOutRestore\n"));
  RT_Restore(t , pScrn , &t->savedState);
}
		  
/**********************************************************************
 *
 * theaterOutInit
 *
 * Define state for cloning current CRTC mode on TV output
 * It works in this way:
 * 1. It checks if resolution in "mode" parameter is one of those 
 *    allowing tv output
 * 2. If resolution is OK, define RT state according to resolution and
 *    and current settings (tv standard etc.)
 *    If resolution is not ok, define RT state to turn tv output off
 * 3. If resolution is OK, modify Radeon state to make it correct for 
 *    tv output (this is needed,e.g., to set vertical frequency to 50/60 Hz)
 *
 * Return value is TRUE when mode is OK for cloning on tv and tv output
 * is enabled, FALSE otherwise
 *
 **********************************************************************/

Bool
theaterOutInit(
	       TheaterOutPtr t,
	       DisplayModePtr mode,
	       RADEONSavePtr save
	       )
{
  const ModeConstants *p;
  Bool isErt = t->theatre_num < 0;

  RTTRACE(("Entering theaterOutInit: std=%u h=%u v=%u\n" , t->standard , mode->HDisplay , mode->VDisplay));

  t->compatibleMode = FALSE;

  if (t->standard != TV_STD_KEEP_OFF)
    {
      /*
       * Search mode among available ones
       */
      for (p = availableModes; p < (availableModes + N_AVAILABLE_MODES); p++)
	{
	  if (p->horResolution == mode->HDisplay &&
	      p->verResolution == mode->VDisplay &&
	      p->standard == t->standard)
	    {
	      /*
	       * Match found
	       */
	      t->compatibleMode = TRUE;
	      t->currentMode = p;

	      RT_Init(p , t->standard , isErt , TRUE , t->hPos , t->vPos , t->hSize , &t->modeState);
	      RT_InitCRTC(p , isErt , save);

	      return TRUE;
	    }
	}
    }

  /*
   * Match not found or tv output disabled
   * First parameter is dummy when setting for no tv output, so any mode
   * will do (here first mode in table is passed).
   */
  RT_Init(availableModes , TV_STD_NTSC , isErt , FALSE , t->hPos , t->vPos , t->hSize , &t->modeState);
  return FALSE;
}
	       
/**********************************************************************
 *
 * theaterOutRestoreMode
 *
 * Set state of RT to the one defined by last call to theaterOutInit
 *
 **********************************************************************/

void
theaterOutRestoreMode(
		      TheaterOutPtr t,
		      ScrnInfoPtr pScrn
		      )
{
  RTTRACE(("Entering theaterOutRestoreMode\n"));
  RT_Restore(t , pScrn , &t->modeState);
}

/**********************************************************************
 *
 * theaterOutSetStandard
 *
 * Set TV output standard
 *
 * Return value is TRUE when video mode should be set again
 *
 **********************************************************************/
Bool
theaterOutSetStandard(
		      TheaterOutPtr t,
		      TVStd std
		      )
{
  TVStd oldStd = t->standard;

  RTTRACE(("Entering theaterOutSetStandard\n"));

  if (std >= TV_STD_N_STANDARDS)
    std = TV_STD_KEEP_OFF;

  t->standard = std;

  if (t->compatibleMode)
    return oldStd != std;
  else 
    return std != TV_STD_KEEP_OFF && oldStd == TV_STD_KEEP_OFF;
}
		      
/**********************************************************************
 *
 * theaterOutGetStandard
 *
 * Get current TV output standard
 *
 **********************************************************************/
TVStd
theaterOutGetStandard(
		      TheaterOutPtr t
		      )
{
  return t->standard;
}

/**********************************************************************
 *
 * theaterOutGetCompatMode
 *
 * Return whether the current mode is compatible with tv output or not
 *
 **********************************************************************/
Bool
theaterOutGetCompatMode(
			TheaterOutPtr t
			)
{
  return t->compatibleMode;
}

/**********************************************************************
 *
 * updateHVPosition
 *
 * Set hw registers for a new h/v position & h size
 *
 **********************************************************************/
static
void
updateHVPosition(
		 TheaterOutPtr t
		 )
{
  Bool reloadTable;

  reloadTable = computeRestarts(t->currentMode , t->standard , t->hPos , t->vPos , t->hSize , &t->modeState);

  if (t->theatre_num < 0)
    {
      ERT_RestoreRestarts(t , &t->modeState);
      ert_write(t , TV_TIMING_CNTL , t->modeState.timing_cntl);

      if (reloadTable)
	{
	  ert_write(t,
		    TV_MASTER_CNTL ,
		    t->modeState.master_cntl | 
		    VIP_MASTER_CNTL_TV_ASYNC_RST |
		    VIP_MASTER_CNTL_CRT_ASYNC_RST |
		    VIP_MASTER_CNTL_RESTART_PHASE_FIX);

	  restoreTimingTables(t , &t->modeState);
	
	  ert_write(t , 
		    TV_MASTER_CNTL , 
		    t->modeState.master_cntl);
	}
    }
  else
    {
      restoreRestarts(t , &t->modeState);
      theatre_write(t , VIP_TIMING_CNTL , t->modeState.timing_cntl);

      if (reloadTable)
	{
	  theatre_write(t , 
			VIP_MASTER_CNTL , 
			t->modeState.master_cntl |
			VIP_MASTER_CNTL_TV_ASYNC_RST |
			VIP_MASTER_CNTL_CRT_ASYNC_RST);

	  restoreTimingTables(t , &t->modeState);
	
	  theatre_write(t , 
			VIP_MASTER_CNTL , 
			t->modeState.master_cntl);
	}
    }
}

/**********************************************************************
 *
 * theaterOutSetAttr
 *
 * Set an attribute
 *
 **********************************************************************/
void
theaterOutSetAttr(
		  TheaterOutPtr t,
		  TheaterOutAttr attr,
		  int value
		  )
{
  switch (attr)
    {
    case THEATER_OUT_HPOS:
      if (value < -MAX_H_POSITION)
	t->hPos = -MAX_H_POSITION;
      else if (value > MAX_H_POSITION)
	t->hPos = MAX_H_POSITION;
      else
	t->hPos = value;
      break;
	
    case THEATER_OUT_VPOS:
      if (value < -MAX_V_POSITION)
	t->vPos = -MAX_V_POSITION;
      else if (value > MAX_V_POSITION)
	t->vPos = MAX_V_POSITION;
      else
	t->vPos = value;
      break;
	
    case THEATER_OUT_HSIZE:
      if (value < -MAX_H_SIZE)
	t->hSize = -MAX_H_SIZE;
      else if (value > MAX_H_SIZE)
	t->hSize = MAX_H_SIZE;
      else
	t->hSize = value;
      break;

    default:
      return;
    }

  if (t->compatibleMode)
    updateHVPosition(t);
}
		      
/**********************************************************************
 *
 * theaterOutGetAttr
 *
 * Get an attribute
 *
 **********************************************************************/
int
theaterOutGetAttr(
		  TheaterOutPtr t,
		  TheaterOutAttr attr
		  )
{
  switch (attr)
    {
    case THEATER_OUT_HPOS:
      return t->hPos;
	
    case THEATER_OUT_VPOS:
      return t->vPos;
	
    case THEATER_OUT_HSIZE:
      return t->hSize;

    default:
      return 0;
    }
}
		      
/**********************************************************************
 *
 * theaterOutGetAttrLimits
 *
 * Get limits for an attribute value
 *
 **********************************************************************/
void
theaterOutGetAttrLimits(
			TheaterOutPtr t,
			TheaterOutAttr attr,
			int *maxValue,
			int *minValue
			)
{
  switch (attr)
    {
    case THEATER_OUT_HPOS:
      *maxValue = MAX_H_POSITION;
      *minValue = -MAX_H_POSITION;
      break;
	
    case THEATER_OUT_VPOS:
      *maxValue = MAX_V_POSITION;
      *minValue = -MAX_V_POSITION;
      break;
	
    case THEATER_OUT_HSIZE:
      *maxValue = MAX_H_SIZE;
      *minValue = -MAX_H_SIZE;
      break;

    default:
      break;
    }
}




/*********************************************************************
 *
 * $Id: theater_out.h,v 1.1.2.2 2004/01/27 22:50:35 fulivi Exp $
 *
 * Interface file for theater_out module
 *
 * Copyright (C) 2003 Federico Ulivi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * AUTHORS: F.Ulivi
 * NOTES:
 * $Log: theater_out.h,v $
 * Revision 1.1.2.2  2004/01/27 22:50:35  fulivi
 * Support for positioning/sizing of image added
 *
 * Revision 1.1.2.9  2004/01/18 23:01:12  fede
 * Functions for get/setting h/v pos/size replaced by
 * theaterOutSetAttr/theaterOutGetAttr/theaterOutGetAttrLimits
 * Circular inclusion with radeon.h fixed
 *
 * Revision 1.1.2.8  2004/01/11 21:43:32  fede
 * Fixed problem with definition of TVStd
 *
 * Revision 1.1.2.7  2004/01/05 00:09:59  fede
 * Functions for setting/getting H/V position added
 * Functions for setting/getting on/off attribute removed
 *
 * Revision 1.1.2.1  2003/11/26 19:50:10  fulivi
 * Support for ERT added
 *
 * Revision 1.1.2.6  2003/11/25 20:44:00  fede
 * TV_STD_KEEP_OFF added
 *
 * Revision 1.1.2.5  2003/10/14 18:41:32  fede
 * forceERT changed to forceVIP
 *
 * Revision 1.1.2.4  2003/10/11 12:30:30  fede
 * Support for ERT added
 *
 * Revision 1.1  2003/09/28 21:42:37  fulivi
 * Theater_out module added
 *
 * Revision 1.1.2.3  2003/09/28 15:26:09  fede
 * Minor aesthetic changes
 *
 * Revision 1.1.2.1  2003/08/31 13:36:35  fede
 * *** empty log message ***
 *
 *
 *********************************************************************/

#ifndef _THEATER_OUT_H
#define _THEATER_OUT_H

/**********************************************************************
 *
 * TheaterOutPtr
 *
 * Pointer to TheaterOut struct. Actual definition is in theater_out.c
 *
 **********************************************************************/
typedef struct TheaterOut *TheaterOutPtr;

/**********************************************************************
 *
 * TVStd
 *
 * Tv standard
 *
 **********************************************************************/
typedef enum
  {
    TV_STD_NTSC,
    TV_STD_PAL,
    TV_STD_PAL_M,
    TV_STD_PAL_60,
    TV_STD_NTSC_J,
    TV_STD_PAL_CN,
    TV_STD_PAL_N,
    TV_STD_KEEP_OFF,
    TV_STD_N_STANDARDS	/* Must be last */
  } TVStd;

/**********************************************************************
 *
 * TheaterOutAttr
 *
 * Integer-valued attributes of this module
 *
 **********************************************************************/
typedef enum
  {
    THEATER_OUT_HPOS,	/* Horizontal position */
    THEATER_OUT_VPOS,	/* Vertical position */
    THEATER_OUT_HSIZE	/* Horizontal size */
  } TheaterOutAttr;

#ifndef _RADEON_H_
#include "radeon.h"
#endif

/**********************************************************************
 *
 * detectTheaterOut
 *
 * Detect presence of a RT chip
 *
 **********************************************************************/

extern
TheaterOutPtr 
detectTheaterOut(
		 ScrnInfoPtr pScrn,
		 Bool forceVIP,
GENERIC_BUS_Ptr b
		 );

/**********************************************************************
 *
 * initTheaterOut
 *
 * Initialization of module
 *
 * 's' should be the value of TV_Output option (i.e. the initial TV
 * standard)
 *
 **********************************************************************/

extern
void
initTheaterOut(
	       TheaterOutPtr t,
	       const char *s
	       );

/**********************************************************************
 *
 * theaterOutSave
 *
 * Save current state of RT as initial state (the one that is restored
 * when switching back to text mode)
 *
 **********************************************************************/

extern
void
theaterOutSave(
	       TheaterOutPtr t,
	       ScrnInfoPtr pScrn
	       );

/**********************************************************************
 *
 * theaterOutRestore
 *
 * Restore state of RT from initial state (the one saved through 
 * theaterOutSave)
 *
 **********************************************************************/

extern
void
theaterOutRestore(
		  TheaterOutPtr t,
		  ScrnInfoPtr pScrn
		  );
		  
/**********************************************************************
 *
 * theaterOutInit
 *
 * Define state for cloning current CRTC mode on TV output
 * It works in this way:
 * 1. It checks if resolution in "mode" parameter is one of those 
 *    allowing tv output
 * 2. If resolution is OK, define RT state according to resolution and
 *    and current settings (tv standard etc.)
 *    If resolution is not ok, define RT state to turn tv output off
 * 3. If resolution is OK, modify Radeon state to make it correct for 
 *    tv output (this is needed,e.g., to set vertical frequency to 50/60 Hz)
 *
 * Return value is TRUE when mode is OK for cloning on tv and tv output
 * is enabled, FALSE otherwise
 *
 **********************************************************************/

extern
Bool
theaterOutInit(
	       TheaterOutPtr t,
	       DisplayModePtr mode,
	       RADEONSavePtr save
	       );
	       
/**********************************************************************
 *
 * theaterOutRestoreMode
 *
 * Set state of RT to the one defined by last call to theaterOutInit
 *
 **********************************************************************/

extern
void
theaterOutRestoreMode(
		      TheaterOutPtr t,
		      ScrnInfoPtr pScrn
		      );

/**********************************************************************
 *
 * theaterOutSetStandard
 *
 * Set TV output standard
 *
 * Return value is TRUE when video mode should be set again
 *
 **********************************************************************/

extern
Bool
theaterOutSetStandard(
		      TheaterOutPtr t,
		      TVStd std
		      );
		      
/**********************************************************************
 *
 * theaterOutGetStandard
 *
 * Get current TV output standard
 *
 **********************************************************************/
extern
TVStd
theaterOutGetStandard(
		      TheaterOutPtr t
		      );

/**********************************************************************
 *
 * theaterOutGetCompatMode
 *
 * Return whether the current mode is compatible with tv output or not
 *
 **********************************************************************/
extern
Bool
theaterOutGetCompatMode(
			TheaterOutPtr t
			);

/**********************************************************************
 *
 * theaterOutSetAttr
 *
 * Set an attribute
 *
 **********************************************************************/
extern
void
theaterOutSetAttr(
		  TheaterOutPtr t,
		  TheaterOutAttr attr,
		  int value
		  );

/**********************************************************************
 *
 * theaterOutGetAttr
 *
 * Get an attribute
 *
 **********************************************************************/
extern
int
theaterOutGetAttr(
		  TheaterOutPtr t,
		  TheaterOutAttr attr
		  );

/**********************************************************************
 *
 * theaterOutGetAttrLimits
 *
 * Get limits for an attribute value
 *
 **********************************************************************/
extern
void
theaterOutGetAttrLimits(
			TheaterOutPtr t,
			TheaterOutAttr attr,
			int *maxValue,
			int *minValue
			);

/**********************************************************************
 *
 * THEATER_OUT_SYMBOLS
 *
 * Symbol list for module loading
 *
 **********************************************************************/

#define THEATER_OUT_SYMBOLS	"detectTheaterOut", \
				"initTheaterOut", \
				"theaterOutSave", \
				"theaterOutRestore", \
				"theaterOutInit", \
				"theaterOutRestoreMode", \
				"theaterOutSetStandard", \
				"theaterOutGetStandard", \
				"theaterOutGetCompatMode", \
				"theaterOutSetAttr", \
				"theaterOutGetAttr", \
				"theaterOutGetAttrLimits"

/**********************************************************************
 *
 * External access to module functions
 *
 **********************************************************************/

#ifdef XFree86LOADER

#define xf86_detectTheaterOut	((TheaterOutPtr (*)(ScrnInfoPtr , Bool,GENERIC_BUS_Ptr))LoaderSymbol("detectTheaterOut"))
#define xf86_initTheaterOut	((void (*)(TheaterOutPtr , const char*))LoaderSymbol("initTheaterOut"))
#define xf86_theaterOutSave	((void (*)(TheaterOutPtr , ScrnInfoPtr))LoaderSymbol("theaterOutSave"))
#define xf86_theaterOutRestore	((void (*)(TheaterOutPtr , ScrnInfoPtr))LoaderSymbol("theaterOutRestore"))
#define xf86_theaterOutInit	((Bool (*)(TheaterOutPtr , DisplayModePtr , RADEONSavePtr))LoaderSymbol("theaterOutInit"))
#define xf86_theaterOutRestoreMode	((void (*)(TheaterOutPtr , ScrnInfoPtr))LoaderSymbol("theaterOutRestoreMode"))
#define xf86_theaterOutSetStandard	((Bool (*)(TheaterOutPtr , TVStd))LoaderSymbol("theaterOutSetStandard"))
#define xf86_theaterOutGetStandard	((TVStd (*)(TheaterOutPtr))LoaderSymbol("theaterOutGetStandard"))
#define xf86_theaterOutGetCompatMode	((Bool (*)(TheaterOutPtr))LoaderSymbol("theaterOutGetCompatMode"))
#define xf86_theaterOutSetAttr	((void (*)(TheaterOutPtr , TheaterOutAttr , int))LoaderSymbol("theaterOutSetAttr"))
#define xf86_theaterOutGetAttr	((int (*)(TheaterOutPtr , TheaterOutAttr))LoaderSymbol("theaterOutGetAttr"))
#define xf86_theaterOutGetAttrLimits	((void (*)(TheaterOutPtr , TheaterOutAttr , int * , int *))LoaderSymbol("theaterOutGetAttrLimits"))

#else

#define xf86_detectTheaterOut	detectTheaterOut
#define xf86_initTheaterOut	initTheaterOut
#define xf86_theaterOutSave	theaterOutSave
#define xf86_theaterOutRestore	theaterOutRestore
#define xf86_theaterOutInit	theaterOutInit
#define xf86_theaterOutRestoreMode	theaterOutRestoreMode
#define xf86_theaterOutSetStandard	theaterOutSetStandard
#define xf86_theaterOutGetStandard	theaterOutGetStandard
#define xf86_theaterOutGetCompatMode	theaterOutGetCompatMode
#define xf86_theaterOutSetAttr	theaterOutSetAttr	
#define xf86_theaterOutGetAttr	theaterOutGetAttr	
#define xf86_theaterOutGetAttrLimits	theaterOutGetAttrLimits

#endif	/* XFree86LOADER */

#endif  /* _THEATER_OUT_H */




#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "xf86Module.h"

static MODULESETUPPROTO(theaterOutSetup);

static 
XF86ModuleVersionInfo 
theaterVersRec =
{
  "theater_out",	/* modname */
  MODULEVENDORSTRING,	/* vendor */
  MODINFOSTRING1,	/* _modinfo1_ */
  MODINFOSTRING2,	/* _modinfo2_ */
  XORG_VERSION_CURRENT,	/* xf86version */
  1,			/* majorversion */
  0,			/* minorversion */
  0,			/* patchlevel */
  ABI_CLASS_VIDEODRV,	/* abiclass */
  ABI_VIDEODRV_VERSION,	/* abiversion */
  MOD_CLASS_NONE,	/* moduleclass */
  { 0 , 0 , 0 , 0 }	/* checksum */
};
 
_X_EXPORT XF86ModuleData 
theater_outModuleData = 
  { 
    &theaterVersRec, 
    theaterOutSetup, 
    NULL 
  }; 

static
pointer
theaterOutSetup(
		pointer module, 
		pointer opts, 
		int *errmaj, 
		int *errmin
		)
{
  return (pointer)1;
}




XCOMM $Id: Imakefile,v 1.1.2.1 2004/01/27 22:55:40 fulivi Exp $
XCOMM
XCOMM Imakefile for tvo_set utility
XCOMM
XCOMM Copyright (C) 2004 Federico Ulivi
XCOMM
XCOMM This program is free software; you can redistribute it and/or modify
XCOMM it under the terms of the GNU General Public License as published by
XCOMM the Free Software Foundation; either version 2 of the License, or
XCOMM (at your option) any later version.
XCOMM
XCOMM This program is distributed in the hope that it will be useful,
XCOMM but WITHOUT ANY WARRANTY; without even the implied warranty of
XCOMM MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
XCOMM GNU General Public License for more details.
XCOMM
XCOMM You should have received a copy of the GNU General Public License
XCOMM along with this program; if not, write to the Free Software
XCOMM Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
XCOMM
XCOMM AUTHORS: F.Ulivi
XCOMM NOTES:
XCOMM $Log: Imakefile,v $
XCOMM Revision 1.1.2.1  2004/01/27 22:55:40  fulivi
XCOMM Initial release
XCOMM
XCOMM Revision 1.1.2.1  2004/01/25 23:07:31  fede
XCOMM *** empty log message ***
XCOMM
XCOMM

        DEPLIBS = $(DEPXVLIB) $(DEPXLIB)
LOCAL_LIBRARIES = $(XVLIB) $(XLIB)
           SRCS = tvo_set.c
           OBJS = tvo_set.o

ComplexProgramTargetNoMan(tvo_set)




/*********************************************************************
 *
 * $Id: tvo_set.c,v 1.1.2.1 2004/01/27 22:55:40 fulivi Exp $
 *
 * Main (and only) module of tvo_set utility. 
 * The purpose of this utility is to set various parameters of
 * tv output module.
 *
 * Copyright (C) 2004 Federico Ulivi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * AUTHORS: F.Ulivi
 * NOTES:
 * $Log: tvo_set.c,v $
 * Revision 1.1.2.1  2004/01/27 22:55:40  fulivi
 * Initial release
 *
 * Revision 1.1.2.2  2004/01/25 23:07:47  fede
 * GPL notice added
 *
 * Revision 1.1.2.1  2004/01/25 15:09:42  fede
 * First version
 *
 *
 *********************************************************************/

#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/extensions/Xvlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

/**********************************************************************
 *
 * program_name
 *
 **********************************************************************/
static
const char *program_name;

/**********************************************************************
 *
 * Action
 *
 **********************************************************************/
typedef enum
  {
    ACT_FULL_DUMP,
    ACT_SET,
    ACT_INC,
    ACT_DEC,
    ACT_ZERO
  } Action;

/**********************************************************************
 *
 * attrNames / attrData
 *
 **********************************************************************/
typedef struct
{
  Atom atom;
  int minValue;
  int maxValue;
} AttrData;

typedef struct
{
  char* extName;
  char* attrName;
  char* description;
} AttrName;

static
const AttrName attrNames[] =
  {
    { "hpos" , "XV_TVO_HPOS" , "Horizontal position" },
    { "vpos" , "XV_TVO_VPOS" , "Vertical position" },
    { "hsize" , "XV_TVO_HSIZE" , "Horizontal size" },
    { "std" , "XV_TVO_STANDARD" , "TV Standard" }
  };

#define N_ATTRS (sizeof(attrNames) / sizeof(attrNames[ 0 ]))
/*
 * Index of TV standard attribute
 */
#define STD_ATTR        3

static
AttrData attrData[ N_ATTRS ];

/**********************************************************************
 *
 * stdNames
 *
 **********************************************************************/
static
const char *stdNames[] = 
  {
    "NTSC",
    "PAL",
    "PAL-M",
    "PAL-60",
    "NTSC-J",
    "PAL-CN",
    "PAL-N",
    "OFF"
  };
#define N_STDS  (sizeof(stdNames) / sizeof(stdNames[ 0 ]))

/**********************************************************************
 *
 * scanAttributes
 *
 **********************************************************************/
static
Bool
subScanAttributes(
                  Display *dpy,
                  XvAttribute *pAttributes,
                  int nAttributes
                  )
{
  unsigned i;
  unsigned j;
  Atom theAtom;

  for (i = 0; i < N_ATTRS; i++)
    {
      const char* name = attrNames[ i ].attrName;

      for (j = 0; j < nAttributes; j++)
        {
          if (strcmp(name , pAttributes[ j ].name) == 0)
            {
              attrData[ i ].minValue = pAttributes[ j ].min_value;
              attrData[ i ].maxValue = pAttributes[ j ].max_value;
              if ((pAttributes[ j ].flags & (XvGettable | XvSettable)) != (XvGettable | XvSettable))
                return False;
              
              theAtom = XInternAtom(dpy , name , True);
              if (theAtom == None)
                return False;

              attrData[ i ].atom = theAtom;

              break;
            }
        }
      if (j == nAttributes)
        return False;
    }

  return True;
}

static
Bool
scanAttributes(
               Display *dpy,
               XvPortID portID
               )
{
  XvAttribute *pAttributes;
  int nAttributes;
  Bool res = False;

  if ((pAttributes = XvQueryPortAttributes(dpy , portID , &nAttributes)) == 0)
    return False;

  if (nAttributes > 0)
    res = subScanAttributes(dpy , pAttributes , nAttributes);

  XFree(pAttributes);
  return res;
}
               
/**********************************************************************
 *
 * getAttribute
 *
 **********************************************************************/
static
void
getAttribute(
             Display *dpy,
             XvPortID portID,
             int attribute,
             int *value
             )
{
  if (XvGetPortAttribute(dpy , 
                         portID , 
                         attrData[ attribute ].atom ,
                         value) == Success)
    return;

  fprintf(stderr , "%s: Unable to get value of attribute %s\n" , program_name , attrNames[ attribute ].attrName);
  exit(2);
}

/**********************************************************************
 *
 * setAttribute
 *
 **********************************************************************/
static
void
setAttribute(
             Display *dpy,
             XvPortID portID,
             int attribute,
             int value
             )
{
  int dummy;

  if (XvSetPortAttribute(dpy , portID , attrData[ attribute ].atom , value) != Success)
    {
      fprintf(stderr , "%s: Unable to set value of attribute %s\n" , program_name , attrNames[ attribute ].attrName);
      exit(2);
    }

  getAttribute(dpy , portID , attribute , &dummy);
}

/**********************************************************************
 *
 * parseAttribute
 *
 **********************************************************************/
static
int
parseAttribute(
               const char *name
               )
{
  int i;

  for (i = 0; i < N_ATTRS; i++)
    if (strcasecmp(name , attrNames[ i ].extName) == 0)
      return i;

  return -1;
}

/**********************************************************************
 *
 * parseStd
 *
 **********************************************************************/
static
int
parseStd(
         const char *name
         )
{
  int i;

  for (i = 0; i < N_STDS; i++)
    if (strcasecmp(name , stdNames[ i ]) == 0)
      return i;

  return -1;
}

/**********************************************************************
 *
 * printUsage
 *
 **********************************************************************/
static
void
printUsage(void)
{
  unsigned i;

  fprintf(stderr , "Usage:\n"
          "%s [-display host:dpy] [<cmd> <attribute> [<value>]]\n\n" , program_name);
  fprintf(stderr , "When <cmd> is absent, a dump of all attributes is done\n");
  fprintf(stderr , "Allowed <cmd>s:\n"
                   "set <attribute> <value>   Set <attribute> to <value>\n"
                   "inc <attribute>           Increment <attribute> by 1\n"
                   "dec <attribute>           Decrement <attribute> by 1\n"
                   "zero <attribute>          Set <attribute> to 0\n"
                   "\nAllowed <attribute>s:\n");

  for (i = 0; i < N_ATTRS; i++)
    fprintf(stderr , "%-6s  %s\n" , attrNames[ i ].extName , attrNames[ i ].description);

  fprintf(stderr , "\nFor %s attribute, both the numeric value and the name of the standard are valid.\n" ,
          attrNames[ STD_ATTR ].extName);

  fprintf(stderr , "\nAllowed standards:\n");
  
  for (i = 0; i < N_STDS; i++)
    fprintf(stderr , "%d %s\n" , i , stdNames[ i ]);

  exit(1);
}

/**********************************************************************
 *
 * main
 *
 **********************************************************************/
int 
main(
     int argc, 
     char *argv[]
     )
{
  Action action;
  Display *dpy;
  char *disname = NULL;
  unsigned argIdx = 1;
  int attribute;
  int value;
  unsigned ver, rev, eventB, reqB, errorB; 
  XvAdaptorInfo *ainfo;
  unsigned nadaptors;
  unsigned i;
  XvPortID portID;

  program_name = argv[ 0 ];

  if (argc >= 3 && 
      strcmp(argv[ argIdx ] , "-display") == 0)
    {
      argIdx++;
      disname = argv[ argIdx++ ];
    }

  if (argIdx < argc)
    {
      if (strcasecmp(argv[ argIdx ] , "set") == 0)
        action = ACT_SET;
      else if (strcasecmp(argv[ argIdx ] , "inc") == 0)
        action = ACT_INC;
      else if (strcasecmp(argv[ argIdx ] , "dec") == 0)
        action = ACT_DEC;
      else if (strcasecmp(argv[ argIdx ] , "zero") == 0)
        action = ACT_ZERO;
      else
        printUsage();

      argIdx++;
      if (argIdx >= argc)
        printUsage();

      if ((attribute = parseAttribute(argv[ argIdx ])) < 0)
        {
          fprintf(stderr , "%s: Unrecognized attribute name (%s)\n" , program_name , argv[ argIdx ]);
          printUsage();
        }
      argIdx++;

      if (action == ACT_SET)
        {
          if (argIdx >= argc)
            printUsage();
          if (sscanf(argv[ argIdx ] , "%d" , &value) != 1 &&
              (attribute != STD_ATTR || (value = parseStd(argv[ argIdx ])) < 0))
            printUsage();
        }
    }
  else 
    action = ACT_FULL_DUMP;

  /*
   * Open display
   */
  if (!(dpy = XOpenDisplay(disname))) 
    {
      fprintf(stderr , "%s: Unable to open display %s\n" , program_name , 
              (disname != NULL) ? disname : XDisplayName(NULL));
      return -1;
    }

  if (XvQueryExtension(dpy, &ver, &rev, &reqB, &eventB, &errorB) != Success) 
    {
      fprintf(stderr , "%s: No XV Extension on %s\n" , program_name ,
              (disname != NULL) ? disname : XDisplayName(NULL));
      return 0;
    } 
  
  /*
   * Use screen #0
   */
  XvQueryAdaptors(dpy , RootWindow(dpy , 0) , &nadaptors , &ainfo);
  
  if (!nadaptors)
    {
      fprintf(stderr , "%s: No adaptors present\n" , program_name);
      return 0;
    } 

  /*
   * Use adaptor #0
   */
  portID = ainfo[ 0 ].base_id;
  if (!scanAttributes(dpy , portID))
    {
      fprintf(stderr , "%s: Invalid attributes in XV adaptor\n" , program_name);
      return 0;
    }

  switch (action)
    {
    case ACT_FULL_DUMP:
      for(i = 0; i < nadaptors; i++)
        {
          printf("Adaptor #%d: \"%s\"\n" , i , ainfo[ i ].name);
          printf("  number of ports   : %d\n" , ainfo[ i ].num_ports);
          printf("  port base         : %d\n" , ainfo[ i ].base_id);
          printf("  number of adaptors: %u\n" , ainfo[ i ].num_adaptors);
        }
      for (i = 0; i < N_ATTRS; i++)
        {
          getAttribute(dpy , portID , i , &value);
          if (i == STD_ATTR)
            if (value < 0 || value >= N_STDS)
              printf ("%s = ??? (%d)\n" , attrNames[ i ].extName , value);
            else
              printf ("%s = %s (%d)\n" , attrNames[ i ].extName , stdNames[ value ] , value);
          else
            printf("%s = %d\n" , attrNames[ i ].extName , value);
        }
      break;

    case ACT_SET:
      setAttribute(dpy , portID , attribute , value);
      break;

    case ACT_INC:
      getAttribute(dpy , portID , attribute , &value);
      value++;
      if (value > attrData[ attribute ].maxValue)
        value = attrData[ attribute ].minValue;
      setAttribute(dpy , portID , attribute , value);
      break;

    case ACT_DEC:
      getAttribute(dpy , portID , attribute , &value);
      value--;
      if (value < attrData[ attribute ].minValue)
        value = attrData[ attribute ].maxValue;
      setAttribute(dpy , portID , attribute , value);
      break;

    case ACT_ZERO:
      setAttribute(dpy , portID , attribute , 0);
      break;
    }

  return 0;
}

Return to bug 127642

Lines 91-96 Link Here

(-)xf86-video-ati-6.5.8.0/src/Makefile.am (+10 lines)
91	theatre_drv_la_SOURCES = \	91	theatre_drv_la_SOURCES = \
92	theatre.c theatre_module.c	92	theatre.c theatre_module.c
93		93
		94	theater_out_drv_la_LTLIBRARIES = theater_out_drv.la
		95	theater_out_drv_la_LDFLAGS = -module -avoid-version
		96	theater_out_drv_ladir = @moduledir@/multimedia
		97	theater_out_drv_la_CFLAGS = \
		98	$(AM_CFLAGS) -DMICROC_DIR=\"$(theater_out_drv_ladir)\"
		99	theater_out_drv_la_SOURCES = \
		100	theater_out.c theater_out_module.c
		101
		102
94	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la	103	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la
95	theatre200_drv_la_LDFLAGS = -module -avoid-version	104	theatre200_drv_la_LDFLAGS = -module -avoid-version
96	theatre200_drv_ladir = @moduledir@/multimedia	105	theatre200_drv_ladir = @moduledir@/multimedia
Lines 185-190 Link Here
185	radeon_sarea.h \	194	radeon_sarea.h \
186	radeon_version.h \	195	radeon_version.h \
187	radeon_video.h \	196	radeon_video.h \
		197	theater_out.h \
188	theatre200.h \	198	theatre200.h \
189	theatre_detect.h \	199	theatre_detect.h \
190	theatre.h \	200	theatre.h \

Lines 73-78 Link Here

(-)xf86-video-ati-6.5.8.0/src/radeon_driver.c (-9 / +204 lines)
73	#include "radeon_macros.h"	73	#include "radeon_macros.h"
74	#include "radeon_probe.h"	74	#include "radeon_probe.h"
75	#include "radeon_version.h"	75	#include "radeon_version.h"
		76	#include "theater_out.h"
76	#include "radeon_mergedfb.h"	77	#include "radeon_mergedfb.h"
77		78
78	#ifdef XF86DRI	79	#ifdef XF86DRI
Lines 184-189 Link Here
184	OPTION_RAGE_THEATRE_COMPOSITE_PORT,	185	OPTION_RAGE_THEATRE_COMPOSITE_PORT,
185	OPTION_RAGE_THEATRE_SVIDEO_PORT,	186	OPTION_RAGE_THEATRE_SVIDEO_PORT,
186	OPTION_TUNER_TYPE,	187	OPTION_TUNER_TYPE,
		188	OPTION_TV_OUTPUT,
187	OPTION_RAGE_THEATRE_MICROC_PATH,	189	OPTION_RAGE_THEATRE_MICROC_PATH,
188	OPTION_RAGE_THEATRE_MICROC_TYPE,	190	OPTION_RAGE_THEATRE_MICROC_TYPE,
189	#endif	191	#endif
Lines 247-252 Link Here
247	{ OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE },	249	{ OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE },
248	{ OPTION_RAGE_THEATRE_SVIDEO_PORT, "RageTheatreSVideoPort", OPTV_INTEGER, {0}, FALSE },	250	{ OPTION_RAGE_THEATRE_SVIDEO_PORT, "RageTheatreSVideoPort", OPTV_INTEGER, {0}, FALSE },
249	{ OPTION_TUNER_TYPE, "TunerType", OPTV_INTEGER, {0}, FALSE },	251	{ OPTION_TUNER_TYPE, "TunerType", OPTV_INTEGER, {0}, FALSE },
		252	{ OPTION_TV_OUTPUT, "TVOutput", OPTV_ANYSTR, {0}, FALSE },
250	{ OPTION_RAGE_THEATRE_MICROC_PATH, "RageTheatreMicrocPath", OPTV_STRING, {0}, FALSE },	253	{ OPTION_RAGE_THEATRE_MICROC_PATH, "RageTheatreMicrocPath", OPTV_STRING, {0}, FALSE },
251	{ OPTION_RAGE_THEATRE_MICROC_TYPE, "RageTheatreMicrocType", OPTV_STRING, {0}, FALSE },	254	{ OPTION_RAGE_THEATRE_MICROC_TYPE, "RageTheatreMicrocType", OPTV_STRING, {0}, FALSE },
252	#endif	255	#endif
Lines 5689-5694 Link Here
5689		5692
5690	info->PaletteSavedOnVT = FALSE;	5693	info->PaletteSavedOnVT = FALSE;
5691		5694
		5695	RADEONTRACE(("Allocating VIP interface"));
		5696	info->VIP = RADEONAllocateVIP(pScrn);
		5697
		5698	if ((s = xf86GetOptValString(info->Options , OPTION_TV_OUTPUT)) != NULL && xf86NameCmp(s , "NOLOAD") != 0)
		5699	{
		5700	RADEONTRACE(("TVOutput opt = %s\n" , s));
		5701	if(!xf86LoadSubModule(pScrn , "theater_out"))
		5702	{
		5703	RADEONTRACE(("Failed to find theater_out module\n"));
		5704	xf86DrvMsg(pScrn->scrnIndex , X_ERROR , "Unable to load TV output module\n");
		5705	info->theaterOut = NULL;
		5706	}
		5707	else
		5708	{
		5709	RADEONTRACE(("Found theater_out module\n"));
		5710	xf86LoaderReqSymbols(THEATER_OUT_SYMBOLS , NULL);
		5711
		5712	info->theaterOut = xf86_detectTheaterOut(pScrn , FALSE,info->VIP);
		5713	if (info->theaterOut != NULL)
		5714	xf86_initTheaterOut(info->theaterOut , s);
		5715	}
		5716
		5717	}
		5718
		5719
5692	RADEONSave(pScrn);	5720	RADEONSave(pScrn);
5693		5721
5694	if ((!info->IsSecondary) && info->IsMobility) {	5722	if ((!info->IsSecondary) && info->IsMobility) {
Lines 6098-6104 Link Here
6098		6126
6099	/* Init Xv */	6127	/* Init Xv */
6100	RADEONTRACE(("Initializing Xv\n"));	6128	RADEONTRACE(("Initializing Xv\n"));
6101	RADEONInitVideo(pScreen);	6129	// RADEONInitVideo(pScreen);
		6130	RADEONInitVideo(pScreen , info->VIP , TRUE);
6102		6131
6103	if(info->MergedFB)	6132	if(info->MergedFB)
6104	/* need this here to fix up sarea values */	6133	/* need this here to fix up sarea values */
Lines 6314-6320 Link Here
6314	OUTREG(RADEON_OVR_WID_TOP_BOTTOM, restore->ovr_wid_top_bottom);	6343	OUTREG(RADEON_OVR_WID_TOP_BOTTOM, restore->ovr_wid_top_bottom);
6315	OUTREG(RADEON_OV0_SCALE_CNTL, restore->ov0_scale_cntl);	6344	OUTREG(RADEON_OV0_SCALE_CNTL, restore->ov0_scale_cntl);
6316	OUTREG(RADEON_SUBPIC_CNTL, restore->subpic_cntl);	6345	OUTREG(RADEON_SUBPIC_CNTL, restore->subpic_cntl);
6317	OUTREG(RADEON_VIPH_CONTROL, restore->viph_control);	6346	// OUTREG(RADEON_VIPH_CONTROL, restore->viph_control);
		6347	/*
		6348	* fulivi: removed. It messes the VIP access up
		6349	*/
		6350
6318	OUTREG(RADEON_I2C_CNTL_1, restore->i2c_cntl_1);	6351	OUTREG(RADEON_I2C_CNTL_1, restore->i2c_cntl_1);
6319	OUTREG(RADEON_GEN_INT_CNTL, restore->gen_int_cntl);	6352	OUTREG(RADEON_GEN_INT_CNTL, restore->gen_int_cntl);
6320	OUTREG(RADEON_CAP0_TRIG_CNTL, restore->cap0_trig_cntl);	6353	OUTREG(RADEON_CAP0_TRIG_CNTL, restore->cap0_trig_cntl);
Lines 6400-6405 Link Here
6400	OUTREG(RADEON_CRTC_OFFSET, restore->crtc_offset);	6433	OUTREG(RADEON_CRTC_OFFSET, restore->crtc_offset);
6401	OUTREG(RADEON_CRTC_OFFSET_CNTL, restore->crtc_offset_cntl);	6434	OUTREG(RADEON_CRTC_OFFSET_CNTL, restore->crtc_offset_cntl);
6402	OUTREG(RADEON_CRTC_PITCH, restore->crtc_pitch);	6435	OUTREG(RADEON_CRTC_PITCH, restore->crtc_pitch);
		6436	OUTREG(RADEON_DISP_OUTPUT_CNTL, restore->disp_output_cntl);
6403	OUTREG(RADEON_DISP_MERGE_CNTL, restore->disp_merge_cntl);	6437	OUTREG(RADEON_DISP_MERGE_CNTL, restore->disp_merge_cntl);
6404	OUTREG(RADEON_CRTC_MORE_CNTL, restore->crtc_more_cntl);	6438	OUTREG(RADEON_CRTC_MORE_CNTL, restore->crtc_more_cntl);
6405		6439
Lines 6582-6593 Link Here
6582	~(RADEON_P2PLL_ATOMIC_UPDATE_W));	6616	~(RADEON_P2PLL_ATOMIC_UPDATE_W));
6583	}	6617	}
6584		6618
		6619	static CARD8 RADEONComputePLLGain(CARD16 reference_freq,
		6620	CARD16 ref_div,
		6621	CARD16 fb_div)
		6622	{
		6623	unsigned vcoFreq;
		6624
		6625	vcoFreq = ((unsigned)reference_freq * fb_div) / ref_div;
		6626
		6627	/*
		6628	* This is orribly crude: the VCO frequency range is divided into
		6629	* 3 parts, each part having a fixed PLL gain value.
		6630	*/
		6631	if (vcoFreq >= 30000)
		6632	/*
		6633	* [300..max] MHz : 7
		6634	*/
		6635	return 7;
		6636	else if (vcoFreq >= 18000)
		6637	/*
		6638	* [180..300) MHz : 4
		6639	*/
		6640	return 4;
		6641	else
		6642	/*
		6643	* [0..180) MHz : 1
		6644	*/
		6645	return 1;
		6646	}
		6647
		6648
6585	/* Write PLL registers */	6649	/* Write PLL registers */
6586	static void RADEONRestorePLLRegisters(ScrnInfoPtr pScrn,	6650	static void RADEONRestorePLLRegisters(ScrnInfoPtr pScrn,
6587	RADEONSavePtr restore)	6651	RADEONSavePtr restore)
6588	{	6652	{
6589	RADEONInfoPtr info = RADEONPTR(pScrn);	6653	RADEONInfoPtr info = RADEONPTR(pScrn);
6590	unsigned char *RADEONMMIO = info->MMIO;	6654	unsigned char *RADEONMMIO = info->MMIO;
		6655	CARD8 pllGain;
6591		6656
6592	if (info->IsMobility) {	6657	if (info->IsMobility) {
6593	/* A temporal workaround for the occational blanking on certain laptop panels.	6658	/* A temporal workaround for the occational blanking on certain laptop panels.
Lines 6610-6624 Link Here
6610	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,	6675	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,
6611	RADEON_VCLK_SRC_SEL_CPUCLK,	6676	RADEON_VCLK_SRC_SEL_CPUCLK,
6612	~(RADEON_VCLK_SRC_SEL_MASK));	6677	~(RADEON_VCLK_SRC_SEL_MASK));
		6678	pllGain = RADEONComputePLLGain(info->pll.reference_freq,
		6679	restore->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
		6680	restore->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK);
		6681
		6682
6613		6683
6614	OUTPLLP(pScrn,	6684	OUTPLLP(pScrn,
6615	RADEON_PPLL_CNTL,	6685	RADEON_PPLL_CNTL,
6616	RADEON_PPLL_RESET	6686	RADEON_PPLL_RESET
6617	\| RADEON_PPLL_ATOMIC_UPDATE_EN	6687	\| RADEON_PPLL_ATOMIC_UPDATE_EN
6618	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN,	6688	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
		6689	\| ((CARD32)pllGain << RADEON_PPLL_PVG_SHIFT),
6619	~(RADEON_PPLL_RESET	6690	~(RADEON_PPLL_RESET
6620	\| RADEON_PPLL_ATOMIC_UPDATE_EN	6691	\| RADEON_PPLL_ATOMIC_UPDATE_EN
6621	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN));	6692	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
		6693	\| RADEON_PPLL_PVG_MASK));
		6694
6622		6695
6623	OUTREGP(RADEON_CLOCK_CNTL_INDEX,	6696	OUTREGP(RADEON_CLOCK_CNTL_INDEX,
6624	RADEON_PLL_DIV_SEL,	6697	RADEON_PLL_DIV_SEL,
Lines 6678-6686 Link Here
6678		6751
6679	usleep(50000); /* Let the clock to lock */	6752	usleep(50000); /* Let the clock to lock */
6680		6753
6681	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,	6754	OUTPLL(pScrn, RADEON_VCLK_ECP_CNTL , restore->vclk_ecp_cntl);
6682	RADEON_VCLK_SRC_SEL_PPLLCLK,	6755
6683	~(RADEON_VCLK_SRC_SEL_MASK));	6756	RADEONTRACE(("VCLK_ECP_CNTL = %08X\n" , restore->vclk_ecp_cntl));
		6757
6684	}	6758	}
6685		6759
6686		6760
Lines 7093-7098 Link Here
7093	save->crtc_offset = INREG(RADEON_CRTC_OFFSET);	7167	save->crtc_offset = INREG(RADEON_CRTC_OFFSET);
7094	save->crtc_offset_cntl = INREG(RADEON_CRTC_OFFSET_CNTL);	7168	save->crtc_offset_cntl = INREG(RADEON_CRTC_OFFSET_CNTL);
7095	save->crtc_pitch = INREG(RADEON_CRTC_PITCH);	7169	save->crtc_pitch = INREG(RADEON_CRTC_PITCH);
		7170	save->disp_output_cntl = INREG(RADEON_DISP_OUTPUT_CNTL);
7096	save->disp_merge_cntl = INREG(RADEON_DISP_MERGE_CNTL);	7171	save->disp_merge_cntl = INREG(RADEON_DISP_MERGE_CNTL);
7097	save->crtc_more_cntl = INREG(RADEON_CRTC_MORE_CNTL);	7172	save->crtc_more_cntl = INREG(RADEON_CRTC_MORE_CNTL);
7098		7173
Lines 7162-7167 Link Here
7162	save->ppll_ref_div = INPLL(pScrn, RADEON_PPLL_REF_DIV);	7237	save->ppll_ref_div = INPLL(pScrn, RADEON_PPLL_REF_DIV);
7163	save->ppll_div_3 = INPLL(pScrn, RADEON_PPLL_DIV_3);	7238	save->ppll_div_3 = INPLL(pScrn, RADEON_PPLL_DIV_3);
7164	save->htotal_cntl = INPLL(pScrn, RADEON_HTOTAL_CNTL);	7239	save->htotal_cntl = INPLL(pScrn, RADEON_HTOTAL_CNTL);
		7240	save->vclk_ecp_cntl= INPLL(pScrn, RADEON_VCLK_ECP_CNTL);
7165		7241
7166	RADEONTRACE(("Read: 0x%08x 0x%08x 0x%08x\n",	7242	RADEONTRACE(("Read: 0x%08x 0x%08x 0x%08x\n",
7167	save->ppll_ref_div,	7243	save->ppll_ref_div,
Lines 7171-7176 Link Here
7171	save->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,	7247	save->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
7172	save->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK,	7248	save->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK,
7173	(save->ppll_div_3 & RADEON_PPLL_POST3_DIV_MASK) >> 16));	7249	(save->ppll_div_3 & RADEON_PPLL_POST3_DIV_MASK) >> 16));
		7250	RADEONTRACE(("Read VCLK_ECP_CNTL = %08x\n" , save->vclk_ecp_cntl));
7174	}	7251	}
7175		7252
7176	/* Read PLL registers */	7253	/* Read PLL registers */
Lines 7279-7284 Link Here
7279	RADEONSaveMode(pScrn, save);	7356	RADEONSaveMode(pScrn, save);
7280	if (!info->IsSecondary)	7357	if (!info->IsSecondary)
7281	RADEONSaveSurfaces(pScrn, save);	7358	RADEONSaveSurfaces(pScrn, save);
		7359
		7360	/*
		7361	* Save initial RT state
		7362	*/
		7363	if(info->theaterOut != NULL)
		7364	xf86_theaterOutSave(info->theaterOut , pScrn);
7282	}	7365	}
7283		7366
7284	/* Restore the original (text) mode */	7367	/* Restore the original (text) mode */
Lines 7321-7326 Link Here
7321	if (!info->IsSecondary)	7404	if (!info->IsSecondary)
7322	RADEONRestoreSurfaces(pScrn, restore);	7405	RADEONRestoreSurfaces(pScrn, restore);
7323		7406
		7407	/*
		7408	* Restore RT state
		7409	*/
		7410	if (info->theaterOut != NULL)
		7411	xf86_theaterOutRestore(info->theaterOut , pScrn);
7324	#if 0	7412	#if 0
7325	/* Temp fix to "solve" VT switch problems. When switching VTs on	7413	/* Temp fix to "solve" VT switch problems. When switching VTs on
7326	* some systems, the console can either hang or the fonts can be	7414	* some systems, the console can either hang or the fonts can be
Lines 8072-8078 Link Here
8072	save->crtc2_gen_cntl = (RADEON_CRTC2_EN \| (format << 8));	8160	save->crtc2_gen_cntl = (RADEON_CRTC2_EN \| (format << 8));
8073	save->fp2_h_sync_strt_wid = save->crtc2_h_sync_strt_wid;	8161	save->fp2_h_sync_strt_wid = save->crtc2_h_sync_strt_wid;
8074	save->fp2_v_sync_strt_wid = save->crtc2_v_sync_strt_wid;	8162	save->fp2_v_sync_strt_wid = save->crtc2_v_sync_strt_wid;
8075	save->fp2_gen_cntl = info->SavedReg.fp2_gen_cntl \| RADEON_FP2_ON;	8163	save->fp2_gen_cntl = info->SavedReg.fp2_gen_cntl
		8164	\| RADEON_FP2_SRC_SEL_CRTC2
		8165	\| RADEON_FP2_ON;
		8166
8076	save->fp2_gen_cntl &= ~(RADEON_FP2_BLANK_EN);	8167	save->fp2_gen_cntl &= ~(RADEON_FP2_BLANK_EN);
8077		8168
8078	if ((info->ChipFamily == CHIP_FAMILY_R200) \|\|	8169	if ((info->ChipFamily == CHIP_FAMILY_R200) \|\|
Lines 8418-8432 Link Here
8418	pll->reference_freq);	8509	pll->reference_freq);
8419	save->post_div = post_div->divider;	8510	save->post_div = post_div->divider;
8420		8511
8421	RADEONTRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",	8512	/* RADEONTRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",
8422	save->dot_clock_freq,	8513	save->dot_clock_freq,
8423	save->pll_output_freq,	8514	save->pll_output_freq,
8424	save->feedback_div,	8515	save->feedback_div,
8425	save->post_div));	8516	save->post_div));
		8517	*/
8426		8518
8427	save->ppll_ref_div = pll->reference_div;	8519	save->ppll_ref_div = pll->reference_div;
8428	save->ppll_div_3 = (save->feedback_div \| (post_div->bitvalue << 16));	8520	save->ppll_div_3 = (save->feedback_div \| (post_div->bitvalue << 16));
8429	save->htotal_cntl = 0;	8521	save->htotal_cntl = 0;
		8522	save->vclk_ecp_cntl = (save->vclk_ecp_cntl & ~RADEON_VCLK_SRC_SEL_MASK) \| RADEON_VCLK_SRC_SEL_PPLLCLK;
8430	}	8523	}
8431		8524
8432	/* Define PLL2 registers for requested video mode */	8525	/* Define PLL2 registers for requested video mode */
Lines 8480-8490 Link Here
8480	pll->reference_freq);	8573	pll->reference_freq);
8481	save->post_div_2 = post_div->divider;	8574	save->post_div_2 = post_div->divider;
8482		8575
		8576	/*
8483	RADEONTRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",	8577	RADEONTRACE(("dc=%d, of=%d, fd=%d, pd=%d\n",
8484	save->dot_clock_freq_2,	8578	save->dot_clock_freq_2,
8485	save->pll_output_freq_2,	8579	save->pll_output_freq_2,
8486	save->feedback_div_2,	8580	save->feedback_div_2,
8487	save->post_div_2));	8581	save->post_div_2));
		8582	*/
8488		8583
8489	save->p2pll_ref_div = pll->reference_div;	8584	save->p2pll_ref_div = pll->reference_div;
8490	save->p2pll_div_0 = (save->feedback_div_2 \|	8585	save->p2pll_div_0 = (save->feedback_div_2 \|
Lines 8559-8564 Link Here
8559	#endif	8654	#endif
8560		8655
8561	info->Flags = mode->Flags;	8656	info->Flags = mode->Flags;
		8657	/*
		8658	* Some registers are initialized from text mode state
		8659	*/
		8660	save->disp_output_cntl = RADEONPTR(pScrn)->SavedReg.disp_output_cntl;
		8661	save->vclk_ecp_cntl = RADEONPTR(pScrn)->SavedReg.vclk_ecp_cntl;
		8662
8562		8663
8563	RADEONInitMemMapRegisters(pScrn, save, info);	8664	RADEONInitMemMapRegisters(pScrn, save, info);
8564	RADEONInitCommonRegisters(save, info);	8665	RADEONInitCommonRegisters(save, info);
Lines 8627-8635 Link Here
8627		8728
8628	if (!RADEONInit(pScrn, mode, &info->ModeReg)) return FALSE;	8729	if (!RADEONInit(pScrn, mode, &info->ModeReg)) return FALSE;
8629		8730
		8731	/*
		8732	* Define RT state
		8733	*/
		8734	if (info->theaterOut != NULL)
		8735	{
		8736	Bool res = xf86_theaterOutInit(info->theaterOut , mode , &info->ModeReg);
		8737	RADEONTRACE(("theaterOutInit returns %d\n" , res));
		8738	}
		8739
8630	pScrn->vtSema = TRUE;	8740	pScrn->vtSema = TRUE;
8631	RADEONBlank(pScrn);	8741	RADEONBlank(pScrn);
8632	RADEONRestoreMode(pScrn, &info->ModeReg);	8742	RADEONRestoreMode(pScrn, &info->ModeReg);
		8743
		8744	/*
		8745	* Set RT to new mode
		8746	*/
		8747	if (info->theaterOut != NULL)
		8748	xf86_theaterOutRestoreMode(info->theaterOut , pScrn);
		8749
8633	RADEONUnblank(pScrn);	8750	RADEONUnblank(pScrn);
8634		8751
8635	info->CurrentLayout.mode = mode;	8752	info->CurrentLayout.mode = mode;
Lines 9985-9987 Link Here
9985	pScrn->FreeScreen = RADEONFreeScreen;	10102	pScrn->FreeScreen = RADEONFreeScreen;
9986	pScrn->ValidMode = RADEONValidMode;	10103	pScrn->ValidMode = RADEONValidMode;
9987	}	10104	}
		10105
		10106
		10107	/*
		10108	* fulivi: interface functions between RADEONSet/GetPortAttribute (in radeon_video.c) and
		10109	* theater_out module.
		10110	*/
		10111	static void RADEONRedoSwitchMode(ScrnInfoPtr pScrn)
		10112	{
		10113	int scrnIndex = pScrn->scrnIndex;
		10114
		10115	/*
		10116	* It seems that last parameter (flags) is not used
		10117	*/
		10118	RADEONSwitchMode(scrnIndex , pScrn->currentMode , 0);
		10119	}
		10120
		10121	void RADEONTheaterOutSetStandard(ScrnInfoPtr pScrn,
		10122	TVStd std)
		10123	{
		10124	RADEONInfoPtr info = RADEONPTR(pScrn);
		10125
		10126	RADEONTRACE(("RADEONTheaterOutSetStandard std = %d" , std));
		10127
		10128	if (info->theaterOut != NULL && xf86_theaterOutSetStandard(info->theaterOut , std))
		10129	RADEONRedoSwitchMode(pScrn);
		10130	}
		10131
		10132	TVStd RADEONTheaterOutGetStandard(ScrnInfoPtr pScrn)
		10133	{
		10134	RADEONInfoPtr info = RADEONPTR(pScrn);
		10135
		10136	if (info->theaterOut != NULL)
		10137	return xf86_theaterOutGetStandard(info->theaterOut);
		10138	else
		10139	return TV_STD_KEEP_OFF;
		10140	}
		10141
		10142	Bool RADEONTheaterOutGetCompatMode(ScrnInfoPtr pScrn)
		10143	{
		10144	RADEONInfoPtr info = RADEONPTR(pScrn);
		10145
		10146	if (info->theaterOut != NULL)
		10147	return xf86_theaterOutGetCompatMode(info->theaterOut);
		10148	else
		10149	return FALSE;
		10150	}
		10151
		10152	void RADEONTheaterOutSetAttr(ScrnInfoPtr pScrn,
		10153	TheaterOutAttr attr,
		10154	int value)
		10155	{
		10156	RADEONInfoPtr info = RADEONPTR(pScrn);
		10157
		10158	if (info->theaterOut != NULL)
		10159	xf86_theaterOutSetAttr(info->theaterOut , attr , value);
		10160	}
		10161
		10162	int RADEONTheaterOutGetAttr(ScrnInfoPtr pScrn,
		10163	TheaterOutAttr attr)
		10164	{
		10165	RADEONInfoPtr info = RADEONPTR(pScrn);
		10166
		10167	if (info->theaterOut != NULL)
		10168	return xf86_theaterOutGetAttr(info->theaterOut , attr);
10169	else
10170	return 0;
10171	}
10172
10173	void RADEONTheaterOutGetAttrLimits(ScrnInfoPtr pScrn,
10174	TheaterOutAttr attr,
10175	int *maxValue,
10176	int *minValue)
10177	{
10178	RADEONInfoPtr info = RADEONPTR(pScrn);
10179
10180	if (info->theaterOut != NULL)
10181	xf86_theaterOutGetAttrLimits(info->theaterOut , attr , maxValue , minValue);
10182	}

Lines 77-83 Link Here

(-)xf86-video-ati-6.5.8.0/src/radeon_video.c (-12 / +103 lines)
77		77
78	static void RADEONInitOffscreenImages(ScreenPtr);	78	static void RADEONInitOffscreenImages(ScreenPtr);
79		79
80	static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr);	80	static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr , GENERIC_BUS_Ptr , Bool);
81	static int RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);	81	static int RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);
82	static int RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);	82	static int RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);
83	static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);	83	static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);
Lines 118-123 Link Here
118		118
119	static Atom xvOvAlpha, xvGrAlpha, xvAlphaMode;	119	static Atom xvOvAlpha, xvGrAlpha, xvAlphaMode;
120		120
		121	static Atom xvTvoStandard , xvTvoModeCompat;
		122
		123	typedef struct
		124	{
		125	char *name;
		126	TheaterOutAttr attr;
		127	Atom atom;
		128	} TVOAttr;
		129
		130	static
		131	TVOAttr theaterOutAttrs[] =
		132	{
		133	{"XV_TVO_HPOS" , THEATER_OUT_HPOS , 0 },
		134	{"XV_TVO_VPOS" , THEATER_OUT_VPOS , 0 },
		135	{"XV_TVO_HSIZE" , THEATER_OUT_HSIZE , 0 }
		136	};
		137	#define N_TVO_ATTRS (sizeof(theaterOutAttrs) / sizeof(theaterOutAttrs[ 0 ]))
121		138
122	#define GET_PORT_PRIVATE(pScrn) \	139	#define GET_PORT_PRIVATE(pScrn) \
123	(RADEONPortPrivPtr)((RADEONPTR(pScrn))->adaptor->pPortPrivates[0].ptr)	140	(RADEONPortPrivPtr)((RADEONPTR(pScrn))->adaptor->pPortPrivates[0].ptr)
Lines 136-149 Link Here
136	}	153	}
137	#endif /* USE_EXA */	154	#endif /* USE_EXA */
138		155
139	void RADEONInitVideo(ScreenPtr pScreen)	156	void RADEONInitVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
140	{	157	{
141	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];	158	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
142	XF86VideoAdaptorPtr adaptors, newAdaptors = NULL;	159	XF86VideoAdaptorPtr adaptors, newAdaptors = NULL;
143	XF86VideoAdaptorPtr newAdaptor = NULL;	160	XF86VideoAdaptorPtr newAdaptor = NULL;
144	int num_adaptors;	161	int num_adaptors;
145		162
146	newAdaptor = RADEONSetupImageVideo(pScreen);	163	newAdaptor = RADEONSetupImageVideo(pScreen , VIP , loadTheatre);
147	RADEONInitOffscreenImages(pScreen);	164	RADEONInitOffscreenImages(pScreen);
148	num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);	165	num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
149		166
Lines 236-242 Link Here
236		253
237	#endif	254	#endif
238		255
239	#define NUM_ATTRIBUTES 22	256	//#define NUM_ATTRIBUTES 22
		257	#define NUM_ATTRIBUTES 22+5
240	#define NUM_DEC_ATTRIBUTES (NUM_ATTRIBUTES+12)	258	#define NUM_DEC_ATTRIBUTES (NUM_ATTRIBUTES+12)
241		259
242	static XF86AttributeRec Attributes[NUM_DEC_ATTRIBUTES+1] =	260	static XF86AttributeRec Attributes[NUM_DEC_ATTRIBUTES+1] =
Lines 252-257 Link Here
252	{XvSettable \| XvGettable, 0, 255, "XV_OVERLAY_ALPHA"},	270	{XvSettable \| XvGettable, 0, 255, "XV_OVERLAY_ALPHA"},
253	{XvSettable \| XvGettable, 0, 255, "XV_GRAPHICS_ALPHA"},	271	{XvSettable \| XvGettable, 0, 255, "XV_GRAPHICS_ALPHA"},
254	{XvSettable \| XvGettable, 0, 1, "XV_ALPHA_MODE"},	272	{XvSettable \| XvGettable, 0, 1, "XV_ALPHA_MODE"},
		273
		274	{XvSettable \| XvGettable, 0, TV_STD_N_STANDARDS-1, "XV_TVO_STANDARD"},
		275	{ XvGettable, 0, ~0, "XV_TVO_MODE_COMPAT"},
		276	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_HPOS"},
		277	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_VPOS"},
		278	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_HSIZE"},
		279
255	{XvSettable \| XvGettable, -1000, 1000, "XV_BRIGHTNESS"},	280	{XvSettable \| XvGettable, -1000, 1000, "XV_BRIGHTNESS"},
256	{XvSettable \| XvGettable, -1000, 1000, "XV_CONTRAST"},	281	{XvSettable \| XvGettable, -1000, 1000, "XV_CONTRAST"},
257	{XvSettable \| XvGettable, -1000, 1000, "XV_SATURATION"},	282	{XvSettable \| XvGettable, -1000, 1000, "XV_SATURATION"},
Lines 1057-1062 Link Here
1057	RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;	1082	RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;
1058	char tmp[200];	1083	char tmp[200];
1059		1084
		1085	unsigned i;
1060	/* this function is called from ScreenInit. pScreen is used	1086	/* this function is called from ScreenInit. pScreen is used
1061	by XAA internally, but not valid until ScreenInit finishs.	1087	by XAA internally, but not valid until ScreenInit finishs.
1062	*/	1088	*/
Lines 1070-1075 Link Here
1070	xvLocationID = MAKE_ATOM("XV_LOCATION_ID");	1096	xvLocationID = MAKE_ATOM("XV_LOCATION_ID");
1071	xvDumpStatus = MAKE_ATOM("XV_DUMP_STATUS");	1097	xvDumpStatus = MAKE_ATOM("XV_DUMP_STATUS");
1072		1098
		1099	xvTvoStandard = MAKE_ATOM("XV_TVO_STANDARD");
		1100	xvTvoModeCompat = MAKE_ATOM("XV_TVO_MODE_COMPAT");
		1101
		1102	for (i = 0; i < N_TVO_ATTRS; i++)
		1103	{
		1104	char *name;
		1105	name = theaterOutAttrs[ i ].name;
		1106	theaterOutAttrs[ i ].atom = MakeAtom(name, strlen(name), TRUE);
		1107
		1108	RADEONTRACE(("RADEONResetVideo,name=%s,atom=%d\n",name,theaterOutAttrs[ i ].atom));
		1109	}
		1110
1073	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");	1111	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
1074	xvSaturation = MAKE_ATOM("XV_SATURATION");	1112	xvSaturation = MAKE_ATOM("XV_SATURATION");
1075	xvColor = MAKE_ATOM("XV_COLOR");	1113	xvColor = MAKE_ATOM("XV_COLOR");
Lines 1271-1277 Link Here
1271	}	1309	}
1272		1310
1273	static XF86VideoAdaptorPtr	1311	static XF86VideoAdaptorPtr
1274	RADEONAllocAdaptor(ScrnInfoPtr pScrn)	1312	RADEONAllocAdaptor(ScrnInfoPtr pScrn, GENERIC_BUS_Ptr VIP)
1275	{	1313	{
1276	XF86VideoAdaptorPtr adapt;	1314	XF86VideoAdaptorPtr adapt;
1277	RADEONInfoPtr info = RADEONPTR(pScrn);	1315	RADEONInfoPtr info = RADEONPTR(pScrn);
Lines 1397-1403 Link Here
1397	#endif	1435	#endif
1398		1436
1399	/* Initialize VIP bus */	1437	/* Initialize VIP bus */
1400	RADEONVIP_init(pScrn, pPriv);	1438	// RADEONVIP_init(pScrn, pPriv);
		1439	pPriv->VIP = VIP;
		1440
1401	info->adaptor = adapt;	1441	info->adaptor = adapt;
1402		1442
1403	if(!xf86LoadSubModule(pScrn,"theatre_detect"))	1443	if(!xf86LoadSubModule(pScrn,"theatre_detect"))
Lines 1479-1491 Link Here
1479	}	1519	}
1480		1520
1481	static XF86VideoAdaptorPtr	1521	static XF86VideoAdaptorPtr
1482	RADEONSetupImageVideo(ScreenPtr pScreen)	1522	RADEONSetupImageVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
1483	{	1523	{
1484	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];	1524	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
1485	RADEONPortPrivPtr pPriv;	1525	RADEONPortPrivPtr pPriv;
1486	XF86VideoAdaptorPtr adapt;	1526	XF86VideoAdaptorPtr adapt;
		1527	unsigned i;
1487		1528
1488	if(!(adapt = RADEONAllocAdaptor(pScrn)))	1529	if(!(adapt = RADEONAllocAdaptor(pScrn, VIP)))
1489	return NULL;	1530	return NULL;
1490		1531
1491	adapt->type = XvWindowMask \| XvInputMask \| XvImageMask;	1532	adapt->type = XvWindowMask \| XvInputMask \| XvImageMask;
Lines 1511-1516 Link Here
1511	adapt->PutImage = RADEONPutImage;	1552	adapt->PutImage = RADEONPutImage;
1512	adapt->QueryImageAttributes = RADEONQueryImageAttributes;	1553	adapt->QueryImageAttributes = RADEONQueryImageAttributes;
1513		1554
		1555	/*
		1556	* fulivi: set limits of theater_out attributes
		1557	*/
		1558	for (i = 0; i < N_TVO_ATTRS; i++)
		1559	{
		1560	int maxValue;
		1561	int minValue;
		1562	unsigned j;
		1563
		1564	RADEONTheaterOutGetAttrLimits(pScrn , theaterOutAttrs[ i ].attr , &maxValue , &minValue);
		1565
		1566	for (j = 0; i < NUM_DEC_ATTRIBUTES; j++)
		1567	if (strcmp(theaterOutAttrs[ i ].name , Attributes[ j ].name) == 0)
		1568	{
		1569	Attributes[ j ].min_value = minValue;
		1570	Attributes[ j ].max_value = maxValue;
		1571	break;
		1572	}
		1573	}
		1574
1514	pPriv = (RADEONPortPrivPtr)(adapt->pPortPrivates[0].ptr);	1575	pPriv = (RADEONPortPrivPtr)(adapt->pPortPrivates[0].ptr);
1515	REGION_NULL(pScreen, &(pPriv->clip));	1576	REGION_NULL(pScreen, &(pPriv->clip));
1516		1577
Lines 1813-1820 Link Here
1813	RADEON_TDA9885_SetEncoding(pPriv);	1874	RADEON_TDA9885_SetEncoding(pPriv);
1814	}	1875	}
1815	}	1876	}
1816	else	1877	else if (attribute == xvTvoStandard)
1817	return BadMatch;	1878	{
		1879	value = ClipValue(value , 0 , TV_STD_N_STANDARDS-1);
		1880	RADEONTheaterOutSetStandard(pScrn , (TVStd)value);
		1881	}
		1882	else
		1883	{
		1884	unsigned i;
		1885
		1886	for (i = 0; i < N_TVO_ATTRS; i++)
		1887	if (theaterOutAttrs[ i ].atom == attribute)
		1888	{
		1889	RADEONTheaterOutSetAttr(pScrn , theaterOutAttrs[ i ].attr , value);
		1890	break;
		1891	}
		1892	if (i == N_TVO_ATTRS)
		1893	return BadMatch;
		1894	}
1818		1895
1819	if (setTransform)	1896	if (setTransform)
1820	{	1897	{
Lines 1918-1925 Link Here
1918	*value = pPriv->instance_id;	1995	*value = pPriv->instance_id;
1919	else if(attribute == xvAdjustment)	1996	else if(attribute == xvAdjustment)
1920	*value = pPriv->adjustment;	1997	*value = pPriv->adjustment;
1921	else	1998	else if(attribute == xvTvoStandard)
1922	return BadMatch;	1999	*value = (INT32)RADEONTheaterOutGetStandard(pScrn);
		2000	else if(attribute == xvTvoModeCompat)
		2001	*value = (INT32)RADEONTheaterOutGetCompatMode(pScrn);
		2002	else {
		2003	unsigned i;
		2004
		2005	for (i = 0; i < N_TVO_ATTRS; i++) {
		2006	if (theaterOutAttrs[ i ].atom == attribute) {
		2007	*value = (INT32)RADEONTheaterOutGetAttr(pScrn , theaterOutAttrs[ i].attr);
		2008	break;
		2009	}
		2010	}
		2011	if (i == N_TVO_ATTRS)
		2012	return BadMatch;
		2013	}
1923		2014
1924	return Success;	2015	return Success;
1925	}	2016	}

Line 0 Link Here

(-)xf86-video-ati-6.5.8.0/src/README.tvout (+236 lines)
		1
		2	*******************************************************
		3	XFree86 driver for TV output on ATI Radeon cards
		4	*******************************************************
		5
		6	Copyright (c) 2003-2004, by Federico Ulivi <fulivi@lycos.com>
		7	Released under the GNU General Public License, version 2.
		8
		9	1. About this driver
		10	--------------------
		11
		12	This driver was developped as a part of ati.2 project. Its purpose
		13	is to enable the TV output of ATI Radeon cards when running the
		14	XFree86 graphical environment.
		15
		16	2. Status of the driver
		17	-----------------------
		18
		19	The driver is in early development stage. It currently works with
		20	those cards having a Rage Theater chip for TV output or with cards
		21	having the tv module inside the Radeon chip (ERT, Embedded Rage
		22	Theater, is my name for the latter).
		23	The driver was successfully tested on these cards:
		24	- Radeon 7200 / European model (TV out hw: RT 100)
		25	- Radeon 9000 (TV out hw: ERT)
		26	- Radeon 9200SE (TV out hw: ERT)
		27	- Radeon 7000 (TV out hw: ERT)
		28
		29	3. Making it work
		30	-----------------
		31
		32	The driver is always loaded by the Radeon driver. If you need to
		33	disable this auto-loading mechanism, just set the "TVOutput" option
		34	(see below) to "NOLOAD".
		35	In principle the driver should coexist with video grabbing functions,
		36	especially on those AIW cards where TV output is done by ERT
		37	inside Radeon.
		38
		39	Principle of operation of the driver is very simple. Driver enables
		40	tv output whenever the current screen resolution and tv standard match
		41	one of a set of pre-computed combinations. In all other cases tv output
		42	is simply kept disabled.
		43	The driver currently works in the so-called "clone" mode only. This means
		44	that the image on the TV screen is exactly the same as the one on the
		45	monitor.
		46
		47	The driver is enabled by adding a "TVOutput" line in the "device"
		48	section of XF86Config-4 file (this file is usually located in /etc/X11
		49	directory). Syntax of this option is very simple:
		50
		51	Section "Device"
		52	..
		53	..
		54	Option "TVOuput" "<name of tv standard>"
		55	EndSection
		56
		57	Names of recognized TV standards are:
		58	"NTSC"
		59	"NTSC-J"
		60	"PAL"
		61	"PAL-CN"
		62	"PAL-M"
		63	"PAL-N"
		64	"PAL-60"
65
66	If "TVOutput" is not present or its value is invalid, TV output is kept disabled.
67
68	In the current version of the driver these are the recognized TV standard &
69	resolution combinations:
70
71	PAL 800x600
72	NTSC 800x600
73
74	More combinations will be added in future releases.
75
76	4. XV Interface
77	---------------
78
79	The driver has an external interface through some Xv attributes.
80	You can change the value of these attributes by using the tvo_set utility
81	(see below).
82
83	XV_TVO_STANDARD Settable/Gettable
84	This is the tv standard in use by the driver. Its value is encoded
85	according to this table:
86
87	0 NTSC
88	1 PAL
89	2 PAL-M
90	3 PAL-60
91	4 NTSC-J
92	5 PAL-CN
93	6 PAL-N
94	7 Keep TV off
95
96	XV_TVO_MODE_COMPAT Gettable
97	This attribute is set to 1 whenever TV output is enabled, i.e.
98	whenever the current resolution & tv standard combination is
99	recognized by the driver.
100
101	XV_TVO_HPOS Settable/Gettable
102	Horizontal position, valid range is [-5..+5].
103	This attribute defines the horizontal position of the TV image.
104	Higher values shift the image to the right, lower values to the left.
105
106	XV_TVO_VPOS Settable/Gettable
107	Vertical position, valid range is [-5..+5].
108	This attribute defines the vertical position of the TV image.
109	Higher values shift the image upward, lower values downward.
110
111	XV_TVO_HSIZE Settable/Gettable
112	Horizontal size, valid range is [-5..+5].
113	This attribute is used to set the horizontal size of TV image.
114	Higher values enlarge TV lines, lower values reduce them.
115
116	Default value for XV_TVO_HPOS, XV_TVO_VPOS & XV_TVO_HSIZE just after
117	X Window start is 0.
118
119	You might ask where a vertical size attribute has gone. It was not included
120	because it's quite hard to implement (it requires changing many timings in
121	the CRTC). For the moment I'm not planning to work on it.
122
123	5. tvo_set utility
124	------------------
125
126	tvo_set is a command line utility that is used to change TV output
127	attributes while X Window is running. It offers a somewhat more
128	friendly interface to XV_TVO_* attributes.
129
130	This is how to compile tvo_set:
131	- cd to tvo_set directory
132	- xmkmf
133	- make
134	- make install
135	Last step should place the executable (tvo_set) in /usr/X11R6/bin.
136
137	This is the invocation syntax:
138	tvo_set [-display host:dpy] [<cmd> <attribute> [<value>]]
139
140	tvo_set is not case sensitive for <cmd>, <attribute> & <value>
141	fields.
142	When no <cmd> is given, tvo_set just dumps the current state of
143	TV attributes.
144
145	Recognized commands:
146	set <attribute> <value> Set <attribute> to <value>
147	inc <attribute> Increment <attribute> by 1
148	dec <attribute> Decrement <attribute> by 1
149	zero <attribute> Set <attribute> to 0
150
151	Recognized values for <attribute> field:
152	hpos Horizontal position
153	vpos Vertical position
154	hsize Horizontal size
155	std TV Standard
156
157	When setting "std" attribute, both the numeric value and the name of the
158	standard are valid, see following table.
159
160	Table of TV standards:
161	0 NTSC
162	1 PAL
163	2 PAL-M
164	3 PAL-60
165	4 NTSC-J
166	5 PAL-CN
167	6 PAL-N
168	7 OFF
169
170	Examples:
171	"tvo_set set std ntsc"
172	Set standard to NTSC
173
174	"tvo_set set std off"
175	Turn off TV output
176
177	"tvo_set set hsize 5"
178	Set hsize to 5
179
180	"tvo_set inc hpos"
181	Shift image a bit to the right (increment hpos by 1)
182
183	"tvo_set zero vpos"
184	Restore default value for vpos
185
186
187	6. WARNING
188	----------
189
190	It's important that you are aware of the fact that, when TV output is active,
191	the monitor is driven at the same vertical refresh frequency as that of the
192	TV output. This means 50 or 60 Hz according to the standard you're using.
193	NO CHECK IS DONE IN THE DRIVER ABOUT THE CAPABILITY OF THE MONITOR TO
194	SUSTAIN THESE FREQUENCIES. You should look up in the monitor manual
195	and check that 50/60 Hz is within the limits. IT IS POTENTIALLY HARMFUL
196	TO THE MONITOR TO BE DRIVEN AT A FREQUENCY OUTSIDE ITS OPERATING RANGE.
197
198	Note, however, that most monitors should accept a 60 Hz vertical frequency,
199	since this is used in standard VGA modes. You should really check for 50 Hz
200	compatibility if you are going to use any related standard (PAL mostly).
201	ATI manuals recommend checking for 50 Hz compatibility (they take
202	60 Hz for granted).
203
204	One last thing: I did no testing on cards having DVI/LCD outputs
205	so I'm not sure about the driver behaviour with this kind of displays.
206	Be warned.
207
208	6. Credits
209	----------
210
211	Vladimir Dergachev For leading the GATOS project, for all the good
212	advices he gave me about dealing with ATI and for
213	all his precious technical hints.
214
215	ATI external developer office
216	For providing me the Rage Theater documentation.
217
218	7. Revision history
219	--------------------
220
221
222	2003-09-23
223	==========
224
225	Initial release
226
227	2003-11-26
228	==========
229
230	Support for ERT added
231
232	2004-01-27
233	==========
234
235	Support for sizing/positioning of TV image added
236

Line 0 Link Here

(-)xf86-video-ati-6.5.8.0/src/theater_out.h (+370 lines)
		1	/*********************************************************************
		2	*
		3	* $Id: theater_out.h,v 1.1.2.2 2004/01/27 22:50:35 fulivi Exp $
		4	*
		5	* Interface file for theater_out module
		6	*
		7	* Copyright (C) 2003 Federico Ulivi
		8	*
		9	* This program is free software; you can redistribute it and/or modify
		10	* it under the terms of the GNU General Public License as published by
		11	* the Free Software Foundation; either version 2 of the License, or
		12	* (at your option) any later version.
		13	*
		14	* This program is distributed in the hope that it will be useful,
		15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		17	* GNU General Public License for more details.
		18	*
		19	* You should have received a copy of the GNU General Public License
		20	* along with this program; if not, write to the Free Software
		21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		22	*
		23	* AUTHORS: F.Ulivi
		24	* NOTES:
		25	* $Log: theater_out.h,v $
		26	* Revision 1.1.2.2 2004/01/27 22:50:35 fulivi
		27	* Support for positioning/sizing of image added
		28	*
		29	* Revision 1.1.2.9 2004/01/18 23:01:12 fede
		30	* Functions for get/setting h/v pos/size replaced by
		31	* theaterOutSetAttr/theaterOutGetAttr/theaterOutGetAttrLimits
		32	* Circular inclusion with radeon.h fixed
		33	*
		34	* Revision 1.1.2.8 2004/01/11 21:43:32 fede
		35	* Fixed problem with definition of TVStd
		36	*
		37	* Revision 1.1.2.7 2004/01/05 00:09:59 fede
		38	* Functions for setting/getting H/V position added
		39	* Functions for setting/getting on/off attribute removed
		40	*
		41	* Revision 1.1.2.1 2003/11/26 19:50:10 fulivi
		42	* Support for ERT added
		43	*
		44	* Revision 1.1.2.6 2003/11/25 20:44:00 fede
		45	* TV_STD_KEEP_OFF added
		46	*
		47	* Revision 1.1.2.5 2003/10/14 18:41:32 fede
		48	* forceERT changed to forceVIP
		49	*
		50	* Revision 1.1.2.4 2003/10/11 12:30:30 fede
		51	* Support for ERT added
		52	*
		53	* Revision 1.1 2003/09/28 21:42:37 fulivi
		54	* Theater_out module added
		55	*
		56	* Revision 1.1.2.3 2003/09/28 15:26:09 fede
		57	* Minor aesthetic changes
		58	*
		59	* Revision 1.1.2.1 2003/08/31 13:36:35 fede
		60	* * empty log message *
		61	*
		62	*
		63	*********************************************************************/
		64
65	#ifndef _THEATER_OUT_H
66	#define _THEATER_OUT_H
67
68	/**********************************************************************
69	*
70	* TheaterOutPtr
71	*
72	* Pointer to TheaterOut struct. Actual definition is in theater_out.c
73	*
74	**********************************************************************/
75	typedef struct TheaterOut *TheaterOutPtr;
76
77	/**********************************************************************
78	*
79	* TVStd
80	*
81	* Tv standard
82	*
83	**********************************************************************/
84	typedef enum
85	{
86	TV_STD_NTSC,
87	TV_STD_PAL,
88	TV_STD_PAL_M,
89	TV_STD_PAL_60,
90	TV_STD_NTSC_J,
91	TV_STD_PAL_CN,
92	TV_STD_PAL_N,
93	TV_STD_KEEP_OFF,
94	TV_STD_N_STANDARDS /* Must be last */
95	} TVStd;
96
97	/**********************************************************************
98	*
99	* TheaterOutAttr
100	*
101	* Integer-valued attributes of this module
102	*
103	**********************************************************************/
104	typedef enum
105	{
106	THEATER_OUT_HPOS, /* Horizontal position */
107	THEATER_OUT_VPOS, /* Vertical position */
108	THEATER_OUT_HSIZE /* Horizontal size */
109	} TheaterOutAttr;
110
111	#ifndef _RADEON_H_
112	#include "radeon.h"
113	#endif
114
115	/**********************************************************************
116	*
117	* detectTheaterOut
118	*
119	* Detect presence of a RT chip
120	*
121	**********************************************************************/
122
123	extern
124	TheaterOutPtr
125	detectTheaterOut(
126	ScrnInfoPtr pScrn,
127	Bool forceVIP,
128	GENERIC_BUS_Ptr b
129	);
130
131	/**********************************************************************
132	*
133	* initTheaterOut
134	*
135	* Initialization of module
136	*
137	* 's' should be the value of TV_Output option (i.e. the initial TV
138	* standard)
139	*
140	**********************************************************************/
141
142	extern
143	void
144	initTheaterOut(
145	TheaterOutPtr t,
146	const char *s
147	);
148
149	/**********************************************************************
150	*
151	* theaterOutSave
152	*
153	* Save current state of RT as initial state (the one that is restored
154	* when switching back to text mode)
155	*
156	**********************************************************************/
157
158	extern
159	void
160	theaterOutSave(
161	TheaterOutPtr t,
162	ScrnInfoPtr pScrn
163	);
164
165	/**********************************************************************
166	*
167	* theaterOutRestore
168	*
169	* Restore state of RT from initial state (the one saved through
170	* theaterOutSave)
171	*
172	**********************************************************************/
173
174	extern
175	void
176	theaterOutRestore(
177	TheaterOutPtr t,
178	ScrnInfoPtr pScrn
179	);
180
181	/**********************************************************************
182	*
183	* theaterOutInit
184	*
185	* Define state for cloning current CRTC mode on TV output
186	* It works in this way:
187	* 1. It checks if resolution in "mode" parameter is one of those
188	* allowing tv output
189	* 2. If resolution is OK, define RT state according to resolution and
190	* and current settings (tv standard etc.)
191	* If resolution is not ok, define RT state to turn tv output off
192	* 3. If resolution is OK, modify Radeon state to make it correct for
193	* tv output (this is needed,e.g., to set vertical frequency to 50/60 Hz)
194	*
195	* Return value is TRUE when mode is OK for cloning on tv and tv output
196	* is enabled, FALSE otherwise
197	*
198	**********************************************************************/
199
200	extern
201	Bool
202	theaterOutInit(
203	TheaterOutPtr t,
204	DisplayModePtr mode,
205	RADEONSavePtr save
206	);
207
208	/**********************************************************************
209	*
210	* theaterOutRestoreMode
211	*
212	* Set state of RT to the one defined by last call to theaterOutInit
213	*
214	**********************************************************************/
215
216	extern
217	void
218	theaterOutRestoreMode(
219	TheaterOutPtr t,
220	ScrnInfoPtr pScrn
221	);
222
223	/**********************************************************************
224	*
225	* theaterOutSetStandard
226	*
227	* Set TV output standard
228	*
229	* Return value is TRUE when video mode should be set again
230	*
231	**********************************************************************/
232
233	extern
234	Bool
235	theaterOutSetStandard(
236	TheaterOutPtr t,
237	TVStd std
238	);
239
240	/**********************************************************************
241	*
242	* theaterOutGetStandard
243	*
244	* Get current TV output standard
245	*
246	**********************************************************************/
247	extern
248	TVStd
249	theaterOutGetStandard(
250	TheaterOutPtr t
251	);
252
253	/**********************************************************************
254	*
255	* theaterOutGetCompatMode
256	*
257	* Return whether the current mode is compatible with tv output or not
258	*
259	**********************************************************************/
260	extern
261	Bool
262	theaterOutGetCompatMode(
263	TheaterOutPtr t
264	);
265
266	/**********************************************************************
267	*
268	* theaterOutSetAttr
269	*
270	* Set an attribute
271	*
272	**********************************************************************/
273	extern
274	void
275	theaterOutSetAttr(
276	TheaterOutPtr t,
277	TheaterOutAttr attr,
278	int value
279	);
280
281	/**********************************************************************
282	*
283	* theaterOutGetAttr
284	*
285	* Get an attribute
286	*
287	**********************************************************************/
288	extern
289	int
290	theaterOutGetAttr(
291	TheaterOutPtr t,
292	TheaterOutAttr attr
293	);
294
295	/**********************************************************************
296	*
297	* theaterOutGetAttrLimits
298	*
299	* Get limits for an attribute value
300	*
301	**********************************************************************/
302	extern
303	void
304	theaterOutGetAttrLimits(
305	TheaterOutPtr t,
306	TheaterOutAttr attr,
307	int *maxValue,
308	int *minValue
309	);
310
311	/**********************************************************************
312	*
313	* THEATER_OUT_SYMBOLS
314	*
315	* Symbol list for module loading
316	*
317	**********************************************************************/
318
319	#define THEATER_OUT_SYMBOLS "detectTheaterOut", \
320	"initTheaterOut", \
321	"theaterOutSave", \
322	"theaterOutRestore", \
323	"theaterOutInit", \
324	"theaterOutRestoreMode", \
325	"theaterOutSetStandard", \
326	"theaterOutGetStandard", \
327	"theaterOutGetCompatMode", \
328	"theaterOutSetAttr", \
329	"theaterOutGetAttr", \
330	"theaterOutGetAttrLimits"
331
332	/**********************************************************************
333	*
334	* External access to module functions
335	*
336	**********************************************************************/
337
338	#ifdef XFree86LOADER
339
340	#define xf86_detectTheaterOut ((TheaterOutPtr (*)(ScrnInfoPtr , Bool,GENERIC_BUS_Ptr))LoaderSymbol("detectTheaterOut"))
341	#define xf86_initTheaterOut ((void ()(TheaterOutPtr , const char))LoaderSymbol("initTheaterOut"))
342	#define xf86_theaterOutSave ((void (*)(TheaterOutPtr , ScrnInfoPtr))LoaderSymbol("theaterOutSave"))
343	#define xf86_theaterOutRestore ((void (*)(TheaterOutPtr , ScrnInfoPtr))LoaderSymbol("theaterOutRestore"))
344	#define xf86_theaterOutInit ((Bool (*)(TheaterOutPtr , DisplayModePtr , RADEONSavePtr))LoaderSymbol("theaterOutInit"))
345	#define xf86_theaterOutRestoreMode ((void (*)(TheaterOutPtr , ScrnInfoPtr))LoaderSymbol("theaterOutRestoreMode"))
346	#define xf86_theaterOutSetStandard ((Bool (*)(TheaterOutPtr , TVStd))LoaderSymbol("theaterOutSetStandard"))
347	#define xf86_theaterOutGetStandard ((TVStd (*)(TheaterOutPtr))LoaderSymbol("theaterOutGetStandard"))
348	#define xf86_theaterOutGetCompatMode ((Bool (*)(TheaterOutPtr))LoaderSymbol("theaterOutGetCompatMode"))
349	#define xf86_theaterOutSetAttr ((void (*)(TheaterOutPtr , TheaterOutAttr , int))LoaderSymbol("theaterOutSetAttr"))
350	#define xf86_theaterOutGetAttr ((int (*)(TheaterOutPtr , TheaterOutAttr))LoaderSymbol("theaterOutGetAttr"))
351	#define xf86_theaterOutGetAttrLimits ((void ()(TheaterOutPtr , TheaterOutAttr , int , int *))LoaderSymbol("theaterOutGetAttrLimits"))
352
353	#else
354
355	#define xf86_detectTheaterOut detectTheaterOut
356	#define xf86_initTheaterOut initTheaterOut
357	#define xf86_theaterOutSave theaterOutSave
358	#define xf86_theaterOutRestore theaterOutRestore
359	#define xf86_theaterOutInit theaterOutInit
360	#define xf86_theaterOutRestoreMode theaterOutRestoreMode
361	#define xf86_theaterOutSetStandard theaterOutSetStandard
362	#define xf86_theaterOutGetStandard theaterOutGetStandard
363	#define xf86_theaterOutGetCompatMode theaterOutGetCompatMode
364	#define xf86_theaterOutSetAttr theaterOutSetAttr
365	#define xf86_theaterOutGetAttr theaterOutGetAttr
366	#define xf86_theaterOutGetAttrLimits theaterOutGetAttrLimits
367
368	#endif /* XFree86LOADER */
369
370	#endif /* _THEATER_OUT_H */

Line 0 Link Here

(-)xf86-video-ati-6.5.8.0/src/theater_out_module.c (+45 lines)
	1	#ifdef HAVE_CONFIG_H
	2	#include "config.h"
	3	#endif
	4
	5	#include "xf86Module.h"
	6
	7	static MODULESETUPPROTO(theaterOutSetup);
	8
	9	static
	10	XF86ModuleVersionInfo
	11	theaterVersRec =
	12	{
	13	"theater_out", /* modname */
	14	MODULEVENDORSTRING, /* vendor */
	15	MODINFOSTRING1, /* _modinfo1_ */
	16	MODINFOSTRING2, /* _modinfo2_ */
	17	XORG_VERSION_CURRENT, /* xf86version */
	18	1, /* majorversion */
	19	0, /* minorversion */
	20	0, /* patchlevel */
	21	ABI_CLASS_VIDEODRV, /* abiclass */
	22	ABI_VIDEODRV_VERSION, /* abiversion */
	23	MOD_CLASS_NONE, /* moduleclass */
	24	{ 0 , 0 , 0 , 0 } /* checksum */
	25	};
	26
	27	_X_EXPORT XF86ModuleData
	28	theater_outModuleData =
	29	{
	30	&theaterVersRec,
	31	theaterOutSetup,
	32	NULL
	33	};
	34
	35	static
	36	pointer
	37	theaterOutSetup(
	38	pointer module,
	39	pointer opts,
	40	int *errmaj,
	41	int *errmin
	42	)
	43	{
	44	return (pointer)1;
	45	}

Line 0 Link Here

(-)xf86-video-ati-6.5.8.0/src/tvo_set/Imakefile (+37 lines)
	1	XCOMM $Id: Imakefile,v 1.1.2.1 2004/01/27 22:55:40 fulivi Exp $
	2	XCOMM
	3	XCOMM Imakefile for tvo_set utility
	4	XCOMM
	5	XCOMM Copyright (C) 2004 Federico Ulivi
	6	XCOMM
	7	XCOMM This program is free software; you can redistribute it and/or modify
	8	XCOMM it under the terms of the GNU General Public License as published by
	9	XCOMM the Free Software Foundation; either version 2 of the License, or
	10	XCOMM (at your option) any later version.
	11	XCOMM
	12	XCOMM This program is distributed in the hope that it will be useful,
	13	XCOMM but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	XCOMM MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	XCOMM GNU General Public License for more details.
	16	XCOMM
	17	XCOMM You should have received a copy of the GNU General Public License
	18	XCOMM along with this program; if not, write to the Free Software
	19	XCOMM Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	XCOMM
	21	XCOMM AUTHORS: F.Ulivi
	22	XCOMM NOTES:
	23	XCOMM $Log: Imakefile,v $
	24	XCOMM Revision 1.1.2.1 2004/01/27 22:55:40 fulivi
	25	XCOMM Initial release
	26	XCOMM
	27	XCOMM Revision 1.1.2.1 2004/01/25 23:07:31 fede
	28	XCOMM * empty log message *
	29	XCOMM
	30	XCOMM
	31
	32	DEPLIBS = $(DEPXVLIB) $(DEPXLIB)
	33	LOCAL_LIBRARIES = $(XVLIB) $(XLIB)
	34	SRCS = tvo_set.c
	35	OBJS = tvo_set.o
	36
	37	ComplexProgramTargetNoMan(tvo_set)

Line 0 Link Here

(-)xf86-video-ati-6.5.8.0/src/tvo_set/tvo_set.c (+472 lines)
		1	/*********************************************************************
		2	*
		3	* $Id: tvo_set.c,v 1.1.2.1 2004/01/27 22:55:40 fulivi Exp $
		4	*
		5	* Main (and only) module of tvo_set utility.
		6	* The purpose of this utility is to set various parameters of
		7	* tv output module.
		8	*
		9	* Copyright (C) 2004 Federico Ulivi
		10	*
		11	* This program is free software; you can redistribute it and/or modify
		12	* it under the terms of the GNU General Public License as published by
		13	* the Free Software Foundation; either version 2 of the License, or
		14	* (at your option) any later version.
		15	*
		16	* This program is distributed in the hope that it will be useful,
		17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		19	* GNU General Public License for more details.
		20	*
		21	* You should have received a copy of the GNU General Public License
		22	* along with this program; if not, write to the Free Software
		23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		24	*
		25	* AUTHORS: F.Ulivi
		26	* NOTES:
		27	* $Log: tvo_set.c,v $
		28	* Revision 1.1.2.1 2004/01/27 22:55:40 fulivi
		29	* Initial release
		30	*
		31	* Revision 1.1.2.2 2004/01/25 23:07:47 fede
		32	* GPL notice added
		33	*
		34	* Revision 1.1.2.1 2004/01/25 15:09:42 fede
		35	* First version
		36	*
		37	*
		38	*********************************************************************/
		39
		40	#include <X11/X.h>
		41	#include <X11/Xlib.h>
		42	#include <X11/extensions/Xvlib.h>
		43	#include <stdio.h>
		44	#include <stdlib.h>
		45	#include <errno.h>
		46	#include <string.h>
		47
		48	/**********************************************************************
		49	*
		50	* program_name
		51	*
		52	**********************************************************************/
		53	static
		54	const char *program_name;
		55
		56	/**********************************************************************
		57	*
		58	* Action
		59	*
		60	**********************************************************************/
		61	typedef enum
		62	{
		63	ACT_FULL_DUMP,
		64	ACT_SET,
65	ACT_INC,
66	ACT_DEC,
67	ACT_ZERO
68	} Action;
69
70	/**********************************************************************
71	*
72	* attrNames / attrData
73	*
74	**********************************************************************/
75	typedef struct
76	{
77	Atom atom;
78	int minValue;
79	int maxValue;
80	} AttrData;
81
82	typedef struct
83	{
84	char* extName;
85	char* attrName;
86	char* description;
87	} AttrName;
88
89	static
90	const AttrName attrNames[] =
91	{
92	{ "hpos" , "XV_TVO_HPOS" , "Horizontal position" },
93	{ "vpos" , "XV_TVO_VPOS" , "Vertical position" },
94	{ "hsize" , "XV_TVO_HSIZE" , "Horizontal size" },
95	{ "std" , "XV_TVO_STANDARD" , "TV Standard" }
96	};
97
98	#define N_ATTRS (sizeof(attrNames) / sizeof(attrNames[ 0 ]))
99	/*
100	* Index of TV standard attribute
101	*/
102	#define STD_ATTR 3
103
104	static
105	AttrData attrData[ N_ATTRS ];
106
107	/**********************************************************************
108	*
109	* stdNames
110	*
111	**********************************************************************/
112	static
113	const char *stdNames[] =
114	{
115	"NTSC",
116	"PAL",
117	"PAL-M",
118	"PAL-60",
119	"NTSC-J",
120	"PAL-CN",
121	"PAL-N",
122	"OFF"
123	};
124	#define N_STDS (sizeof(stdNames) / sizeof(stdNames[ 0 ]))
125
126	/**********************************************************************
127	*
128	* scanAttributes
129	*
130	**********************************************************************/
131	static
132	Bool
133	subScanAttributes(
134	Display *dpy,
135	XvAttribute *pAttributes,
136	int nAttributes
137	)
138	{
139	unsigned i;
140	unsigned j;
141	Atom theAtom;
142
143	for (i = 0; i < N_ATTRS; i++)
144	{
145	const char* name = attrNames[ i ].attrName;
146
147	for (j = 0; j < nAttributes; j++)
148	{
149	if (strcmp(name , pAttributes[ j ].name) == 0)
150	{
151	attrData[ i ].minValue = pAttributes[ j ].min_value;
152	attrData[ i ].maxValue = pAttributes[ j ].max_value;
153	if ((pAttributes[ j ].flags & (XvGettable \| XvSettable)) != (XvGettable \| XvSettable))
154	return False;
155
156	theAtom = XInternAtom(dpy , name , True);
157	if (theAtom == None)
158	return False;
159
160	attrData[ i ].atom = theAtom;
161
162	break;
163	}
164	}
165	if (j == nAttributes)
166	return False;
167	}
168
169	return True;
170	}
171
172	static
173	Bool
174	scanAttributes(
175	Display *dpy,
176	XvPortID portID
177	)
178	{
179	XvAttribute *pAttributes;
180	int nAttributes;
181	Bool res = False;
182
183	if ((pAttributes = XvQueryPortAttributes(dpy , portID , &nAttributes)) == 0)
184	return False;
185
186	if (nAttributes > 0)
187	res = subScanAttributes(dpy , pAttributes , nAttributes);
188
189	XFree(pAttributes);
190	return res;
191	}
192
193	/**********************************************************************
194	*
195	* getAttribute
196	*
197	**********************************************************************/
198	static
199	void
200	getAttribute(
201	Display *dpy,
202	XvPortID portID,
203	int attribute,
204	int *value
205	)
206	{
207	if (XvGetPortAttribute(dpy ,
208	portID ,
209	attrData[ attribute ].atom ,
210	value) == Success)
211	return;
212
213	fprintf(stderr , "%s: Unable to get value of attribute %s\n" , program_name , attrNames[ attribute ].attrName);
214	exit(2);
215	}
216
217	/**********************************************************************
218	*
219	* setAttribute
220	*
221	**********************************************************************/
222	static
223	void
224	setAttribute(
225	Display *dpy,
226	XvPortID portID,
227	int attribute,
228	int value
229	)
230	{
231	int dummy;
232
233	if (XvSetPortAttribute(dpy , portID , attrData[ attribute ].atom , value) != Success)
234	{
235	fprintf(stderr , "%s: Unable to set value of attribute %s\n" , program_name , attrNames[ attribute ].attrName);
236	exit(2);
237	}
238
239	getAttribute(dpy , portID , attribute , &dummy);
240	}
241
242	/**********************************************************************
243	*
244	* parseAttribute
245	*
246	**********************************************************************/
247	static
248	int
249	parseAttribute(
250	const char *name
251	)
252	{
253	int i;
254
255	for (i = 0; i < N_ATTRS; i++)
256	if (strcasecmp(name , attrNames[ i ].extName) == 0)
257	return i;
258
259	return -1;
260	}
261
262	/**********************************************************************
263	*
264	* parseStd
265	*
266	**********************************************************************/
267	static
268	int
269	parseStd(
270	const char *name
271	)
272	{
273	int i;
274
275	for (i = 0; i < N_STDS; i++)
276	if (strcasecmp(name , stdNames[ i ]) == 0)
277	return i;
278
279	return -1;
280	}
281
282	/**********************************************************************
283	*
284	* printUsage
285	*
286	**********************************************************************/
287	static
288	void
289	printUsage(void)
290	{
291	unsigned i;
292
293	fprintf(stderr , "Usage:\n"
294	"%s [-display host:dpy] [<cmd> <attribute> [<value>]]\n\n" , program_name);
295	fprintf(stderr , "When <cmd> is absent, a dump of all attributes is done\n");
296	fprintf(stderr , "Allowed <cmd>s:\n"
297	"set <attribute> <value> Set <attribute> to <value>\n"
298	"inc <attribute> Increment <attribute> by 1\n"
299	"dec <attribute> Decrement <attribute> by 1\n"
300	"zero <attribute> Set <attribute> to 0\n"
301	"\nAllowed <attribute>s:\n");
302
303	for (i = 0; i < N_ATTRS; i++)
304	fprintf(stderr , "%-6s %s\n" , attrNames[ i ].extName , attrNames[ i ].description);
305
306	fprintf(stderr , "\nFor %s attribute, both the numeric value and the name of the standard are valid.\n" ,
307	attrNames[ STD_ATTR ].extName);
308
309	fprintf(stderr , "\nAllowed standards:\n");
310
311	for (i = 0; i < N_STDS; i++)
312	fprintf(stderr , "%d %s\n" , i , stdNames[ i ]);
313
314	exit(1);
315	}
316
317	/**********************************************************************
318	*
319	* main
320	*
321	**********************************************************************/
322	int
323	main(
324	int argc,
325	char *argv[]
326	)
327	{
328	Action action;
329	Display *dpy;
330	char *disname = NULL;
331	unsigned argIdx = 1;
332	int attribute;
333	int value;
334	unsigned ver, rev, eventB, reqB, errorB;
335	XvAdaptorInfo *ainfo;
336	unsigned nadaptors;
337	unsigned i;
338	XvPortID portID;
339
340	program_name = argv[ 0 ];
341
342	if (argc >= 3 &&
343	strcmp(argv[ argIdx ] , "-display") == 0)
344	{
345	argIdx++;
346	disname = argv[ argIdx++ ];
347	}
348
349	if (argIdx < argc)
350	{
351	if (strcasecmp(argv[ argIdx ] , "set") == 0)
352	action = ACT_SET;
353	else if (strcasecmp(argv[ argIdx ] , "inc") == 0)
354	action = ACT_INC;
355	else if (strcasecmp(argv[ argIdx ] , "dec") == 0)
356	action = ACT_DEC;
357	else if (strcasecmp(argv[ argIdx ] , "zero") == 0)
358	action = ACT_ZERO;
359	else
360	printUsage();
361
362	argIdx++;
363	if (argIdx >= argc)
364	printUsage();
365
366	if ((attribute = parseAttribute(argv[ argIdx ])) < 0)
367	{
368	fprintf(stderr , "%s: Unrecognized attribute name (%s)\n" , program_name , argv[ argIdx ]);
369	printUsage();
370	}
371	argIdx++;
372
373	if (action == ACT_SET)
374	{
375	if (argIdx >= argc)
376	printUsage();
377	if (sscanf(argv[ argIdx ] , "%d" , &value) != 1 &&
378	(attribute != STD_ATTR \|\| (value = parseStd(argv[ argIdx ])) < 0))
379	printUsage();
380	}
381	}
382	else
383	action = ACT_FULL_DUMP;
384
385	/*
386	* Open display
387	*/
388	if (!(dpy = XOpenDisplay(disname)))
389	{
390	fprintf(stderr , "%s: Unable to open display %s\n" , program_name ,
391	(disname != NULL) ? disname : XDisplayName(NULL));
392	return -1;
393	}
394
395	if (XvQueryExtension(dpy, &ver, &rev, &reqB, &eventB, &errorB) != Success)
396	{
397	fprintf(stderr , "%s: No XV Extension on %s\n" , program_name ,
398	(disname != NULL) ? disname : XDisplayName(NULL));
399	return 0;
400	}
401
402	/*
403	* Use screen #0
404	*/
405	XvQueryAdaptors(dpy , RootWindow(dpy , 0) , &nadaptors , &ainfo);
406
407	if (!nadaptors)
408	{
409	fprintf(stderr , "%s: No adaptors present\n" , program_name);
410	return 0;
411	}
412
413	/*
414	* Use adaptor #0
415	*/
416	portID = ainfo[ 0 ].base_id;
417	if (!scanAttributes(dpy , portID))
418	{
419	fprintf(stderr , "%s: Invalid attributes in XV adaptor\n" , program_name);
420	return 0;
421	}
422
423	switch (action)
424	{
425	case ACT_FULL_DUMP:
426	for(i = 0; i < nadaptors; i++)
427	{
428	printf("Adaptor #%d: \"%s\"\n" , i , ainfo[ i ].name);
429	printf(" number of ports : %d\n" , ainfo[ i ].num_ports);
430	printf(" port base : %d\n" , ainfo[ i ].base_id);
431	printf(" number of adaptors: %u\n" , ainfo[ i ].num_adaptors);
432	}
433	for (i = 0; i < N_ATTRS; i++)
434	{
435	getAttribute(dpy , portID , i , &value);
436	if (i == STD_ATTR)
437	if (value < 0 \|\| value >= N_STDS)
438	printf ("%s = ??? (%d)\n" , attrNames[ i ].extName , value);
439	else
440	printf ("%s = %s (%d)\n" , attrNames[ i ].extName , stdNames[ value ] , value);
441	else
442	printf("%s = %d\n" , attrNames[ i ].extName , value);
443	}
444	break;
445
446	case ACT_SET:
447	setAttribute(dpy , portID , attribute , value);
448	break;
449
450	case ACT_INC:
451	getAttribute(dpy , portID , attribute , &value);
452	value++;
453	if (value > attrData[ attribute ].maxValue)
454	value = attrData[ attribute ].minValue;
455	setAttribute(dpy , portID , attribute , value);
456	break;
457
458	case ACT_DEC:
459	getAttribute(dpy , portID , attribute , &value);
460	value--;
461	if (value < attrData[ attribute ].minValue)
462	value = attrData[ attribute ].maxValue;
463	setAttribute(dpy , portID , attribute , value);
464	break;
465
466	case ACT_ZERO:
467	setAttribute(dpy , portID , attribute , 0);
468	break;
469	}
470
471	return 0;
472	}