Attachment #115513 for bug #127642




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)




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 271-276 Link Here

(-)src/Makefile.in.orig (-5 / +129 lines)
271	theatre.c theatre_module.c	271	theatre.c theatre_module.c
272		272
273		273
		274	theater_out_drv_la_LTLIBRARIES = theater_out_drv.la
		275	theater_out_drv_la_LDFLAGS = -module -avoid-version
		276	theater_out_drv_ladir = @moduledir@/multimedia
		277	theater_out_drv_la_CFLAGS = \
		278	$(AM_CFLAGS) -DMICROC_DIR=\"$(theater_out_drv_ladir)\"
		279
		280	theater_out_drv_la_SOURCES = \
		281	theater_out.c theater_out_module.c
		282
		283
274	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la	284	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la
275	theatre200_drv_la_LDFLAGS = -module -avoid-version	285	theatre200_drv_la_LDFLAGS = -module -avoid-version
276	theatre200_drv_ladir = @moduledir@/multimedia	286	theatre200_drv_ladir = @moduledir@/multimedia
Lines 359-364 Link Here
359	radeon_sarea.h \	369	radeon_sarea.h \
360	radeon_version.h \	370	radeon_version.h \
361	radeon_video.h \	371	radeon_video.h \
		372	theater_out.h \
362	theatre200.h \	373	theatre200.h \
363	theatre_detect.h \	374	theatre_detect.h \
364	theatre.h \	375	theatre.h \
Lines 372-377 Link Here
372	CONFIG_CLEAN_FILES =	383	CONFIG_CLEAN_FILES =
373	LTLIBRARIES = $(ati_drv_la_LTLIBRARIES) $(atimisc_drv_la_LTLIBRARIES) \	384	LTLIBRARIES = $(ati_drv_la_LTLIBRARIES) $(atimisc_drv_la_LTLIBRARIES) \
374	$(r128_drv_la_LTLIBRARIES) $(radeon_drv_la_LTLIBRARIES) \	385	$(r128_drv_la_LTLIBRARIES) $(radeon_drv_la_LTLIBRARIES) \
		386	$(theater_out_drv_la_LTLIBRARIES) \
375	$(theatre200_drv_la_LTLIBRARIES) \	387	$(theatre200_drv_la_LTLIBRARIES) \
376	$(theatre_detect_drv_la_LTLIBRARIES) \	388	$(theatre_detect_drv_la_LTLIBRARIES) \
377	$(theatre_drv_la_LTLIBRARIES)	389	$(theatre_drv_la_LTLIBRARIES)
Lines 426-431 Link Here
426	radeon_probe.lo radeon_display.lo radeon_modes.lo \	438	radeon_probe.lo radeon_display.lo radeon_modes.lo \
427	$(am__objects_6) $(am__objects_7)	439	$(am__objects_6) $(am__objects_7)
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 486-492 Link Here
486	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_modes.Plo \	502	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_modes.Plo \
487	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_probe.Plo \	503	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_probe.Plo \
488	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_video.Plo \	504	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_video.Plo \
489	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_vip.Plo ./$(DEPDIR)/theatre.Plo \	505	@AMDEP_TRUE@ ./$(DEPDIR)/radeon_vip.Plo \
		506	@AMDEP_TRUE@ ./$(DEPDIR)/theater_out_drv_la-theater_out.Plo \
		507	@AMDEP_TRUE@ ./$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo \
		508	@AMDEP_TRUE@ ./$(DEPDIR)/theatre.Plo \
490	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200.Plo \	509	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200.Plo \
491	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo \	510	@AMDEP_TRUE@ ./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo \
492	@AMDEP_TRUE@ ./$(DEPDIR)/theatre_detect.Plo \	511	@AMDEP_TRUE@ ./$(DEPDIR)/theatre_detect.Plo \
Lines 501-510 Link Here
501	$(AM_LDFLAGS) $(LDFLAGS) -o $@	520	$(AM_LDFLAGS) $(LDFLAGS) -o $@
502	DIST_SOURCES = $(ati_drv_la_SOURCES) $(am__atimisc_drv_la_SOURCES_DIST) \	521	DIST_SOURCES = $(ati_drv_la_SOURCES) $(am__atimisc_drv_la_SOURCES_DIST) \
503	$(am__r128_drv_la_SOURCES_DIST) \	522	$(am__r128_drv_la_SOURCES_DIST) \
504	$(am__radeon_drv_la_SOURCES_DIST) $(theatre200_drv_la_SOURCES) \	523	$(am__radeon_drv_la_SOURCES_DIST) $(theater_out_drv_la_SOURCES) \
505	$(theatre_detect_drv_la_SOURCES) $(theatre_drv_la_SOURCES)	524	$(theatre200_drv_la_SOURCES) $(theatre_detect_drv_la_SOURCES) \
		525	$(theatre_drv_la_SOURCES)
506	DIST_COMMON = $(srcdir)/Makefile.in Makefile.am	526	DIST_COMMON = $(srcdir)/Makefile.in Makefile.am
507	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)	527	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)
508		528
509	all: all-am	529	all: all-am
510		530
Lines 627-632 Link Here
627	echo "rm -f \"$${dir}/so_locations\""; \	647	echo "rm -f \"$${dir}/so_locations\""; \
628	rm -f "$${dir}/so_locations"; \	648	rm -f "$${dir}/so_locations"; \
629	done	649	done
		650	theater_out_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
		651	install-theater_out_drv_laLTLIBRARIES: $(theater_out_drv_la_LTLIBRARIES)
		652	@$(NORMAL_INSTALL)
		653	$(mkinstalldirs) $(DESTDIR)$(theater_out_drv_ladir)
		654	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		655	if test -f $$p; then \
		656	f="`echo $$p \| sed -e 's\|^.*/\|\|'`"; \
		657	echo " $(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) $$p $(DESTDIR)$(theater_out_drv_ladir)/$$f"; \
		658	$(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) $$p $(DESTDIR)$(theater_out_drv_ladir)/$$f; \
		659	else :; fi; \
		660	done
		661
		662	uninstall-theater_out_drv_laLTLIBRARIES:
		663	@$(NORMAL_UNINSTALL)
		664	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		665	p="`echo $$p \| sed -e 's\|^.*/\|\|'`"; \
		666	echo " $(LIBTOOL) --mode=uninstall rm -f $(DESTDIR)$(theater_out_drv_ladir)/$$p"; \
		667	$(LIBTOOL) --mode=uninstall rm -f $(DESTDIR)$(theater_out_drv_ladir)/$$p; \
		668	done
		669
		670	clean-theater_out_drv_laLTLIBRARIES:
		671	-test -z "$(theater_out_drv_la_LTLIBRARIES)" \|\| rm -f $(theater_out_drv_la_LTLIBRARIES)
		672	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		673	dir="`echo $$p \| sed -e 's\|/[^/]*$$\|\|'`"; \
		674	test "$$dir" = "$$p" && dir=.; \
		675	echo "rm -f \"$${dir}/so_locations\""; \
		676	rm -f "$${dir}/so_locations"; \
		677	done
630	theatre200_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	678	theatre200_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
631	install-theatre200_drv_laLTLIBRARIES: $(theatre200_drv_la_LTLIBRARIES)	679	install-theatre200_drv_laLTLIBRARIES: $(theatre200_drv_la_LTLIBRARIES)
632	@$(NORMAL_INSTALL)	680	@$(NORMAL_INSTALL)
Lines 719-724 Link Here
719	$(LINK) -rpath $(r128_drv_ladir) $(r128_drv_la_LDFLAGS) $(r128_drv_la_OBJECTS) $(r128_drv_la_LIBADD) $(LIBS)	767	$(LINK) -rpath $(r128_drv_ladir) $(r128_drv_la_LDFLAGS) $(r128_drv_la_OBJECTS) $(r128_drv_la_LIBADD) $(LIBS)
720	radeon_drv.la: $(radeon_drv_la_OBJECTS) $(radeon_drv_la_DEPENDENCIES)	768	radeon_drv.la: $(radeon_drv_la_OBJECTS) $(radeon_drv_la_DEPENDENCIES)
721	$(LINK) -rpath $(radeon_drv_ladir) $(radeon_drv_la_LDFLAGS) $(radeon_drv_la_OBJECTS) $(radeon_drv_la_LIBADD) $(LIBS)	769	$(LINK) -rpath $(radeon_drv_ladir) $(radeon_drv_la_LDFLAGS) $(radeon_drv_la_OBJECTS) $(radeon_drv_la_LIBADD) $(LIBS)
		770	theater_out_drv.la: $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_DEPENDENCIES)
		771	$(LINK) -rpath $(theater_out_drv_ladir) $(theater_out_drv_la_LDFLAGS) $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_LIBADD) $(LIBS)
722	theatre200_drv.la: $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_DEPENDENCIES)	772	theatre200_drv.la: $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_DEPENDENCIES)
723	$(LINK) -rpath $(theatre200_drv_ladir) $(theatre200_drv_la_LDFLAGS) $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_LIBADD) $(LIBS)	773	$(LINK) -rpath $(theatre200_drv_ladir) $(theatre200_drv_la_LDFLAGS) $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_LIBADD) $(LIBS)
724	theatre_detect_drv.la: $(theatre_detect_drv_la_OBJECTS) $(theatre_detect_drv_la_DEPENDENCIES)	774	theatre_detect_drv.la: $(theatre_detect_drv_la_OBJECTS) $(theatre_detect_drv_la_DEPENDENCIES)
Lines 796-801 Link Here
796	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_probe.Plo@am__quote@	846	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_probe.Plo@am__quote@
797	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_video.Plo@am__quote@	847	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_video.Plo@am__quote@
798	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_vip.Plo@am__quote@	848	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_vip.Plo@am__quote@
		849	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out.Plo@am__quote@
		850	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo@am__quote@
799	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre.Plo@am__quote@	851	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre.Plo@am__quote@
800	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200.Plo@am__quote@	852	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200.Plo@am__quote@
801	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo@am__quote@	853	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo@am__quote@
Lines 836-841 Link Here
836	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@	888	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
837	@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ `test -f '$<' \|\| echo '$(srcdir)/'`$<	889	@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ `test -f '$<' \|\| echo '$(srcdir)/'`$<
838		890
		891	theater_out_drv_la-theater_out.o: theater_out.c
		892	@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" \
		893	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out.o `test -f 'theater_out.c' \|\| echo '$(srcdir)/'`theater_out.c; \
		894	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Po"; \
		895	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; \
		896	@am__fastdepCC_TRUE@ fi
		897	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out.c' object='theater_out_drv_la-theater_out.o' libtool=no @AMDEPBACKSLASH@
		898	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out.Po' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out.TPo' @AMDEPBACKSLASH@
		899	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		900	@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
		901
		902	theater_out_drv_la-theater_out.obj: theater_out.c
		903	@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" \
		904	@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`; \
		905	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Po"; \
		906	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; \
		907	@am__fastdepCC_TRUE@ fi
		908	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out.c' object='theater_out_drv_la-theater_out.obj' libtool=no @AMDEPBACKSLASH@
		909	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out.Po' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out.TPo' @AMDEPBACKSLASH@
		910	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		911	@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`
		912
		913	theater_out_drv_la-theater_out.lo: theater_out.c
		914	@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" \
		915	@am__fastdepCC_TRUE@ -c -o theater_out_drv_la-theater_out.lo `test -f 'theater_out.c' \|\| echo '$(srcdir)/'`theater_out.c; \
		916	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Plo"; \
		917	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; \
		918	@am__fastdepCC_TRUE@ fi
		919	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out.c' object='theater_out_drv_la-theater_out.lo' libtool=yes @AMDEPBACKSLASH@
		920	@AMDEP_TRUE@@am__fastdepCC_FALSE@ depfile='$(DEPDIR)/theater_out_drv_la-theater_out.Plo' tmpdepfile='$(DEPDIR)/theater_out_drv_la-theater_out.TPlo' @AMDEPBACKSLASH@
		921	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		922	@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
		923
		924	theater_out_drv_la-theater_out_module.o: theater_out_module.c
		925	@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" \
		926	@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; \
		927	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Po"; \
		928	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; \
		929	@am__fastdepCC_TRUE@ fi
		930	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.o' libtool=no @AMDEPBACKSLASH@
		931	@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@
		932	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		933	@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
		934
		935	theater_out_drv_la-theater_out_module.obj: theater_out_module.c
		936	@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" \
		937	@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`; \
		938	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Po"; \
		939	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; \
		940	@am__fastdepCC_TRUE@ fi
		941	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.obj' libtool=no @AMDEPBACKSLASH@
		942	@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@
		943	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		944	@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`
		945
		946	theater_out_drv_la-theater_out_module.lo: theater_out_module.c
		947	@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" \
		948	@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; \
		949	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo"; \
		950	@am__fastdepCC_TRUE@ else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; \
		951	@am__fastdepCC_TRUE@ fi
		952	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.lo' libtool=yes @AMDEPBACKSLASH@
		953	@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@
		954	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
955	@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
956
839	theatre200_drv_la-theatre200.o: theatre200.c	957	theatre200_drv_la-theatre200.o: theatre200.c
840	@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" \	958	@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" \
841	@am__fastdepCC_TRUE@ -c -o theatre200_drv_la-theatre200.o `test -f 'theatre200.c' \|\| echo '$(srcdir)/'`theatre200.c; \	959	@am__fastdepCC_TRUE@ -c -o theatre200_drv_la-theatre200.o `test -f 'theatre200.c' \|\| echo '$(srcdir)/'`theatre200.c; \
Lines 1002-1008 Link Here
1002	all-am: Makefile $(LTLIBRARIES)	1120	all-am: Makefile $(LTLIBRARIES)
1003		1121
1004	installdirs:	1122	installdirs:
1005	$(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)	1123	$(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)
1006	install: install-am	1124	install: install-am
1007	install-exec: install-exec-am	1125	install-exec: install-exec-am
1008	install-data: install-data-am	1126	install-data: install-data-am
Lines 1032-1037 Link Here
1032	clean-am: clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \	1150	clean-am: clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
1033	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \	1151	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
1034	clean-radeon_drv_laLTLIBRARIES \	1152	clean-radeon_drv_laLTLIBRARIES \
		1153	clean-theater_out_drv_laLTLIBRARIES \
1035	clean-theatre200_drv_laLTLIBRARIES \	1154	clean-theatre200_drv_laLTLIBRARIES \
1036	clean-theatre_detect_drv_laLTLIBRARIES \	1155	clean-theatre_detect_drv_laLTLIBRARIES \
1037	clean-theatre_drv_laLTLIBRARIES mostlyclean-am	1156	clean-theatre_drv_laLTLIBRARIES mostlyclean-am
Lines 1053-1058 Link Here
1053	install-data-am: install-ati_drv_laLTLIBRARIES \	1172	install-data-am: install-ati_drv_laLTLIBRARIES \
1054	install-atimisc_drv_laLTLIBRARIES \	1173	install-atimisc_drv_laLTLIBRARIES \
1055	install-r128_drv_laLTLIBRARIES install-radeon_drv_laLTLIBRARIES \	1174	install-r128_drv_laLTLIBRARIES install-radeon_drv_laLTLIBRARIES \
		1175	install-theater_out_drv_laLTLIBRARIES \
1056	install-theatre200_drv_laLTLIBRARIES \	1176	install-theatre200_drv_laLTLIBRARIES \
1057	install-theatre_detect_drv_laLTLIBRARIES \	1177	install-theatre_detect_drv_laLTLIBRARIES \
1058	install-theatre_drv_laLTLIBRARIES	1178	install-theatre_drv_laLTLIBRARIES
Lines 1087-1092 Link Here
1087	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \	1207	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
1088	uninstall-r128_drv_laLTLIBRARIES \	1208	uninstall-r128_drv_laLTLIBRARIES \
1089	uninstall-radeon_drv_laLTLIBRARIES \	1209	uninstall-radeon_drv_laLTLIBRARIES \
		1210	uninstall-theater_out_drv_laLTLIBRARIES \
1090	uninstall-theatre200_drv_laLTLIBRARIES \	1211	uninstall-theatre200_drv_laLTLIBRARIES \
1091	uninstall-theatre_detect_drv_laLTLIBRARIES \	1212	uninstall-theatre_detect_drv_laLTLIBRARIES \
1092	uninstall-theatre_drv_laLTLIBRARIES	1213	uninstall-theatre_drv_laLTLIBRARIES
Lines 1095-1100 Link Here
1095	clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \	1216	clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
1096	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \	1217	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
1097	clean-radeon_drv_laLTLIBRARIES \	1218	clean-radeon_drv_laLTLIBRARIES \
		1219	clean-theater_out_drv_laLTLIBRARIES \
1098	clean-theatre200_drv_laLTLIBRARIES \	1220	clean-theatre200_drv_laLTLIBRARIES \
1099	clean-theatre_detect_drv_laLTLIBRARIES \	1221	clean-theatre_detect_drv_laLTLIBRARIES \
1100	clean-theatre_drv_laLTLIBRARIES ctags distclean \	1222	clean-theatre_drv_laLTLIBRARIES ctags distclean \
Lines 1105-1110 Link Here
1105	install-exec install-exec-am install-info install-info-am \	1227	install-exec install-exec-am install-info install-info-am \
1106	install-man install-r128_drv_laLTLIBRARIES \	1228	install-man install-r128_drv_laLTLIBRARIES \
1107	install-radeon_drv_laLTLIBRARIES install-strip \	1229	install-radeon_drv_laLTLIBRARIES install-strip \
		1230	install-theater_out_drv_laLTLIBRARIES \
1108	install-theatre200_drv_laLTLIBRARIES \	1231	install-theatre200_drv_laLTLIBRARIES \
1109	install-theatre_detect_drv_laLTLIBRARIES \	1232	install-theatre_detect_drv_laLTLIBRARIES \
1110	install-theatre_drv_laLTLIBRARIES installcheck installcheck-am \	1233	install-theatre_drv_laLTLIBRARIES installcheck installcheck-am \
Lines 1115-1120 Link Here
1115	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \	1238	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
1116	uninstall-r128_drv_laLTLIBRARIES \	1239	uninstall-r128_drv_laLTLIBRARIES \
1117	uninstall-radeon_drv_laLTLIBRARIES \	1240	uninstall-radeon_drv_laLTLIBRARIES \
		1241	uninstall-theater_out_drv_laLTLIBRARIES \
1118	uninstall-theatre200_drv_laLTLIBRARIES \	1242	uninstall-theatre200_drv_laLTLIBRARIES \
1119	uninstall-theatre_detect_drv_laLTLIBRARIES \	1243	uninstall-theatre_detect_drv_laLTLIBRARIES \
1120	uninstall-theatre_drv_laLTLIBRARIES	1244	uninstall-theatre_drv_laLTLIBRARIES

Lines 74-79 Link Here

(-)src/radeon_driver.c.orig (-10 / +308 lines)
74	#include "radeon_macros.h"	74	#include "radeon_macros.h"
75	#include "radeon_probe.h"	75	#include "radeon_probe.h"
76	#include "radeon_version.h"	76	#include "radeon_version.h"
		77	//2006021906
		78	#include "theater_out.h"
77	#include "radeon_mergedfb.h"	79	#include "radeon_mergedfb.h"
78		80
79	#ifdef XF86DRI	81	#ifdef XF86DRI
Lines 183-188 Link Here
183	{ OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE },	185	{ OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE },
184	{ OPTION_RAGE_THEATRE_SVIDEO_PORT, "RageTheatreSVideoPort", OPTV_INTEGER, {0}, FALSE },	186	{ OPTION_RAGE_THEATRE_SVIDEO_PORT, "RageTheatreSVideoPort", OPTV_INTEGER, {0}, FALSE },
185	{ OPTION_TUNER_TYPE, "TunerType", OPTV_INTEGER, {0}, FALSE },	187	{ OPTION_TUNER_TYPE, "TunerType", OPTV_INTEGER, {0}, FALSE },
		188	//2006021906
		189	{ OPTION_TV_OUTPUT, "TVOutput", OPTV_ANYSTR, {0}, FALSE },
186	{ OPTION_RAGE_THEATRE_MICROC_PATH, "RageTheatreMicrocPath", OPTV_STRING, {0}, FALSE },	190	{ OPTION_RAGE_THEATRE_MICROC_PATH, "RageTheatreMicrocPath", OPTV_STRING, {0}, FALSE },
187	{ OPTION_RAGE_THEATRE_MICROC_TYPE, "RageTheatreMicrocType", OPTV_STRING, {0}, FALSE },	191	{ OPTION_RAGE_THEATRE_MICROC_TYPE, "RageTheatreMicrocType", OPTV_STRING, {0}, FALSE },
188	{ OPTION_SCALER_WIDTH, "ScalerWidth", OPTV_INTEGER, {0}, FALSE },	192	{ OPTION_SCALER_WIDTH, "ScalerWidth", OPTV_INTEGER, {0}, FALSE },
Lines 3788-3793 Link Here
3788		3792
3789	info->PaletteSavedOnVT = FALSE;	3793	info->PaletteSavedOnVT = FALSE;
3790		3794
		3795	//2006021909
		3796	RADEONTRACE(("Allocating VIP interface"));
		3797	info->VIP = RADEONAllocateVIP(pScrn);
		3798
		3799	/*
		3800	if (info->VIP != NULL)
		3801	{
		3802	RADEONTRACE(("\n061:NOT NULL\n"));
		3803	}
		3804	else
		3805	{
		3806	RADEONTRACE(("\n062:NULL\n"));
		3807	}
		3808	*/
		3809
		3810	//2006021907
		3811	if ((s = xf86GetOptValString(info->Options , OPTION_TV_OUTPUT)) != NULL && xf86NameCmp(s , "NOLOAD") != 0)
		3812	{
		3813	//RADEONTRACE(("TVOUT OPTION ON\n"));
		3814	RADEONTRACE(("TVOutput opt = %s\n" , s));
		3815	if(!xf86LoadSubModule(pScrn , "theater_out"))
		3816	{
		3817	RADEONTRACE(("Failed to find theater_out module\n"));
		3818	xf86DrvMsg(pScrn->scrnIndex , X_ERROR , "Unable to load TV output module\n");
		3819	info->theaterOut = NULL;
		3820	}
		3821	else
		3822	{
		3823	RADEONTRACE(("Found theater_out module\n"));
		3824	xf86LoaderReqSymbols(THEATER_OUT_SYMBOLS , NULL);
		3825	// RADEONTRACE(("071:OK\n"));
		3826
		3827	info->theaterOut = xf86_detectTheaterOut(pScrn , FALSE,info->VIP);
		3828	// RADEONTRACE(("072:OK\n"));
		3829	if (info->theaterOut != NULL)
		3830	{
		3831	// RADEONTRACE(("072:NOT NULL\n"));
		3832	xf86_initTheaterOut(info->theaterOut , s);
		3833	// RADEONTRACE(("073:start init\n"));
		3834	}
		3835	else
		3836	{
		3837	RADEONTRACE(("TheaterOut is NULL!!\n"));
		3838	}
		3839
		3840	}
		3841
		3842	}
		3843	else
		3844	{
		3845	// RADEONTRACE(("NO TVOUT OPTION\n"));
		3846	}
		3847
		3848
		3849
		3850
		3851
3791	RADEONSave(pScrn);	3852	RADEONSave(pScrn);
3792		3853
3793	if ((!info->IsSecondary) && info->IsMobility) {	3854	if ((!info->IsSecondary) && info->IsMobility) {
Lines 4213-4219 Link Here
4213		4274
4214	/* Init Xv */	4275	/* Init Xv */
4215	RADEONTRACE(("Initializing Xv\n"));	4276	RADEONTRACE(("Initializing Xv\n"));
4216	RADEONInitVideo(pScreen);	4277	//2006021911
		4278	// RADEONInitVideo(pScreen);
		4279	RADEONInitVideo(pScreen , info->VIP , TRUE);
4217		4280
4218	if(info->MergedFB)	4281	if(info->MergedFB)
4219	/* need this here to fix up sarea values */	4282	/* need this here to fix up sarea values */
Lines 4455-4461 Link Here
4455	OUTREG(RADEON_OVR_WID_TOP_BOTTOM, restore->ovr_wid_top_bottom);	4518	OUTREG(RADEON_OVR_WID_TOP_BOTTOM, restore->ovr_wid_top_bottom);
4456	OUTREG(RADEON_OV0_SCALE_CNTL, restore->ov0_scale_cntl);	4519	OUTREG(RADEON_OV0_SCALE_CNTL, restore->ov0_scale_cntl);
4457	OUTREG(RADEON_SUBPIC_CNTL, restore->subpic_cntl);	4520	OUTREG(RADEON_SUBPIC_CNTL, restore->subpic_cntl);
4458	OUTREG(RADEON_VIPH_CONTROL, restore->viph_control);	4521	//2006021914
		4522	// OUTREG(RADEON_VIPH_CONTROL, restore->viph_control);
		4523	/*
		4524	* fulivi: removed. It messes the VIP access up
		4525	*/
		4526
4459	OUTREG(RADEON_I2C_CNTL_1, restore->i2c_cntl_1);	4527	OUTREG(RADEON_I2C_CNTL_1, restore->i2c_cntl_1);
4460	OUTREG(RADEON_GEN_INT_CNTL, restore->gen_int_cntl);	4528	OUTREG(RADEON_GEN_INT_CNTL, restore->gen_int_cntl);
4461	OUTREG(RADEON_CAP0_TRIG_CNTL, restore->cap0_trig_cntl);	4529	OUTREG(RADEON_CAP0_TRIG_CNTL, restore->cap0_trig_cntl);
Lines 4548-4553 Link Here
4548	OUTREG(RADEON_CRTC_OFFSET, restore->crtc_offset);	4616	OUTREG(RADEON_CRTC_OFFSET, restore->crtc_offset);
4549	OUTREG(RADEON_CRTC_OFFSET_CNTL, restore->crtc_offset_cntl);	4617	OUTREG(RADEON_CRTC_OFFSET_CNTL, restore->crtc_offset_cntl);
4550	OUTREG(RADEON_CRTC_PITCH, restore->crtc_pitch);	4618	OUTREG(RADEON_CRTC_PITCH, restore->crtc_pitch);
		4619	//2006021914
		4620	OUTREG(RADEON_DISP_OUTPUT_CNTL, restore->disp_output_cntl);
4551	OUTREG(RADEON_DISP_MERGE_CNTL, restore->disp_merge_cntl);	4621	OUTREG(RADEON_DISP_MERGE_CNTL, restore->disp_merge_cntl);
4552	OUTREG(RADEON_CRTC_MORE_CNTL, restore->crtc_more_cntl);	4622	OUTREG(RADEON_CRTC_MORE_CNTL, restore->crtc_more_cntl);
4553		4623
Lines 4690-4701 Link Here
4690	~(RADEON_P2PLL_ATOMIC_UPDATE_W));	4760	~(RADEON_P2PLL_ATOMIC_UPDATE_W));
4691	}	4761	}
4692		4762
		4763	//2006021914
		4764	static
		4765	CARD8
		4766	RADEONComputePLLGain(
		4767	CARD16 reference_freq,
		4768	CARD16 ref_div,
		4769	CARD16 fb_div
		4770	)
		4771	{
		4772	unsigned vcoFreq;
		4773
		4774	vcoFreq = ((unsigned)reference_freq * fb_div) / ref_div;
		4775
		4776	/*
		4777	* This is orribly crude: the VCO frequency range is divided into
		4778	* 3 parts, each part having a fixed PLL gain value.
		4779	*/
		4780	if (vcoFreq >= 30000)
		4781	/*
		4782	* [300..max] MHz : 7
		4783	*/
		4784	return 7;
		4785	else if (vcoFreq >= 18000)
		4786	/*
		4787	* [180..300) MHz : 4
		4788	*/
		4789	return 4;
		4790	else
		4791	/*
		4792	* [0..180) MHz : 1
		4793	*/
		4794	return 1;
		4795	}
		4796
		4797
4693	/* Write PLL registers */	4798	/* Write PLL registers */
4694	static void RADEONRestorePLLRegisters(ScrnInfoPtr pScrn,	4799	static void RADEONRestorePLLRegisters(ScrnInfoPtr pScrn,
4695	RADEONSavePtr restore)	4800	RADEONSavePtr restore)
4696	{	4801	{
4697	RADEONInfoPtr info = RADEONPTR(pScrn);	4802	RADEONInfoPtr info = RADEONPTR(pScrn);
4698	unsigned char *RADEONMMIO = info->MMIO;	4803	unsigned char *RADEONMMIO = info->MMIO;
		4804	//2006021914
		4805	CARD8 pllGain;
4699		4806
4700	if (info->IsMobility) {	4807	if (info->IsMobility) {
4701	/* A temporal workaround for the occational blanking on certain laptop panels.	4808	/* A temporal workaround for the occational blanking on certain laptop panels.
Lines 4718-4732 Link Here
4718	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,	4825	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,
4719	RADEON_VCLK_SRC_SEL_CPUCLK,	4826	RADEON_VCLK_SRC_SEL_CPUCLK,
4720	~(RADEON_VCLK_SRC_SEL_MASK));	4827	~(RADEON_VCLK_SRC_SEL_MASK));
		4828	//2006021914
		4829	pllGain = RADEONComputePLLGain(info->pll.reference_freq,
		4830	restore->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
		4831	restore->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK);
		4832
		4833
4721		4834
4722	OUTPLLP(pScrn,	4835	OUTPLLP(pScrn,
4723	RADEON_PPLL_CNTL,	4836	RADEON_PPLL_CNTL,
4724	RADEON_PPLL_RESET	4837	RADEON_PPLL_RESET
4725	\| RADEON_PPLL_ATOMIC_UPDATE_EN	4838	\| RADEON_PPLL_ATOMIC_UPDATE_EN
4726	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN,	4839	//2006021914
		4840	// \| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN,
		4841	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
		4842	\| ((CARD32)pllGain << RADEON_PPLL_PVG_SHIFT),
4727	~(RADEON_PPLL_RESET	4843	~(RADEON_PPLL_RESET
4728	\| RADEON_PPLL_ATOMIC_UPDATE_EN	4844	\| RADEON_PPLL_ATOMIC_UPDATE_EN
4729	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN));	4845	//2006021914
		4846	// \| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN));
		4847	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
		4848	\| RADEON_PPLL_PVG_MASK));
		4849
4730		4850
4731	OUTREGP(RADEON_CLOCK_CNTL_INDEX,	4851	OUTREGP(RADEON_CLOCK_CNTL_INDEX,
4732	RADEON_PLL_DIV_SEL,	4852	RADEON_PLL_DIV_SEL,
Lines 4786-4794 Link Here
4786		4906
4787	usleep(50000); /* Let the clock to lock */	4907	usleep(50000); /* Let the clock to lock */
4788		4908
4789	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,	4909	//2006021914
4790	RADEON_VCLK_SRC_SEL_PPLLCLK,	4910	// OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,
4791	~(RADEON_VCLK_SRC_SEL_MASK));	4911	// RADEON_VCLK_SRC_SEL_PPLLCLK,
		4912	// ~(RADEON_VCLK_SRC_SEL_MASK));
		4913	//old OUTPLL(pScrn, RADEON_VCLK_ECP_CNTL , restore->vclk_ecp_cntl);
		4914	//old RADEONTRACE(("VCLK_ECP_CNTL = %08X\n" , restore->vclk_ecp_cntl));
		4915	OUTPLL(pScrn, RADEON_VCLK_ECP_CNTL , restore->vclk_cntl);
		4916	RADEONTRACE(("VCLK_ECP_CNTL = %08X\n" , restore->vclk_cntl));
		4917
4792	}	4918	}
4793		4919
4794		4920
Lines 5244-5249 Link Here
5244	save->crtc_offset = INREG(RADEON_CRTC_OFFSET);	5370	save->crtc_offset = INREG(RADEON_CRTC_OFFSET);
5245	save->crtc_offset_cntl = INREG(RADEON_CRTC_OFFSET_CNTL);	5371	save->crtc_offset_cntl = INREG(RADEON_CRTC_OFFSET_CNTL);
5246	save->crtc_pitch = INREG(RADEON_CRTC_PITCH);	5372	save->crtc_pitch = INREG(RADEON_CRTC_PITCH);
		5373	//2006021915
		5374	save->disp_output_cntl = INREG(RADEON_DISP_OUTPUT_CNTL);
5247	save->disp_merge_cntl = INREG(RADEON_DISP_MERGE_CNTL);	5375	save->disp_merge_cntl = INREG(RADEON_DISP_MERGE_CNTL);
5248	save->crtc_more_cntl = INREG(RADEON_CRTC_MORE_CNTL);	5376	save->crtc_more_cntl = INREG(RADEON_CRTC_MORE_CNTL);
5249		5377
Lines 5313-5318 Link Here
5313	save->ppll_div_3 = INPLL(pScrn, RADEON_PPLL_DIV_3);	5441	save->ppll_div_3 = INPLL(pScrn, RADEON_PPLL_DIV_3);
5314	save->htotal_cntl = INPLL(pScrn, RADEON_HTOTAL_CNTL);	5442	save->htotal_cntl = INPLL(pScrn, RADEON_HTOTAL_CNTL);
5315	save->vclk_cntl = INPLL(pScrn, RADEON_VCLK_ECP_CNTL);	5443	save->vclk_cntl = INPLL(pScrn, RADEON_VCLK_ECP_CNTL);
		5444	//2006021915
		5445	//save->vclk_ecp_cntl= INPLL(pScrn, RADEON_VCLK_ECP_CNTL);
5316		5446
5317	RADEONTRACE(("Read: 0x%08x 0x%08x 0x%08lx\n",	5447	RADEONTRACE(("Read: 0x%08x 0x%08x 0x%08lx\n",
5318	save->ppll_ref_div,	5448	save->ppll_ref_div,
Lines 5322-5327 Link Here
5322	save->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,	5452	save->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
5323	save->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK,	5453	save->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK,
5324	(save->ppll_div_3 & RADEON_PPLL_POST3_DIV_MASK) >> 16));	5454	(save->ppll_div_3 & RADEON_PPLL_POST3_DIV_MASK) >> 16));
		5455	//2006021915
		5456	//RADEONTRACE(("Read VCLK_ECP_CNTL = %08x\n" , save->vclk_ecp_cntl));
		5457	RADEONTRACE(("Read VCLK_ECP_CNTL = %08x\n" , save->vclk_cntl));
5325	}	5458	}
5326		5459
5327	/* Read PLL registers */	5460	/* Read PLL registers */
Lines 5431-5436 Link Here
5431	RADEONSaveMode(pScrn, save);	5564	RADEONSaveMode(pScrn, save);
5432	if (!info->IsSecondary)	5565	if (!info->IsSecondary)
5433	RADEONSaveSurfaces(pScrn, save);	5566	RADEONSaveSurfaces(pScrn, save);
		5567
		5568	//2006021915
		5569	/*
		5570	* Save initial RT state
		5571	*/
		5572	if (info->theaterOut != NULL)
		5573	{
		5574	// RADEONTRACE(("2006021915\n"));
		5575	xf86_theaterOutSave(info->theaterOut , pScrn);
		5576	}
5434	}	5577	}
5435		5578
5436	/* Restore the original (text) mode */	5579	/* Restore the original (text) mode */
Lines 5473-5478 Link Here
5473	if (!info->IsSecondary)	5616	if (!info->IsSecondary)
5474	RADEONRestoreSurfaces(pScrn, restore);	5617	RADEONRestoreSurfaces(pScrn, restore);
5475		5618
		5619	/*
		5620	* Restore RT state
		5621	*/
		5622	if (info->theaterOut != NULL)
		5623	{
		5624	// RADEONTRACE(("2006021915-2\n"));
		5625	xf86_theaterOutRestore(info->theaterOut , pScrn);
		5626	}
5476	#if 0	5627	#if 0
5477	/* Temp fix to "solve" VT switch problems. When switching VTs on	5628	/* Temp fix to "solve" VT switch problems. When switching VTs on
5478	* some systems, the console can either hang or the fonts can be	5629	* some systems, the console can either hang or the fonts can be
Lines 6136-6142 Link Here
6136	? RADEON_CRTC2_INTERLACE_EN	6287	? RADEON_CRTC2_INTERLACE_EN
6137	: 0));	6288	: 0));
6138		6289
6139	save->disp2_merge_cntl = info->SavedReg.disp2_merge_cntl;	6290	//2006021915
		6291	//old save->fp2_gen_cntl = info->SavedReg.fp2_gen_cntl \| RADEON_FP2_ON;
		6292	//save->disp2_merge_cntl = info->SavedReg.disp2_merge_cntl;
		6293	save->disp2_merge_cntl = info->SavedReg.disp2_merge_cntl
		6294	\| RADEON_FP2_SRC_SEL_CRTC2
		6295	\| RADEON_FP2_ON;
		6296
6140	save->disp2_merge_cntl &= ~(RADEON_DISP2_RGB_OFFSET_EN);	6297	save->disp2_merge_cntl &= ~(RADEON_DISP2_RGB_OFFSET_EN);
6141		6298
6142	save->fp_h2_sync_strt_wid = save->crtc2_h_sync_strt_wid;	6299	save->fp_h2_sync_strt_wid = save->crtc2_h_sync_strt_wid;
Lines 6227-6242 Link Here
6227	pll->reference_freq);	6384	pll->reference_freq);
6228	save->post_div = post_div->divider;	6385	save->post_div = post_div->divider;
6229		6386
		6387	//2006021915
		6388	/*
6230	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",	6389	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",
6231	save->dot_clock_freq,	6390	save->dot_clock_freq,
6232	save->pll_output_freq,	6391	save->pll_output_freq,
6233	save->feedback_div,	6392	save->feedback_div,
6234	save->post_div));	6393	save->post_div));
6235		6394	*/
6236	save->ppll_ref_div = pll->reference_div;	6395	save->ppll_ref_div = pll->reference_div;
6237	save->ppll_div_3 = (save->feedback_div \| (post_div->bitvalue << 16));	6396	save->ppll_div_3 = (save->feedback_div \| (post_div->bitvalue << 16));
6238	save->htotal_cntl = 0;	6397	save->htotal_cntl = 0;
6239		6398
		6399	//2006021915
		6400	//save->vclk_ecp_cntl = (save->vclk_ecp_cntl &
		6401	// ~RADEON_VCLK_SRC_SEL_MASK) \| RADEON_VCLK_SRC_SEL_PPLLCLK;
		6402
6240	save->vclk_cntl = (info->SavedReg.vclk_cntl &	6403	save->vclk_cntl = (info->SavedReg.vclk_cntl &
6241	~RADEON_VCLK_SRC_SEL_MASK) \| RADEON_VCLK_SRC_SEL_PPLLCLK;	6404	~RADEON_VCLK_SRC_SEL_MASK) \| RADEON_VCLK_SRC_SEL_PPLLCLK;
6242		6405
Lines 6293-6304 Link Here
6293	* save->pll_output_freq_2,	6456	* save->pll_output_freq_2,
6294	pll->reference_freq);	6457	pll->reference_freq);
6295	save->post_div_2 = post_div->divider;	6458	save->post_div_2 = post_div->divider;
6296		6459	//2006021915
		6460	/*
6297	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",	6461	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",
6298	save->dot_clock_freq_2,	6462	save->dot_clock_freq_2,
6299	save->pll_output_freq_2,	6463	save->pll_output_freq_2,
6300	save->feedback_div_2,	6464	save->feedback_div_2,
6301	save->post_div_2));	6465	save->post_div_2));
		6466	*/
6302		6467
6303	save->p2pll_ref_div = pll->reference_div;	6468	save->p2pll_ref_div = pll->reference_div;
6304	save->p2pll_div_0 = (save->feedback_div_2 \|	6469	save->p2pll_div_0 = (save->feedback_div_2 \|
Lines 6383-6388 Link Here
6383		6548
6384	info->Flags = crtc1->Flags;	6549	info->Flags = crtc1->Flags;
6385		6550
		6551	//2006021916
		6552	/*
		6553	* Some registers are initialized from text mode state
		6554	*/
		6555	save->disp_output_cntl = RADEONPTR(pScrn)->SavedReg.disp_output_cntl;
		6556	//save->vclk_ecp_cntl = RADEONPTR(pScrn)->SavedReg.vclk_ecp_cntl;
		6557	save->vclk_cntl = info->SavedReg.vclk_cntl;
		6558
6386	RADEONInitMemMapRegisters(pScrn, save, info);	6559	RADEONInitMemMapRegisters(pScrn, save, info);
6387	RADEONInitCommonRegisters(save, info);	6560	RADEONInitCommonRegisters(save, info);
6388		6561
Lines 6466-6474 Link Here
6466		6639
6467	if (!RADEONInit(pScrn, mode, &info->ModeReg)) return FALSE;	6640	if (!RADEONInit(pScrn, mode, &info->ModeReg)) return FALSE;
6468		6641
		6642	//2006021917
		6643	/*
		6644	* Define RT state
		6645	*/
		6646	if (info->theaterOut != NULL)
		6647	{
		6648	// RADEONTRACE(("2006021917\n"));
		6649	Bool res = xf86_theaterOutInit(info->theaterOut , mode , &info->ModeReg);
		6650	RADEONTRACE(("theaterOutInit returns %d\n" , res));
		6651	}
		6652
		6653
6469	pScrn->vtSema = TRUE;	6654	pScrn->vtSema = TRUE;
6470	RADEONBlank(pScrn);	6655	RADEONBlank(pScrn);
6471	RADEONRestoreMode(pScrn, &info->ModeReg);	6656	RADEONRestoreMode(pScrn, &info->ModeReg);
		6657
		6658	//2006021918
		6659
		6660	/*
		6661	* Set RT to new mode
		6662	*/
		6663	if (info->theaterOut != NULL)
		6664	{
		6665	// RADEONTRACE(("2006021918\n"));
		6666	xf86_theaterOutRestoreMode(info->theaterOut , pScrn);
		6667	}
		6668
		6669
6472	RADEONUnblank(pScrn);	6670	RADEONUnblank(pScrn);
6473		6671
6474	info->CurrentLayout.mode = mode;	6672	info->CurrentLayout.mode = mode;
Lines 7619-7621 Link Here
7619	break;	7817	break;
7620	}	7818	}
7621	}	7819	}
		7820
		7821
		7822	/*
		7823	* fulivi: interface functions between RADEONSet/GetPortAttribute (in radeon_video.c) and
		7824	* theater_out module.
		7825	*/
		7826	static
		7827	void
		7828	RADEONRedoSwitchMode(
		7829	ScrnInfoPtr pScrn
		7830	)
		7831	{
		7832	int scrnIndex = pScrn->scrnIndex;
		7833
		7834	/*
		7835	* It seems that last parameter (flags) is not used
		7836	*/
		7837	RADEONSwitchMode(scrnIndex , pScrn->currentMode , 0);
		7838	}
		7839
		7840	void
		7841	RADEONTheaterOutSetStandard(
		7842	ScrnInfoPtr pScrn,
		7843	TVStd std
		7844	)
		7845	{
		7846	RADEONInfoPtr info = RADEONPTR(pScrn);
		7847
		7848	RADEONTRACE(("RADEONTheaterOutSetStandard std = %d" , std));
		7849
		7850	if (info->theaterOut != NULL && xf86_theaterOutSetStandard(info->theaterOut , std))
		7851	RADEONRedoSwitchMode(pScrn);
		7852	}
		7853
		7854	TVStd
		7855	RADEONTheaterOutGetStandard(
		7856	ScrnInfoPtr pScrn
		7857	)
		7858	{
		7859	RADEONInfoPtr info = RADEONPTR(pScrn);
		7860
		7861	if (info->theaterOut != NULL)
		7862	return xf86_theaterOutGetStandard(info->theaterOut);
		7863	else
		7864	return TV_STD_KEEP_OFF;
		7865	}
		7866
		7867	Bool
		7868	RADEONTheaterOutGetCompatMode(
		7869	ScrnInfoPtr pScrn
		7870	)
		7871	{
		7872	RADEONInfoPtr info = RADEONPTR(pScrn);
		7873
		7874	if (info->theaterOut != NULL)
		7875	return xf86_theaterOutGetCompatMode(info->theaterOut);
		7876	else
		7877	return FALSE;
		7878	}
		7879
		7880	void
		7881	RADEONTheaterOutSetAttr(
		7882	ScrnInfoPtr pScrn,
		7883	TheaterOutAttr attr,
7884	int value
7885	)
7886	{
7887	RADEONInfoPtr info = RADEONPTR(pScrn);
7888
7889	if (info->theaterOut != NULL)
7890	xf86_theaterOutSetAttr(info->theaterOut , attr , value);
7891	}
7892
7893	int
7894	RADEONTheaterOutGetAttr(
7895	ScrnInfoPtr pScrn,
7896	TheaterOutAttr attr
7897	)
7898	{
7899	RADEONInfoPtr info = RADEONPTR(pScrn);
7900
7901	if (info->theaterOut != NULL)
7902	return xf86_theaterOutGetAttr(info->theaterOut , attr);
7903	else
7904	return 0;
7905	}
7906
7907	void
7908	RADEONTheaterOutGetAttrLimits(
7909	ScrnInfoPtr pScrn,
7910	TheaterOutAttr attr,
7911	int *maxValue,
7912	int *minValue
7913	)
7914	{
7915	RADEONInfoPtr info = RADEONPTR(pScrn);
7916
7917	if (info->theaterOut != NULL)
7918	xf86_theaterOutGetAttrLimits(info->theaterOut , attr , maxValue , minValue);
7919	}

Lines 66-71 Link Here

(-)src/radeon.h.orig (-1 / +30 lines)
66	#include "xf86xv.h"	66	#include "xf86xv.h"
67		67
68	#include "radeon_probe.h"	68	#include "radeon_probe.h"
		69
		70	//20060402
		71	#include "radeon_version.h"
		72	#include "generic_bus.h"
		73
69	/* DRI support */	74	/* DRI support */
70	#ifdef XF86DRI	75	#ifdef XF86DRI
71	#define _XF86DRI_SERVER_	76	#define _XF86DRI_SERVER_
Lines 130-135 Link Here
130	OPTION_RAGE_THEATRE_COMPOSITE_PORT,	135	OPTION_RAGE_THEATRE_COMPOSITE_PORT,
131	OPTION_RAGE_THEATRE_SVIDEO_PORT,	136	OPTION_RAGE_THEATRE_SVIDEO_PORT,
132	OPTION_TUNER_TYPE,	137	OPTION_TUNER_TYPE,
		138	OPTION_TV_OUTPUT,
133	OPTION_RAGE_THEATRE_MICROC_PATH,	139	OPTION_RAGE_THEATRE_MICROC_PATH,
134	OPTION_RAGE_THEATRE_MICROC_TYPE,	140	OPTION_RAGE_THEATRE_MICROC_TYPE,
135	#endif	141	#endif
Lines 292-297 Link Here
292	unsigned ppll_div_3;	298	unsigned ppll_div_3;
293	CARD32 htotal_cntl;	299	CARD32 htotal_cntl;
294		300
		301	//2006021904
		302	CARD32 vclk_ecp_cntl;
		303
295	/* Computed values for PLL2 */	304	/* Computed values for PLL2 */
296	CARD32 dot_clock_freq_2;	305	CARD32 dot_clock_freq_2;
297	CARD32 pll_output_freq_2;	306	CARD32 pll_output_freq_2;
Lines 710-715 Link Here
710	char* RageTheatreMicrocPath;	719	char* RageTheatreMicrocPath;
711	char* RageTheatreMicrocType;	720	char* RageTheatreMicrocType;
712	Bool MM_TABLE_valid;	721	Bool MM_TABLE_valid;
		722	//2006021905
		723	GENERIC_BUS_Ptr VIP;
		724	//2006021908
		725	struct TheaterOut *theaterOut;
713	struct {	726	struct {
714	CARD8 table_revision;	727	CARD8 table_revision;
715	CARD8 table_size;	728	CARD8 table_size;
Lines 806-811 Link Here
806	info->fifo_slots -= entries; \	819	info->fifo_slots -= entries; \
807	} while (0)	820	} while (0)
808		821
		822	//2006021908
		823	#include "theater_out.h"
		824
809	extern RADEONEntPtr RADEONEntPriv(ScrnInfoPtr pScrn);	825	extern RADEONEntPtr RADEONEntPriv(ScrnInfoPtr pScrn);
810	extern void RADEONWaitForFifoFunction(ScrnInfoPtr pScrn, int entries);	826	extern void RADEONWaitForFifoFunction(ScrnInfoPtr pScrn, int entries);
811	extern void RADEONWaitForIdleMMIO(ScrnInfoPtr pScrn);	827	extern void RADEONWaitForIdleMMIO(ScrnInfoPtr pScrn);
Lines 816-821 Link Here
816	extern void RADEONDoAdjustFrame(ScrnInfoPtr pScrn, int x, int y,	832	extern void RADEONDoAdjustFrame(ScrnInfoPtr pScrn, int x, int y,
817	int clone);	833	int clone);
818		834
		835	//2006021919
		836	extern void RADEONTheaterOutSetStandard(ScrnInfoPtr, TVStd);
		837	extern TVStd RADEONTheaterOutGetStandard(ScrnInfoPtr);
		838	extern Bool RADEONTheaterOutGetCompatMode(ScrnInfoPtr);
		839	extern void RADEONTheaterOutSetAttr(ScrnInfoPtr, TheaterOutAttr, int);
		840	extern int RADEONTheaterOutGetAttr(ScrnInfoPtr, TheaterOutAttr);
		841	extern void RADEONTheaterOutGetAttrLimits(ScrnInfoPtr, TheaterOutAttr, int , int );
		842
819	extern void RADEONEngineReset(ScrnInfoPtr pScrn);	843	extern void RADEONEngineReset(ScrnInfoPtr pScrn);
820	extern void RADEONEngineFlush(ScrnInfoPtr pScrn);	844	extern void RADEONEngineFlush(ScrnInfoPtr pScrn);
821	extern void RADEONEngineRestore(ScrnInfoPtr pScrn);	845	extern void RADEONEngineRestore(ScrnInfoPtr pScrn);
Lines 847-853 Link Here
847		871
848	extern int RADEONMinBits(int val);	872	extern int RADEONMinBits(int val);
849		873
850	extern void RADEONInitVideo(ScreenPtr pScreen);	874	//2006021919
		875	extern GENERIC_BUS_Ptr RADEONAllocateVIP(ScrnInfoPtr pScrn);
		876
		877	//2006021911
		878	//extern void RADEONInitVideo(ScreenPtr pScreen);
		879	extern void RADEONInitVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre);
851	extern void RADEONResetVideo(ScrnInfoPtr pScrn);	880	extern void RADEONResetVideo(ScrnInfoPtr pScrn);
852	extern void R300CGWorkaround(ScrnInfoPtr pScrn);	881	extern void R300CGWorkaround(ScrnInfoPtr pScrn);
853		882

Lines 1223-1228 Link Here

(-)src/radeon_reg.h.orig (+4 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	//2006021914
		1227	# define RADEON_PPLL_PVG_MASK (7 << 11)
		1228	# define RADEON_PPLL_PVG_SHIFT 11
		1229
1226	# define RADEON_PPLL_ATOMIC_UPDATE_VSYNC (1 << 18)	1230	# define RADEON_PPLL_ATOMIC_UPDATE_VSYNC (1 << 18)
1227	#define RADEON_PPLL_DIV_0 0x0004 /* PLL */	1231	#define RADEON_PPLL_DIV_0 0x0004 /* PLL */
1228	#define RADEON_PPLL_DIV_1 0x0005 /* PLL */	1232	#define RADEON_PPLL_DIV_1 0x0005 /* PLL */

Lines 74-80 Link Here

(-)src/radeon_video.c.orig (-12 / +132 lines)
74		74
75	static void RADEONInitOffscreenImages(ScreenPtr);	75	static void RADEONInitOffscreenImages(ScreenPtr);
76		76
77	static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr);	77	//2006021912
		78	//static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr);
		79	static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr , GENERIC_BUS_Ptr , Bool);
78	static int RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);	80	static int RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);
79	static int RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);	81	static int RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);
80	static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);	82	static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);
Lines 116-121 Link Here
116		118
117	static Atom xvOvAlpha, xvGrAlpha, xvAlphaMode;	119	static Atom xvOvAlpha, xvGrAlpha, xvAlphaMode;
118		120
		121	//2006021920
		122	static Atom xvTvoStandard , xvTvoModeCompat;
		123
		124	typedef struct
		125	{
		126	char *name;
		127	TheaterOutAttr attr;
		128	Atom atom;
		129	} TVOAttr;
		130
		131	static
		132	TVOAttr theaterOutAttrs[] =
		133	{
		134	{"XV_TVO_HPOS" , THEATER_OUT_HPOS , 0 },
		135	{"XV_TVO_VPOS" , THEATER_OUT_VPOS , 0 },
		136	{"XV_TVO_HSIZE" , THEATER_OUT_HSIZE , 0 }
		137	};
		138	#define N_TVO_ATTRS (sizeof(theaterOutAttrs) / sizeof(theaterOutAttrs[ 0 ]))
119		139
120	#define GET_PORT_PRIVATE(pScrn) \	140	#define GET_PORT_PRIVATE(pScrn) \
121	(RADEONPortPrivPtr)((RADEONPTR(pScrn))->adaptor->pPortPrivates[0].ptr)	141	(RADEONPortPrivPtr)((RADEONPTR(pScrn))->adaptor->pPortPrivates[0].ptr)
Lines 134-147 Link Here
134	}	154	}
135	#endif /* USE_EXA */	155	#endif /* USE_EXA */
136		156
137	void RADEONInitVideo(ScreenPtr pScreen)	157	//2006021911
		158	//void RADEONInitVideo(ScreenPtr pScreen)
		159	void RADEONInitVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
138	{	160	{
139	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];	161	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
140	XF86VideoAdaptorPtr adaptors, newAdaptors = NULL;	162	XF86VideoAdaptorPtr adaptors, newAdaptors = NULL;
141	XF86VideoAdaptorPtr newAdaptor = NULL;	163	XF86VideoAdaptorPtr newAdaptor = NULL;
142	int num_adaptors;	164	int num_adaptors;
143		165
144	newAdaptor = RADEONSetupImageVideo(pScreen);	166	//2006021911
		167	// newAdaptor = RADEONSetupImageVideo(pScreen);
		168	newAdaptor = RADEONSetupImageVideo(pScreen , VIP , loadTheatre);
145	RADEONInitOffscreenImages(pScreen);	169	RADEONInitOffscreenImages(pScreen);
146	num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);	170	num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
147		171
Lines 234-240 Link Here
234		258
235	#endif	259	#endif
236		260
237	#define NUM_ATTRIBUTES 22	261	//2006021920
		262	//#define NUM_ATTRIBUTES 22
		263	#define NUM_ATTRIBUTES 22+5
238	#define NUM_DEC_ATTRIBUTES (NUM_ATTRIBUTES+12)	264	#define NUM_DEC_ATTRIBUTES (NUM_ATTRIBUTES+12)
239		265
240	static XF86AttributeRec Attributes[NUM_DEC_ATTRIBUTES+1] =	266	static XF86AttributeRec Attributes[NUM_DEC_ATTRIBUTES+1] =
Lines 250-255 Link Here
250	{XvSettable \| XvGettable, 0, 255, "XV_OVERLAY_ALPHA"},	276	{XvSettable \| XvGettable, 0, 255, "XV_OVERLAY_ALPHA"},
251	{XvSettable \| XvGettable, 0, 255, "XV_GRAPHICS_ALPHA"},	277	{XvSettable \| XvGettable, 0, 255, "XV_GRAPHICS_ALPHA"},
252	{XvSettable \| XvGettable, 0, 1, "XV_ALPHA_MODE"},	278	{XvSettable \| XvGettable, 0, 1, "XV_ALPHA_MODE"},
		279
		280	//2006021920
		281	{XvSettable \| XvGettable, 0, TV_STD_N_STANDARDS-1, "XV_TVO_STANDARD"},
		282	{ XvGettable, 0, ~0, "XV_TVO_MODE_COMPAT"},
		283	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_HPOS"},
		284	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_VPOS"},
		285	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_HSIZE"},
		286
253	{XvSettable \| XvGettable, -1000, 1000, "XV_BRIGHTNESS"},	287	{XvSettable \| XvGettable, -1000, 1000, "XV_BRIGHTNESS"},
254	{XvSettable \| XvGettable, -1000, 1000, "XV_CONTRAST"},	288	{XvSettable \| XvGettable, -1000, 1000, "XV_CONTRAST"},
255	{XvSettable \| XvGettable, -1000, 1000, "XV_SATURATION"},	289	{XvSettable \| XvGettable, -1000, 1000, "XV_SATURATION"},
Lines 1055-1060 Link Here
1055	RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;	1089	RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;
1056	char tmp[200];	1090	char tmp[200];
1057		1091
		1092	//2006021920
		1093	unsigned i;
1058	/* this function is called from ScreenInit. pScreen is used	1094	/* this function is called from ScreenInit. pScreen is used
1059	by XAA internally, but not valid until ScreenInit finishs.	1095	by XAA internally, but not valid until ScreenInit finishs.
1060	*/	1096	*/
Lines 1068-1073 Link Here
1068	xvLocationID = MAKE_ATOM("XV_LOCATION_ID");	1104	xvLocationID = MAKE_ATOM("XV_LOCATION_ID");
1069	xvDumpStatus = MAKE_ATOM("XV_DUMP_STATUS");	1105	xvDumpStatus = MAKE_ATOM("XV_DUMP_STATUS");
1070		1106
		1107	//2006021920
		1108	xvTvoStandard = MAKE_ATOM("XV_TVO_STANDARD");
		1109	xvTvoModeCompat = MAKE_ATOM("XV_TVO_MODE_COMPAT");
		1110
		1111	for (i = 0; i < N_TVO_ATTRS; i++)
		1112	{
		1113	char *name;
		1114	name = theaterOutAttrs[ i ].name;
		1115	theaterOutAttrs[ i ].atom = MakeAtom(name, strlen(name), TRUE);
		1116
		1117	RADEONTRACE(("RADEONResetVideo,name=%s,atom=%d\n",name,theaterOutAttrs[ i ].atom));
		1118	}
		1119
1071	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");	1120	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
1072	xvSaturation = MAKE_ATOM("XV_SATURATION");	1121	xvSaturation = MAKE_ATOM("XV_SATURATION");
1073	xvColor = MAKE_ATOM("XV_COLOR");	1122	xvColor = MAKE_ATOM("XV_COLOR");
Lines 1269-1275 Link Here
1269	}	1318	}
1270		1319
1271	static XF86VideoAdaptorPtr	1320	static XF86VideoAdaptorPtr
1272	RADEONAllocAdaptor(ScrnInfoPtr pScrn)	1321	RADEONAllocAdaptor(ScrnInfoPtr pScrn, GENERIC_BUS_Ptr VIP)
		1322	//2006021913
		1323	//RADEONAllocAdaptor(ScrnInfoPtr pScrn)
1273	{	1324	{
1274	XF86VideoAdaptorPtr adapt;	1325	XF86VideoAdaptorPtr adapt;
1275	RADEONInfoPtr info = RADEONPTR(pScrn);	1326	RADEONInfoPtr info = RADEONPTR(pScrn);
Lines 1385-1391 Link Here
1385	*/	1436	*/
1386	/* Initialize VIP bus */	1437	/* Initialize VIP bus */
1387	if (!info->IsMobility)	1438	if (!info->IsMobility)
1388	RADEONVIP_init(pScrn, pPriv);	1439	RADEONVIP_init(pScrn, pPriv);
		1440	else
		1441	pPriv->VIP = VIP;
		1442	//2006021921
		1443	// RADEONVIP_init(pScrn, pPriv);
		1444
1389		1445
1390	info->adaptor = adapt;	1446	info->adaptor = adapt;
1391		1447
Lines 1468-1480 Link Here
1468	}	1524	}
1469		1525
1470	static XF86VideoAdaptorPtr	1526	static XF86VideoAdaptorPtr
1471	RADEONSetupImageVideo(ScreenPtr pScreen)	1527	RADEONSetupImageVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
		1528	//2006021912
		1529	//RADEONSetupImageVideo(ScreenPtr pScreen)
1472	{	1530	{
1473	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];	1531	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
1474	RADEONPortPrivPtr pPriv;	1532	RADEONPortPrivPtr pPriv;
1475	XF86VideoAdaptorPtr adapt;	1533	XF86VideoAdaptorPtr adapt;
		1534	//2006021912
		1535	unsigned i;
1476		1536
1477	if(!(adapt = RADEONAllocAdaptor(pScrn)))	1537	//2006021912
		1538	// if(!(adapt = RADEONAllocAdaptor(pScrn)))
		1539	if(!(adapt = RADEONAllocAdaptor(pScrn, VIP)))
1478	return NULL;	1540	return NULL;
1479		1541
1480	adapt->type = XvWindowMask \| XvInputMask \| XvImageMask;	1542	adapt->type = XvWindowMask \| XvInputMask \| XvImageMask;
Lines 1500-1505 Link Here
1500	adapt->PutImage = RADEONPutImage;	1562	adapt->PutImage = RADEONPutImage;
1501	adapt->QueryImageAttributes = RADEONQueryImageAttributes;	1563	adapt->QueryImageAttributes = RADEONQueryImageAttributes;
1502		1564
		1565	//2006021921
		1566	/*
		1567	* fulivi: set limits of theater_out attributes
		1568	*/
		1569	for (i = 0; i < N_TVO_ATTRS; i++)
		1570	{
		1571	int maxValue;
		1572	int minValue;
		1573	unsigned j;
		1574
		1575	RADEONTheaterOutGetAttrLimits(pScrn , theaterOutAttrs[ i ].attr , &maxValue , &minValue);
		1576
		1577	for (j = 0; i < NUM_DEC_ATTRIBUTES; j++)
		1578	if (strcmp(theaterOutAttrs[ i ].name , Attributes[ j ].name) == 0)
		1579	{
		1580	Attributes[ j ].min_value = minValue;
		1581	Attributes[ j ].max_value = maxValue;
		1582	break;
		1583	}
		1584	}
		1585
1503	pPriv = (RADEONPortPrivPtr)(adapt->pPortPrivates[0].ptr);	1586	pPriv = (RADEONPortPrivPtr)(adapt->pPortPrivates[0].ptr);
1504	REGION_NULL(pScreen, &(pPriv->clip));	1587	REGION_NULL(pScreen, &(pPriv->clip));
1505		1588
Lines 1802-1809 Link Here
1802	RADEON_TDA9885_SetEncoding(pPriv);	1885	RADEON_TDA9885_SetEncoding(pPriv);
1803	}	1886	}
1804	}	1887	}
1805	else	1888	//2006021922
1806	return BadMatch;	1889	// else
		1890	// return BadMatch;
		1891	else if (attribute == xvTvoStandard)
		1892	{
		1893	value = ClipValue(value , 0 , TV_STD_N_STANDARDS-1);
		1894	RADEONTheaterOutSetStandard(pScrn , (TVStd)value);
		1895	}
		1896	else
		1897	{
		1898	unsigned i;
		1899
		1900	for (i = 0; i < N_TVO_ATTRS; i++)
		1901	if (theaterOutAttrs[ i ].atom == attribute)
		1902	{
		1903	RADEONTheaterOutSetAttr(pScrn , theaterOutAttrs[ i ].attr , value);
		1904	break;
		1905	}
		1906	if (i == N_TVO_ATTRS)
		1907	return BadMatch;
		1908	}
1807		1909
1808	if (setTransform)	1910	if (setTransform)
1809	{	1911	{
Lines 1907-1914 Link Here
1907	*value = pPriv->instance_id;	2009	*value = pPriv->instance_id;
1908	else if(attribute == xvAdjustment)	2010	else if(attribute == xvAdjustment)
1909	*value = pPriv->adjustment;	2011	*value = pPriv->adjustment;
1910	else	2012	else if(attribute == xvTvoStandard) // 2006021923
1911	return BadMatch;	2013	*value = (INT32)RADEONTheaterOutGetStandard(pScrn);
		2014	else if(attribute == xvTvoModeCompat)
		2015	*value = (INT32)RADEONTheaterOutGetCompatMode(pScrn);
		2016	else {
		2017	unsigned i;
		2018
		2019	for (i = 0; i < N_TVO_ATTRS; i++) {
		2020	if (theaterOutAttrs[ i ].atom == attribute) {
		2021	*value = (INT32)RADEONTheaterOutGetAttr(pScrn , theaterOutAttrs[ i].attr);
		2022	break;
		2023	}
		2024	}
		2025	if (i == N_TVO_ATTRS)
		2026	return BadMatch;
		2027	}
		2028
		2029	//2006021923
		2030	// else
		2031	// return BadMatch;
1912		2032
1913	return Success;	2033	return Success;
1914	}	2034	}

Lines 47-52 Link Here

(-)src/radeon_video.h.orig (+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 342-347 Link Here

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





      *******************************************************
      **  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];
   
if (b != NULL)
{
//	RTTRACE(("0711:OK\n"));
}
else
{
//	RTTRACE(("0712:FAILED\n"));
}


  b->ioctl(b , GB_IOCTL_GET_TYPE , 20 , s);

//RTTRACE(("0713: %s vs %s\n",VIP_TYPE,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++)
	{
//	RTTRACE(("0713X\n"));
	  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 , val);
//		RTTRACE(("07130\n"));
		}
	      if (t->theatre_num >= 0)
		{
//		RTTRACE(("07131\n"));
		continue;	// already found one instance
		}
	      if (val == RT100_ATI_ID)
		{
//		RTTRACE(("07132\n"));
		t->theatre_num = i;
		}
	    } 
	  else 
	    {
//		RTTRACE(("0713Y\n"));
	      xf86DrvMsg(b->scrnIndex , X_INFO , "No response from device %d on VIP bus\n" , i);	
	    }
	}
//		RTTRACE(("0713Z\n"));
      if (t->theatre_num >= 0)
	{
//      RTTRACE(("0714:OK\n"));
	  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" , val);
	}
      else
	{
//	  RTTRACE(("0714:FAILED\n"));
	  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;
}




/*********************************************************************
 *
 * $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

Line 0 Link Here

(-)src/tvo_set/Imakefile.orig (+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)

Lines 96-101 Link Here

(-)src/Makefile.am.orig (+10 lines)
96	theatre_drv_la_SOURCES = \	96	theatre_drv_la_SOURCES = \
97	theatre.c theatre_module.c	97	theatre.c theatre_module.c
98		98
		99	theater_out_drv_la_LTLIBRARIES = theater_out_drv.la
		100	theater_out_drv_la_LDFLAGS = -module -avoid-version
		101	theater_out_drv_ladir = @moduledir@/multimedia
		102	theater_out_drv_la_CFLAGS = \
		103	$(AM_CFLAGS) -DMICROC_DIR=\"$(theater_out_drv_ladir)\"
		104	theater_out_drv_la_SOURCES = \
		105	theater_out.c theater_out_module.c
		106
		107
99	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la	108	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la
100	theatre200_drv_la_LDFLAGS = -module -avoid-version	109	theatre200_drv_la_LDFLAGS = -module -avoid-version
101	theatre200_drv_ladir = @moduledir@/multimedia	110	theatre200_drv_ladir = @moduledir@/multimedia
Lines 190-195 Link Here
190	radeon_sarea.h \	199	radeon_sarea.h \
191	radeon_version.h \	200	radeon_version.h \
192	radeon_video.h \	201	radeon_video.h \
		202	theater_out.h \
193	theatre200.h \	203	theatre200.h \
194	theatre_detect.h \	204	theatre_detect.h \
195	theatre.h \	205	theatre.h \

Line 0 Link Here

(-)src/README.tvout.orig (+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

(-)src/theater_out.h.orig (+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

(-)src/theater_out_module.c.orig (+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

(-)src/tvo_set/tvo_set.c.orig (+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	}