Attachment #115366 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)




am__installdirs = "$(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)"

atimisc_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
r128_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
radeon_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
theater_out_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
theatre200_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
theatre_detect_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
theatre_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
LTLIBRARIES = $(ati_drv_la_LTLIBRARIES) $(atimisc_drv_la_LTLIBRARIES) \
	$(r128_drv_la_LTLIBRARIES) $(radeon_drv_la_LTLIBRARIES) \
	$(theater_out_drv_la_LTLIBRARIES) \
	$(theatre200_drv_la_LTLIBRARIES) \
	$(theatre_detect_drv_la_LTLIBRARIES) \
	$(theatre_drv_la_LTLIBRARIES)

	radeon_video.lo radeon_bios.lo radeon_mm_i2c.lo radeon_vip.lo \
	radeon_misc.lo $(am__objects_7) $(am__objects_8)
radeon_drv_la_OBJECTS = $(am_radeon_drv_la_OBJECTS)
theatre_out_drv_la_LIBADD =
am_theater_out_drv_la_OBJECTS = theater_out_drv_la-theater_out.lo \
	theater_out_drv_la-theater_out_module.lo
theater_out_drv_la_OBJECTS = $(am_theater_out_drv_la_OBJECTS)
theatre200_drv_la_LIBADD =
am_theatre200_drv_la_OBJECTS = theatre200_drv_la-theatre200.lo \
	theatre200_drv_la-theatre200_module.lo

	$(AM_LDFLAGS) $(LDFLAGS) -o $@
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_SOURES) \
	$(theatre_detect_drv_la_SOURCES) $(theatre_drv_la_SOURCES)
DIST_SOURCES = $(am__ati_drv_la_SOURCES_DIST) \
	$(am__atimisc_drv_la_SOURCES_DIST) \
	$(am__r128_drv_la_SOURCES_DIST) \
	$(am__radeon_drv_la_SOURCES_DIST) $(theater_out_drv_la_SOURCES) \
	$(theatre200_drv_la_SOURCES) $(theatre_detect_drv_la_SOURCES) \
	$(theatre_drv_la_SOURCES)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

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 \

	  echo "rm -f \"$${dir}/so_locations\""; \
	  rm -f "$${dir}/so_locations"; \
	done
install-theater_out_drv_laLTLIBRARIES: $(theater_out_drv_la_LTLIBRARIES)
	@$(NORMAL_INSTALL)
	test -z "$(theater_out_drv_ladir)" || $(mkdir_p) "$(DESTDIR)$(theater_out_drv_ladir)"
	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
	  if test -f $$p; then \
	    f=$(am__strip_dir) \
	    echo " $(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(theater_out_drv_ladir)/$$f'"; \
	    $(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(theater_out_drv_ladir)/$$f"; \
	  else :; fi; \
	done

uninstall-theater_out_drv_laLTLIBRARIES:
	@$(NORMAL_UNINSTALL)
	@set -x; list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
	  p=$(am__strip_dir) \
	  echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(theater_out_drv_ladir)/$$p'"; \
	  $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(theater_out_drv_ladir)/$$p"; \
	done

clean-theater_out_drv_laLTLIBRARIES:
	-test -z "$(theater_out_drv_la_LTLIBRARIES)" || rm -f $(theater_out_drv_la_LTLIBRARIES)
	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
	  test "$$dir" != "$$p" || dir=.; \
	  echo "rm -f \"$${dir}/so_locations\""; \
	  rm -f "$${dir}/so_locations"; \
	done
install-theatre200_drv_laLTLIBRARIES: $(theatre200_drv_la_LTLIBRARIES)
	@$(NORMAL_INSTALL)
	test -z "$(theatre200_drv_ladir)" || $(mkdir_p) "$(DESTDIR)$(theatre200_drv_ladir)"

	$(LINK) -rpath $(r128_drv_ladir) $(r128_drv_la_LDFLAGS) $(r128_drv_la_OBJECTS) $(r128_drv_la_LIBADD) $(LIBS)
radeon_drv.la: $(radeon_drv_la_OBJECTS) $(radeon_drv_la_DEPENDENCIES) 
	$(LINK) -rpath $(radeon_drv_ladir) $(radeon_drv_la_LDFLAGS) $(radeon_drv_la_OBJECTS) $(radeon_drv_la_LIBADD) $(LIBS)
theater_out_drv.la: $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_DEPENDENCIES) 
	$(LINK) -rpath $(theater_out_drv_ladir) $(theater_out_drv_la_LDFLAGS) $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_LIBADD) $(LIBS)
theatre200_drv.la: $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_DEPENDENCIES) 
	$(LINK) -rpath $(theatre200_drv_ladir) $(theatre200_drv_la_LDFLAGS) $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_LIBADD) $(LIBS)
theatre_detect_drv.la: $(theatre_detect_drv_la_OBJECTS) $(theatre_detect_drv_la_DEPENDENCIES) 

@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_probe.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_video.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_vip.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo@am__quote@

@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<

theater_out_drv_la-theater_out.lo: theater_out.c
@am__fastdepCC_TRUE@	if $(LIBTOOL) --tag=CC --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" -c -o theater_out_drv_la-theater_out.lo `test -f 'theater_out.c' || echo '$(srcdir)/'`theater_out.c; \
@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Plo"; else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; fi
@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='theater_out.c' object='theater_out_drv_la-theater_out.lo' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@	$(LIBTOOL) --tag=CC --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

theater_out_drv_la-theater_out_module.lo: theater_out_module.c
@am__fastdepCC_TRUE@	if $(LIBTOOL) --tag=CC --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" -c -o theater_out_drv_la-theater_out_module.lo `test -f 'theater_out_module.c' || echo '$(srcdir)/'`theater_out_module.c; \
@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo"; else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; fi
@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.lo' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@	$(LIBTOOL) --tag=CC --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

theatre200_drv_la-theatre200.lo: theatre200.c
@am__fastdepCC_TRUE@	if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theatre200_drv_la_CFLAGS) $(CFLAGS) -MT theatre200_drv_la-theatre200.lo -MD -MP -MF "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" -c -o theatre200_drv_la-theatre200.lo `test -f 'theatre200.c' || echo '$(srcdir)/'`theatre200.c; \
@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" "$(DEPDIR)/theatre200_drv_la-theatre200.Plo"; else rm -f "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo"; exit 1; fi

check: check-am
all-am: Makefile $(LTLIBRARIES)
installdirs:
	for dir in "$(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)"; do \
	  test -z "$$dir" || $(mkdir_p) "$$dir"; \
	done
install: install-am

clean-am: clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
	clean-radeon_drv_laLTLIBRARIES \
	clean-theater_out_drv_laLTLIBRARIES \
	clean-theatre200_drv_laLTLIBRARIES \
	clean-theatre_detect_drv_laLTLIBRARIES \
	clean-theatre_drv_laLTLIBRARIES mostlyclean-am

	install-atimisc_drv_laLTLIBRARIES \
	install-r128_drv_laLTLIBRARIES \
	install-radeon_drv_laLTLIBRARIES \
	install-theater_out_drv_laLTLIBRARIES \
	install-theatre200_drv_laLTLIBRARIES \
	install-theatre_detect_drv_laLTLIBRARIES \
	install-theatre_drv_laLTLIBRARIES

	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
	uninstall-r128_drv_laLTLIBRARIES \
	uninstall-radeon_drv_laLTLIBRARIES \
	uninstall-theater_out_drv_laLTLIBRARIES \
	uninstall-theatre200_drv_laLTLIBRARIES \
	uninstall-theatre_detect_drv_laLTLIBRARIES \
	uninstall-theatre_drv_laLTLIBRARIES

	clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
	clean-radeon_drv_laLTLIBRARIES \
	clean-theater_out_drv_laLTLIBRARIES \
	clean-theatre200_drv_laLTLIBRARIES \
	clean-theatre_detect_drv_laLTLIBRARIES \
	clean-theatre_drv_laLTLIBRARIES ctags distclean \

	install-exec install-exec-am install-info install-info-am \
	install-man install-r128_drv_laLTLIBRARIES \
	install-radeon_drv_laLTLIBRARIES install-strip \
	install-theater_out_drv_laLTLIBRARIES \
	install-theatre200_drv_laLTLIBRARIES \
	install-theatre_detect_drv_laLTLIBRARIES \
	install-theatre_drv_laLTLIBRARIES installcheck installcheck-am \

	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
	uninstall-r128_drv_laLTLIBRARIES \
	uninstall-radeon_drv_laLTLIBRARIES \
	uninstall-theater_out_drv_laLTLIBRARIES \
	uninstall-theatre200_drv_laLTLIBRARIES \
	uninstall-theatre_detect_drv_laLTLIBRARIES \
	uninstall-theatre_drv_laLTLIBRARIES




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 \





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


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 76-81 Link Here

(-)src/radeon_driver.c.orig (-9 / +302 lines)
76	#include "radeon_macros.h"	76	#include "radeon_macros.h"
77	#include "radeon_probe.h"	77	#include "radeon_probe.h"
78	#include "radeon_version.h"	78	#include "radeon_version.h"
		79	//2006021906
		80	#include "theater_out.h"
79	#include "radeon_mergedfb.h"	81	#include "radeon_mergedfb.h"
80		82
81	#ifdef XF86DRI	83	#ifdef XF86DRI
Lines 196-201 Link Here
196	{ OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE },	198	{ OPTION_RAGE_THEATRE_COMPOSITE_PORT, "RageTheatreCompositePort", OPTV_INTEGER, {0}, FALSE },
197	{ OPTION_RAGE_THEATRE_SVIDEO_PORT, "RageTheatreSVideoPort", OPTV_INTEGER, {0}, FALSE },	199	{ OPTION_RAGE_THEATRE_SVIDEO_PORT, "RageTheatreSVideoPort", OPTV_INTEGER, {0}, FALSE },
198	{ OPTION_TUNER_TYPE, "TunerType", OPTV_INTEGER, {0}, FALSE },	200	{ OPTION_TUNER_TYPE, "TunerType", OPTV_INTEGER, {0}, FALSE },
		201	//2006021906
		202	{ OPTION_TV_OUTPUT, "TVOutput", OPTV_ANYSTR, {0}, FALSE },
199	{ OPTION_RAGE_THEATRE_MICROC_PATH, "RageTheatreMicrocPath", OPTV_STRING, {0}, FALSE },	203	{ OPTION_RAGE_THEATRE_MICROC_PATH, "RageTheatreMicrocPath", OPTV_STRING, {0}, FALSE },
200	{ OPTION_RAGE_THEATRE_MICROC_TYPE, "RageTheatreMicrocType", OPTV_STRING, {0}, FALSE },	204	{ OPTION_RAGE_THEATRE_MICROC_TYPE, "RageTheatreMicrocType", OPTV_STRING, {0}, FALSE },
201	#endif	205	#endif
Lines 5700-5705 Link Here
5700		5704
5701	info->PaletteSavedOnVT = FALSE;	5705	info->PaletteSavedOnVT = FALSE;
5702		5706
		5707	//2006021909
		5708	RADEONTRACE(("Allocating VIP interface"));
		5709	info->VIP = RADEONAllocateVIP(pScrn);
		5710
		5711	/*
		5712	if (info->VIP != NULL)
		5713	{
		5714	RADEONTRACE(("\n061:NOT NULL\n"));
		5715	}
		5716	else
		5717	{
		5718	RADEONTRACE(("\n062:NULL\n"));
		5719	}
		5720	*/
		5721
		5722	//2006021907
		5723	if ((s = xf86GetOptValString(info->Options , OPTION_TV_OUTPUT)) != NULL && xf86NameCmp(s , "NOLOAD") != 0)
		5724	{
		5725	//RADEONTRACE(("TVOUT OPTION ON\n"));
		5726	RADEONTRACE(("TVOutput opt = %s\n" , s));
		5727	if(!xf86LoadSubModule(pScrn , "theater_out"))
		5728	{
		5729	RADEONTRACE(("Failed to find theater_out module\n"));
		5730	xf86DrvMsg(pScrn->scrnIndex , X_ERROR , "Unable to load TV output module\n");
		5731	info->theaterOut = NULL;
		5732	}
		5733	else
		5734	{
		5735	RADEONTRACE(("Found theater_out module\n"));
		5736	xf86LoaderReqSymbols(THEATER_OUT_SYMBOLS , NULL);
		5737	// RADEONTRACE(("071:OK\n"));
		5738
		5739	info->theaterOut = xf86_detectTheaterOut(pScrn , FALSE,info->VIP);
		5740	// RADEONTRACE(("072:OK\n"));
		5741	if (info->theaterOut != NULL)
		5742	{
		5743	// RADEONTRACE(("072:NOT NULL\n"));
		5744	xf86_initTheaterOut(info->theaterOut , s);
		5745	// RADEONTRACE(("073:start init\n"));
		5746	}
		5747	else
		5748	{
		5749	RADEONTRACE(("TheaterOut is NULL!!\n"));
		5750	}
		5751
		5752	}
		5753
		5754	}
		5755	else
		5756	{
		5757	// RADEONTRACE(("NO TVOUT OPTION\n"));
		5758	}
		5759
		5760
		5761
		5762
		5763
5703	RADEONSave(pScrn);	5764	RADEONSave(pScrn);
5704		5765
5705	if ((!info->IsSecondary) && info->IsMobility) {	5766	if ((!info->IsSecondary) && info->IsMobility) {
Lines 6147-6153 Link Here
6147		6208
6148	/* Init Xv */	6209	/* Init Xv */
6149	RADEONTRACE(("Initializing Xv\n"));	6210	RADEONTRACE(("Initializing Xv\n"));
6150	RADEONInitVideo(pScreen);	6211	//2006021911
		6212	// RADEONInitVideo(pScreen);
		6213	RADEONInitVideo(pScreen , info->VIP , TRUE);
6151		6214
6152	if(info->MergedFB)	6215	if(info->MergedFB)
6153	/* need this here to fix up sarea values */	6216	/* need this here to fix up sarea values */
Lines 6387-6393 Link Here
6387	OUTREG(RADEON_OVR_WID_TOP_BOTTOM, restore->ovr_wid_top_bottom);	6450	OUTREG(RADEON_OVR_WID_TOP_BOTTOM, restore->ovr_wid_top_bottom);
6388	OUTREG(RADEON_OV0_SCALE_CNTL, restore->ov0_scale_cntl);	6451	OUTREG(RADEON_OV0_SCALE_CNTL, restore->ov0_scale_cntl);
6389	OUTREG(RADEON_SUBPIC_CNTL, restore->subpic_cntl);	6452	OUTREG(RADEON_SUBPIC_CNTL, restore->subpic_cntl);
6390	OUTREG(RADEON_VIPH_CONTROL, restore->viph_control);	6453	//2006021914
		6454	// OUTREG(RADEON_VIPH_CONTROL, restore->viph_control);
		6455	/*
		6456	* fulivi: removed. It messes the VIP access up
		6457	*/
		6458
6391	OUTREG(RADEON_I2C_CNTL_1, restore->i2c_cntl_1);	6459	OUTREG(RADEON_I2C_CNTL_1, restore->i2c_cntl_1);
6392	OUTREG(RADEON_GEN_INT_CNTL, restore->gen_int_cntl);	6460	OUTREG(RADEON_GEN_INT_CNTL, restore->gen_int_cntl);
6393	OUTREG(RADEON_CAP0_TRIG_CNTL, restore->cap0_trig_cntl);	6461	OUTREG(RADEON_CAP0_TRIG_CNTL, restore->cap0_trig_cntl);
Lines 6473-6478 Link Here
6473	OUTREG(RADEON_CRTC_OFFSET, restore->crtc_offset);	6541	OUTREG(RADEON_CRTC_OFFSET, restore->crtc_offset);
6474	OUTREG(RADEON_CRTC_OFFSET_CNTL, restore->crtc_offset_cntl);	6542	OUTREG(RADEON_CRTC_OFFSET_CNTL, restore->crtc_offset_cntl);
6475	OUTREG(RADEON_CRTC_PITCH, restore->crtc_pitch);	6543	OUTREG(RADEON_CRTC_PITCH, restore->crtc_pitch);
		6544	//2006021914
		6545	OUTREG(RADEON_DISP_OUTPUT_CNTL, restore->disp_output_cntl);
6476	OUTREG(RADEON_DISP_MERGE_CNTL, restore->disp_merge_cntl);	6546	OUTREG(RADEON_DISP_MERGE_CNTL, restore->disp_merge_cntl);
6477	OUTREG(RADEON_CRTC_MORE_CNTL, restore->crtc_more_cntl);	6547	OUTREG(RADEON_CRTC_MORE_CNTL, restore->crtc_more_cntl);
6478		6548
Lines 6655-6666 Link Here
6655	~(RADEON_P2PLL_ATOMIC_UPDATE_W));	6725	~(RADEON_P2PLL_ATOMIC_UPDATE_W));
6656	}	6726	}
6657		6727
		6728	//2006021914
		6729	static
		6730	CARD8
		6731	RADEONComputePLLGain(
		6732	CARD16 reference_freq,
		6733	CARD16 ref_div,
		6734	CARD16 fb_div
		6735	)
		6736	{
		6737	unsigned vcoFreq;
		6738
		6739	vcoFreq = ((unsigned)reference_freq * fb_div) / ref_div;
		6740
		6741	/*
		6742	* This is orribly crude: the VCO frequency range is divided into
		6743	* 3 parts, each part having a fixed PLL gain value.
		6744	*/
		6745	if (vcoFreq >= 30000)
		6746	/*
		6747	* [300..max] MHz : 7
		6748	*/
		6749	return 7;
		6750	else if (vcoFreq >= 18000)
		6751	/*
		6752	* [180..300) MHz : 4
		6753	*/
		6754	return 4;
		6755	else
		6756	/*
		6757	* [0..180) MHz : 1
		6758	*/
		6759	return 1;
		6760	}
		6761
		6762
6658	/* Write PLL registers */	6763	/* Write PLL registers */
6659	static void RADEONRestorePLLRegisters(ScrnInfoPtr pScrn,	6764	static void RADEONRestorePLLRegisters(ScrnInfoPtr pScrn,
6660	RADEONSavePtr restore)	6765	RADEONSavePtr restore)
6661	{	6766	{
6662	RADEONInfoPtr info = RADEONPTR(pScrn);	6767	RADEONInfoPtr info = RADEONPTR(pScrn);
6663	unsigned char *RADEONMMIO = info->MMIO;	6768	unsigned char *RADEONMMIO = info->MMIO;
		6769	//2006021914
		6770	CARD8 pllGain;
6664		6771
6665	if (info->IsMobility) {	6772	if (info->IsMobility) {
6666	/* A temporal workaround for the occational blanking on certain laptop panels.	6773	/* A temporal workaround for the occational blanking on certain laptop panels.
Lines 6683-6697 Link Here
6683	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,	6790	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,
6684	RADEON_VCLK_SRC_SEL_CPUCLK,	6791	RADEON_VCLK_SRC_SEL_CPUCLK,
6685	~(RADEON_VCLK_SRC_SEL_MASK));	6792	~(RADEON_VCLK_SRC_SEL_MASK));
		6793	//2006021914
		6794	pllGain = RADEONComputePLLGain(info->pll.reference_freq,
		6795	restore->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
		6796	restore->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK);
		6797
		6798
6686		6799
6687	OUTPLLP(pScrn,	6800	OUTPLLP(pScrn,
6688	RADEON_PPLL_CNTL,	6801	RADEON_PPLL_CNTL,
6689	RADEON_PPLL_RESET	6802	RADEON_PPLL_RESET
6690	\| RADEON_PPLL_ATOMIC_UPDATE_EN	6803	\| RADEON_PPLL_ATOMIC_UPDATE_EN
6691	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN,	6804	//2006021914
		6805	// \| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN,
		6806	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
		6807	\| ((CARD32)pllGain << RADEON_PPLL_PVG_SHIFT),
6692	~(RADEON_PPLL_RESET	6808	~(RADEON_PPLL_RESET
6693	\| RADEON_PPLL_ATOMIC_UPDATE_EN	6809	\| RADEON_PPLL_ATOMIC_UPDATE_EN
6694	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN));	6810	//2006021914
		6811	// \| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN));
		6812	\| RADEON_PPLL_VGA_ATOMIC_UPDATE_EN
		6813	\| RADEON_PPLL_PVG_MASK));
		6814
6695		6815
6696	OUTREGP(RADEON_CLOCK_CNTL_INDEX,	6816	OUTREGP(RADEON_CLOCK_CNTL_INDEX,
6697	RADEON_PLL_DIV_SEL,	6817	RADEON_PLL_DIV_SEL,
Lines 6751-6759 Link Here
6751		6871
6752	usleep(50000); /* Let the clock to lock */	6872	usleep(50000); /* Let the clock to lock */
6753		6873
6754	OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,	6874	//2006021914
6755	RADEON_VCLK_SRC_SEL_PPLLCLK,	6875	// OUTPLLP(pScrn, RADEON_VCLK_ECP_CNTL,
6756	~(RADEON_VCLK_SRC_SEL_MASK));	6876	// RADEON_VCLK_SRC_SEL_PPLLCLK,
		6877	// ~(RADEON_VCLK_SRC_SEL_MASK));
		6878	OUTPLL(pScrn, RADEON_VCLK_ECP_CNTL , restore->vclk_ecp_cntl);
		6879
		6880	RADEONTRACE(("VCLK_ECP_CNTL = %08X\n" , restore->vclk_ecp_cntl));
		6881
6757	}	6882	}
6758		6883
6759		6884
Lines 7176-7181 Link Here
7176	save->crtc_offset = INREG(RADEON_CRTC_OFFSET);	7301	save->crtc_offset = INREG(RADEON_CRTC_OFFSET);
7177	save->crtc_offset_cntl = INREG(RADEON_CRTC_OFFSET_CNTL);	7302	save->crtc_offset_cntl = INREG(RADEON_CRTC_OFFSET_CNTL);
7178	save->crtc_pitch = INREG(RADEON_CRTC_PITCH);	7303	save->crtc_pitch = INREG(RADEON_CRTC_PITCH);
		7304	//2006021915
		7305	save->disp_output_cntl = INREG(RADEON_DISP_OUTPUT_CNTL);
7179	save->disp_merge_cntl = INREG(RADEON_DISP_MERGE_CNTL);	7306	save->disp_merge_cntl = INREG(RADEON_DISP_MERGE_CNTL);
7180	save->crtc_more_cntl = INREG(RADEON_CRTC_MORE_CNTL);	7307	save->crtc_more_cntl = INREG(RADEON_CRTC_MORE_CNTL);
7181		7308
Lines 7245-7250 Link Here
7245	save->ppll_ref_div = INPLL(pScrn, RADEON_PPLL_REF_DIV);	7372	save->ppll_ref_div = INPLL(pScrn, RADEON_PPLL_REF_DIV);
7246	save->ppll_div_3 = INPLL(pScrn, RADEON_PPLL_DIV_3);	7373	save->ppll_div_3 = INPLL(pScrn, RADEON_PPLL_DIV_3);
7247	save->htotal_cntl = INPLL(pScrn, RADEON_HTOTAL_CNTL);	7374	save->htotal_cntl = INPLL(pScrn, RADEON_HTOTAL_CNTL);
		7375	//2006021915
		7376	save->vclk_ecp_cntl= INPLL(pScrn, RADEON_VCLK_ECP_CNTL);
7248		7377
7249	RADEONTRACE(("Read: 0x%08x 0x%08x 0x%08lx\n",	7378	RADEONTRACE(("Read: 0x%08x 0x%08x 0x%08lx\n",
7250	save->ppll_ref_div,	7379	save->ppll_ref_div,
Lines 7254-7259 Link Here
7254	save->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,	7383	save->ppll_ref_div & RADEON_PPLL_REF_DIV_MASK,
7255	save->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK,	7384	save->ppll_div_3 & RADEON_PPLL_FB3_DIV_MASK,
7256	(save->ppll_div_3 & RADEON_PPLL_POST3_DIV_MASK) >> 16));	7385	(save->ppll_div_3 & RADEON_PPLL_POST3_DIV_MASK) >> 16));
		7386	//2006021915
		7387	RADEONTRACE(("Read VCLK_ECP_CNTL = %08x\n" , save->vclk_ecp_cntl));
7257	}	7388	}
7258		7389
7259	/* Read PLL registers */	7390	/* Read PLL registers */
Lines 7362-7367 Link Here
7362	RADEONSaveMode(pScrn, save);	7493	RADEONSaveMode(pScrn, save);
7363	if (!info->IsSecondary)	7494	if (!info->IsSecondary)
7364	RADEONSaveSurfaces(pScrn, save);	7495	RADEONSaveSurfaces(pScrn, save);
		7496
		7497	//2006021915
		7498	/*
		7499	* Save initial RT state
		7500	*/
		7501	if (info->theaterOut != NULL)
		7502	{
		7503	// RADEONTRACE(("2006021915\n"));
		7504	xf86_theaterOutSave(info->theaterOut , pScrn);
		7505	}
7365	}	7506	}
7366		7507
7367	/* Restore the original (text) mode */	7508	/* Restore the original (text) mode */
Lines 7404-7409 Link Here
7404	if (!info->IsSecondary)	7545	if (!info->IsSecondary)
7405	RADEONRestoreSurfaces(pScrn, restore);	7546	RADEONRestoreSurfaces(pScrn, restore);
7406		7547
		7548	/*
		7549	* Restore RT state
		7550	*/
		7551	if (info->theaterOut != NULL)
		7552	{
		7553	// RADEONTRACE(("2006021915-2\n"));
		7554	xf86_theaterOutRestore(info->theaterOut , pScrn);
		7555	}
7407	#if 0	7556	#if 0
7408	/* Temp fix to "solve" VT switch problems. When switching VTs on	7557	/* Temp fix to "solve" VT switch problems. When switching VTs on
7409	* some systems, the console can either hang or the fonts can be	7558	* some systems, the console can either hang or the fonts can be
Lines 8154-8160 Link Here
8154	save->crtc2_gen_cntl = (RADEON_CRTC2_EN \| (format << 8));	8303	save->crtc2_gen_cntl = (RADEON_CRTC2_EN \| (format << 8));
8155	save->fp2_h_sync_strt_wid = save->crtc2_h_sync_strt_wid;	8304	save->fp2_h_sync_strt_wid = save->crtc2_h_sync_strt_wid;
8156	save->fp2_v_sync_strt_wid = save->crtc2_v_sync_strt_wid;	8305	save->fp2_v_sync_strt_wid = save->crtc2_v_sync_strt_wid;
8157	save->fp2_gen_cntl = info->SavedReg.fp2_gen_cntl \| RADEON_FP2_ON;	8306	//2006021915
		8307	// save->fp2_gen_cntl = info->SavedReg.fp2_gen_cntl \| RADEON_FP2_ON;
		8308	save->fp2_gen_cntl = info->SavedReg.fp2_gen_cntl
		8309	\| RADEON_FP2_SRC_SEL_CRTC2
		8310	\| RADEON_FP2_ON;
		8311
8158	save->fp2_gen_cntl &= ~(RADEON_FP2_BLANK_EN);	8312	save->fp2_gen_cntl &= ~(RADEON_FP2_BLANK_EN);
8159		8313
8160	if ((info->ChipFamily == CHIP_FAMILY_R200) \|\|	8314	if ((info->ChipFamily == CHIP_FAMILY_R200) \|\|
Lines 8500-8514 Link Here
8500	pll->reference_freq);	8654	pll->reference_freq);
8501	save->post_div = post_div->divider;	8655	save->post_div = post_div->divider;
8502		8656
		8657	//2006021915
		8658	/*
8503	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",	8659	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",
8504	save->dot_clock_freq,	8660	save->dot_clock_freq,
8505	save->pll_output_freq,	8661	save->pll_output_freq,
8506	save->feedback_div,	8662	save->feedback_div,
8507	save->post_div));	8663	save->post_div));
		8664	*/
8508		8665
8509	save->ppll_ref_div = pll->reference_div;	8666	save->ppll_ref_div = pll->reference_div;
8510	save->ppll_div_3 = (save->feedback_div \| (post_div->bitvalue << 16));	8667	save->ppll_div_3 = (save->feedback_div \| (post_div->bitvalue << 16));
8511	save->htotal_cntl = 0;	8668	save->htotal_cntl = 0;
		8669	//2006021915
		8670	save->vclk_ecp_cntl = (save->vclk_ecp_cntl & ~RADEON_VCLK_SRC_SEL_MASK) \| RADEON_VCLK_SRC_SEL_PPLLCLK;
8512	}	8671	}
8513		8672
8514	/* Define PLL2 registers for requested video mode */	8673	/* Define PLL2 registers for requested video mode */
Lines 8561-8572 Link Here
8561	* save->pll_output_freq_2,	8720	* save->pll_output_freq_2,
8562	pll->reference_freq);	8721	pll->reference_freq);
8563	save->post_div_2 = post_div->divider;	8722	save->post_div_2 = post_div->divider;
8564		8723	//2006021915
		8724	/*
8565	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",	8725	RADEONTRACE(("dc=%ld, of=%ld, fd=%d, pd=%d\n",
8566	save->dot_clock_freq_2,	8726	save->dot_clock_freq_2,
8567	save->pll_output_freq_2,	8727	save->pll_output_freq_2,
8568	save->feedback_div_2,	8728	save->feedback_div_2,
8569	save->post_div_2));	8729	save->post_div_2));
		8730	*/
8570		8731
8571	save->p2pll_ref_div = pll->reference_div;	8732	save->p2pll_ref_div = pll->reference_div;
8572	save->p2pll_div_0 = (save->feedback_div_2 \|	8733	save->p2pll_div_0 = (save->feedback_div_2 \|
Lines 8641-8646 Link Here
8641	#endif	8802	#endif
8642		8803
8643	info->Flags = mode->Flags;	8804	info->Flags = mode->Flags;
		8805	//2006021916
		8806	/*
		8807	* Some registers are initialized from text mode state
		8808	*/
		8809	save->disp_output_cntl = RADEONPTR(pScrn)->SavedReg.disp_output_cntl;
		8810	save->vclk_ecp_cntl = RADEONPTR(pScrn)->SavedReg.vclk_ecp_cntl;
		8811
8644		8812
8645	RADEONInitMemMapRegisters(pScrn, save, info);	8813	RADEONInitMemMapRegisters(pScrn, save, info);
8646	RADEONInitCommonRegisters(save, info);	8814	RADEONInitCommonRegisters(save, info);
Lines 8709-8717 Link Here
8709		8877
8710	if (!RADEONInit(pScrn, mode, &info->ModeReg)) return FALSE;	8878	if (!RADEONInit(pScrn, mode, &info->ModeReg)) return FALSE;
8711		8879
		8880	//2006021917
		8881	/*
		8882	* Define RT state
		8883	*/
		8884	if (info->theaterOut != NULL)
		8885	{
		8886	// RADEONTRACE(("2006021917\n"));
		8887	Bool res = xf86_theaterOutInit(info->theaterOut , mode , &info->ModeReg);
		8888	RADEONTRACE(("theaterOutInit returns %d\n" , res));
		8889	}
		8890
		8891
8712	pScrn->vtSema = TRUE;	8892	pScrn->vtSema = TRUE;
8713	RADEONBlank(pScrn);	8893	RADEONBlank(pScrn);
8714	RADEONRestoreMode(pScrn, &info->ModeReg);	8894	RADEONRestoreMode(pScrn, &info->ModeReg);
		8895
		8896	//2006021918
		8897
		8898	/*
		8899	* Set RT to new mode
		8900	*/
		8901	if (info->theaterOut != NULL)
		8902	{
		8903	// RADEONTRACE(("2006021918\n"));
		8904	xf86_theaterOutRestoreMode(info->theaterOut , pScrn);
		8905	}
		8906
		8907
8715	RADEONUnblank(pScrn);	8908	RADEONUnblank(pScrn);
8716		8909
8717	info->CurrentLayout.mode = mode;	8910	info->CurrentLayout.mode = mode;
Lines 10103-10105 Link Here
10103	pScrn->FreeScreen = RADEONFreeScreen;	10296	pScrn->FreeScreen = RADEONFreeScreen;
10104	pScrn->ValidMode = RADEONValidMode;	10297	pScrn->ValidMode = RADEONValidMode;
10105	}	10298	}
		10299
		10300
		10301	/*
		10302	* fulivi: interface functions between RADEONSet/GetPortAttribute (in radeon_video.c) and
		10303	* theater_out module.
		10304	*/
		10305	static
		10306	void
		10307	RADEONRedoSwitchMode(
		10308	ScrnInfoPtr pScrn
		10309	)
		10310	{
		10311	int scrnIndex = pScrn->scrnIndex;
		10312
		10313	/*
		10314	* It seems that last parameter (flags) is not used
		10315	*/
		10316	RADEONSwitchMode(scrnIndex , pScrn->currentMode , 0);
		10317	}
		10318
		10319	void
		10320	RADEONTheaterOutSetStandard(
		10321	ScrnInfoPtr pScrn,
		10322	TVStd std
		10323	)
		10324	{
		10325	RADEONInfoPtr info = RADEONPTR(pScrn);
		10326
		10327	RADEONTRACE(("RADEONTheaterOutSetStandard std = %d" , std));
		10328
		10329	if (info->theaterOut != NULL && xf86_theaterOutSetStandard(info->theaterOut , std))
		10330	RADEONRedoSwitchMode(pScrn);
		10331	}
		10332
		10333	TVStd
		10334	RADEONTheaterOutGetStandard(
		10335	ScrnInfoPtr pScrn
		10336	)
		10337	{
		10338	RADEONInfoPtr info = RADEONPTR(pScrn);
		10339
		10340	if (info->theaterOut != NULL)
		10341	return xf86_theaterOutGetStandard(info->theaterOut);
		10342	else
		10343	return TV_STD_KEEP_OFF;
		10344	}
		10345
		10346	Bool
		10347	RADEONTheaterOutGetCompatMode(
		10348	ScrnInfoPtr pScrn
		10349	)
		10350	{
		10351	RADEONInfoPtr info = RADEONPTR(pScrn);
		10352
		10353	if (info->theaterOut != NULL)
		10354	return xf86_theaterOutGetCompatMode(info->theaterOut);
		10355	else
		10356	return FALSE;
		10357	}
		10358
		10359	void
		10360	RADEONTheaterOutSetAttr(
		10361	ScrnInfoPtr pScrn,
		10362	TheaterOutAttr attr,
10363	int value
10364	)
10365	{
10366	RADEONInfoPtr info = RADEONPTR(pScrn);
10367
10368	if (info->theaterOut != NULL)
10369	xf86_theaterOutSetAttr(info->theaterOut , attr , value);
10370	}
10371
10372	int
10373	RADEONTheaterOutGetAttr(
10374	ScrnInfoPtr pScrn,
10375	TheaterOutAttr attr
10376	)
10377	{
10378	RADEONInfoPtr info = RADEONPTR(pScrn);
10379
10380	if (info->theaterOut != NULL)
10381	return xf86_theaterOutGetAttr(info->theaterOut , attr);
10382	else
10383	return 0;
10384	}
10385
10386	void
10387	RADEONTheaterOutGetAttrLimits(
10388	ScrnInfoPtr pScrn,
10389	TheaterOutAttr attr,
10390	int *maxValue,
10391	int *minValue
10392	)
10393	{
10394	RADEONInfoPtr info = RADEONPTR(pScrn);
10395
10396	if (info->theaterOut != NULL)
10397	xf86_theaterOutGetAttrLimits(info->theaterOut , attr , maxValue , minValue);
10398	}

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 75-81 Link Here

(-)src/radeon_video.c.orig (-12 / +130 lines)
75		75
76	static void RADEONInitOffscreenImages(ScreenPtr);	76	static void RADEONInitOffscreenImages(ScreenPtr);
77		77
78	static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr);	78	//2006021912
		79	//static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr);
		80	static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr , GENERIC_BUS_Ptr , Bool);
79	static int RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);	81	static int RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);
80	static int RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);	82	static int RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);
81	static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);	83	static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);
Lines 117-122 Link Here
117		119
118	static Atom xvOvAlpha, xvGrAlpha, xvAlphaMode;	120	static Atom xvOvAlpha, xvGrAlpha, xvAlphaMode;
119		121
		122	//2006021920
		123	static Atom xvTvoStandard , xvTvoModeCompat;
		124
		125	typedef struct
		126	{
		127	char *name;
		128	TheaterOutAttr attr;
		129	Atom atom;
		130	} TVOAttr;
		131
		132	static
		133	TVOAttr theaterOutAttrs[] =
		134	{
		135	{"XV_TVO_HPOS" , THEATER_OUT_HPOS , 0 },
		136	{"XV_TVO_VPOS" , THEATER_OUT_VPOS , 0 },
		137	{"XV_TVO_HSIZE" , THEATER_OUT_HSIZE , 0 }
		138	};
		139	#define N_TVO_ATTRS (sizeof(theaterOutAttrs) / sizeof(theaterOutAttrs[ 0 ]))
120		140
121	#define GET_PORT_PRIVATE(pScrn) \	141	#define GET_PORT_PRIVATE(pScrn) \
122	(RADEONPortPrivPtr)((RADEONPTR(pScrn))->adaptor->pPortPrivates[0].ptr)	142	(RADEONPortPrivPtr)((RADEONPTR(pScrn))->adaptor->pPortPrivates[0].ptr)
Lines 135-148 Link Here
135	}	155	}
136	#endif /* USE_EXA */	156	#endif /* USE_EXA */
137		157
138	void RADEONInitVideo(ScreenPtr pScreen)	158	//2006021911
		159	//void RADEONInitVideo(ScreenPtr pScreen)
		160	void RADEONInitVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
139	{	161	{
140	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];	162	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
141	XF86VideoAdaptorPtr adaptors, newAdaptors = NULL;	163	XF86VideoAdaptorPtr adaptors, newAdaptors = NULL;
142	XF86VideoAdaptorPtr newAdaptor = NULL;	164	XF86VideoAdaptorPtr newAdaptor = NULL;
143	int num_adaptors;	165	int num_adaptors;
144		166
145	newAdaptor = RADEONSetupImageVideo(pScreen);	167	//2006021911
		168	// newAdaptor = RADEONSetupImageVideo(pScreen);
		169	newAdaptor = RADEONSetupImageVideo(pScreen , VIP , loadTheatre);
146	RADEONInitOffscreenImages(pScreen);	170	RADEONInitOffscreenImages(pScreen);
147	num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);	171	num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
148		172
Lines 235-241 Link Here
235		259
236	#endif	260	#endif
237		261
238	#define NUM_ATTRIBUTES 22	262	//2006021920
		263	//#define NUM_ATTRIBUTES 22
		264	#define NUM_ATTRIBUTES 22+5
239	#define NUM_DEC_ATTRIBUTES (NUM_ATTRIBUTES+12)	265	#define NUM_DEC_ATTRIBUTES (NUM_ATTRIBUTES+12)
240		266
241	static XF86AttributeRec Attributes[NUM_DEC_ATTRIBUTES+1] =	267	static XF86AttributeRec Attributes[NUM_DEC_ATTRIBUTES+1] =
Lines 251-256 Link Here
251	{XvSettable \| XvGettable, 0, 255, "XV_OVERLAY_ALPHA"},	277	{XvSettable \| XvGettable, 0, 255, "XV_OVERLAY_ALPHA"},
252	{XvSettable \| XvGettable, 0, 255, "XV_GRAPHICS_ALPHA"},	278	{XvSettable \| XvGettable, 0, 255, "XV_GRAPHICS_ALPHA"},
253	{XvSettable \| XvGettable, 0, 1, "XV_ALPHA_MODE"},	279	{XvSettable \| XvGettable, 0, 1, "XV_ALPHA_MODE"},
		280
		281	//2006021920
		282	{XvSettable \| XvGettable, 0, TV_STD_N_STANDARDS-1, "XV_TVO_STANDARD"},
		283	{ XvGettable, 0, ~0, "XV_TVO_MODE_COMPAT"},
		284	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_HPOS"},
		285	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_VPOS"},
		286	{XvSettable \| XvGettable, -1000, 1000, "XV_TVO_HSIZE"},
		287
254	{XvSettable \| XvGettable, -1000, 1000, "XV_BRIGHTNESS"},	288	{XvSettable \| XvGettable, -1000, 1000, "XV_BRIGHTNESS"},
255	{XvSettable \| XvGettable, -1000, 1000, "XV_CONTRAST"},	289	{XvSettable \| XvGettable, -1000, 1000, "XV_CONTRAST"},
256	{XvSettable \| XvGettable, -1000, 1000, "XV_SATURATION"},	290	{XvSettable \| XvGettable, -1000, 1000, "XV_SATURATION"},
Lines 1056-1061 Link Here
1056	RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;	1090	RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;
1057	char tmp[200];	1091	char tmp[200];
1058		1092
		1093	//2006021920
		1094	unsigned i;
1059	/* this function is called from ScreenInit. pScreen is used	1095	/* this function is called from ScreenInit. pScreen is used
1060	by XAA internally, but not valid until ScreenInit finishs.	1096	by XAA internally, but not valid until ScreenInit finishs.
1061	*/	1097	*/
Lines 1069-1074 Link Here
1069	xvLocationID = MAKE_ATOM("XV_LOCATION_ID");	1105	xvLocationID = MAKE_ATOM("XV_LOCATION_ID");
1070	xvDumpStatus = MAKE_ATOM("XV_DUMP_STATUS");	1106	xvDumpStatus = MAKE_ATOM("XV_DUMP_STATUS");
1071		1107
		1108	//2006021920
		1109	xvTvoStandard = MAKE_ATOM("XV_TVO_STANDARD");
		1110	xvTvoModeCompat = MAKE_ATOM("XV_TVO_MODE_COMPAT");
		1111
		1112	for (i = 0; i < N_TVO_ATTRS; i++)
		1113	{
		1114	char *name;
		1115	name = theaterOutAttrs[ i ].name;
		1116	theaterOutAttrs[ i ].atom = MakeAtom(name, strlen(name), TRUE);
		1117
		1118	RADEONTRACE(("RADEONResetVideo,name=%s,atom=%d\n",name,theaterOutAttrs[ i ].atom));
		1119	}
		1120
1072	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");	1121	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
1073	xvSaturation = MAKE_ATOM("XV_SATURATION");	1122	xvSaturation = MAKE_ATOM("XV_SATURATION");
1074	xvColor = MAKE_ATOM("XV_COLOR");	1123	xvColor = MAKE_ATOM("XV_COLOR");
Lines 1270-1276 Link Here
1270	}	1319	}
1271		1320
1272	static XF86VideoAdaptorPtr	1321	static XF86VideoAdaptorPtr
1273	RADEONAllocAdaptor(ScrnInfoPtr pScrn)	1322	RADEONAllocAdaptor(ScrnInfoPtr pScrn, GENERIC_BUS_Ptr VIP)
		1323	//2006021913
		1324	//RADEONAllocAdaptor(ScrnInfoPtr pScrn)
1274	{	1325	{
1275	XF86VideoAdaptorPtr adapt;	1326	XF86VideoAdaptorPtr adapt;
1276	RADEONInfoPtr info = RADEONPTR(pScrn);	1327	RADEONInfoPtr info = RADEONPTR(pScrn);
Lines 1396-1402 Link Here
1396	#endif	1447	#endif
1397		1448
1398	/* Initialize VIP bus */	1449	/* Initialize VIP bus */
1399	RADEONVIP_init(pScrn, pPriv);	1450	//2006021921
		1451	// RADEONVIP_init(pScrn, pPriv);
		1452	pPriv->VIP = VIP;
		1453
1400	info->adaptor = adapt;	1454	info->adaptor = adapt;
1401		1455
1402	if(!xf86LoadSubModule(pScrn,"theatre_detect"))	1456	if(!xf86LoadSubModule(pScrn,"theatre_detect"))
Lines 1478-1490 Link Here
1478	}	1532	}
1479		1533
1480	static XF86VideoAdaptorPtr	1534	static XF86VideoAdaptorPtr
1481	RADEONSetupImageVideo(ScreenPtr pScreen)	1535	RADEONSetupImageVideo(ScreenPtr pScreen , GENERIC_BUS_Ptr VIP , Bool loadTheatre)
		1536	//2006021912
		1537	//RADEONSetupImageVideo(ScreenPtr pScreen)
1482	{	1538	{
1483	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];	1539	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
1484	RADEONPortPrivPtr pPriv;	1540	RADEONPortPrivPtr pPriv;
1485	XF86VideoAdaptorPtr adapt;	1541	XF86VideoAdaptorPtr adapt;
		1542	//2006021912
		1543	unsigned i;
1486		1544
1487	if(!(adapt = RADEONAllocAdaptor(pScrn)))	1545	//2006021912
		1546	// if(!(adapt = RADEONAllocAdaptor(pScrn)))
		1547	if(!(adapt = RADEONAllocAdaptor(pScrn, VIP)))
1488	return NULL;	1548	return NULL;
1489		1549
1490	adapt->type = XvWindowMask \| XvInputMask \| XvImageMask;	1550	adapt->type = XvWindowMask \| XvInputMask \| XvImageMask;
Lines 1510-1515 Link Here
1510	adapt->PutImage = RADEONPutImage;	1570	adapt->PutImage = RADEONPutImage;
1511	adapt->QueryImageAttributes = RADEONQueryImageAttributes;	1571	adapt->QueryImageAttributes = RADEONQueryImageAttributes;
1512		1572
		1573	//2006021921
		1574	/*
		1575	* fulivi: set limits of theater_out attributes
		1576	*/
		1577	for (i = 0; i < N_TVO_ATTRS; i++)
		1578	{
		1579	int maxValue;
		1580	int minValue;
		1581	unsigned j;
		1582
		1583	RADEONTheaterOutGetAttrLimits(pScrn , theaterOutAttrs[ i ].attr , &maxValue , &minValue);
		1584
		1585	for (j = 0; i < NUM_DEC_ATTRIBUTES; j++)
		1586	if (strcmp(theaterOutAttrs[ i ].name , Attributes[ j ].name) == 0)
		1587	{
		1588	Attributes[ j ].min_value = minValue;
		1589	Attributes[ j ].max_value = maxValue;
		1590	break;
		1591	}
		1592	}
		1593
1513	pPriv = (RADEONPortPrivPtr)(adapt->pPortPrivates[0].ptr);	1594	pPriv = (RADEONPortPrivPtr)(adapt->pPortPrivates[0].ptr);
1514	REGION_NULL(pScreen, &(pPriv->clip));	1595	REGION_NULL(pScreen, &(pPriv->clip));
1515		1596
Lines 1812-1819 Link Here
1812	RADEON_TDA9885_SetEncoding(pPriv);	1893	RADEON_TDA9885_SetEncoding(pPriv);
1813	}	1894	}
1814	}	1895	}
1815	else	1896	//2006021922
1816	return BadMatch;	1897	// else
		1898	// return BadMatch;
		1899	else if (attribute == xvTvoStandard)
		1900	{
		1901	value = ClipValue(value , 0 , TV_STD_N_STANDARDS-1);
		1902	RADEONTheaterOutSetStandard(pScrn , (TVStd)value);
		1903	}
		1904	else
		1905	{
		1906	unsigned i;
		1907
		1908	for (i = 0; i < N_TVO_ATTRS; i++)
		1909	if (theaterOutAttrs[ i ].atom == attribute)
		1910	{
		1911	RADEONTheaterOutSetAttr(pScrn , theaterOutAttrs[ i ].attr , value);
		1912	break;
		1913	}
		1914	if (i == N_TVO_ATTRS)
		1915	return BadMatch;
		1916	}
1817		1917
1818	if (setTransform)	1918	if (setTransform)
1819	{	1919	{
Lines 1917-1924 Link Here
1917	*value = pPriv->instance_id;	2017	*value = pPriv->instance_id;
1918	else if(attribute == xvAdjustment)	2018	else if(attribute == xvAdjustment)
1919	*value = pPriv->adjustment;	2019	*value = pPriv->adjustment;
1920	else	2020	else if(attribute == xvTvoStandard) // 2006021923
1921	return BadMatch;	2021	*value = (INT32)RADEONTheaterOutGetStandard(pScrn);
		2022	else if(attribute == xvTvoModeCompat)
		2023	*value = (INT32)RADEONTheaterOutGetCompatMode(pScrn);
		2024	else {
		2025	unsigned i;
		2026
		2027	for (i = 0; i < N_TVO_ATTRS; i++) {
		2028	if (theaterOutAttrs[ i ].atom == attribute) {
		2029	*value = (INT32)RADEONTheaterOutGetAttr(pScrn , theaterOutAttrs[ i].attr);
		2030	break;
		2031	}
		2032	}
		2033	if (i == N_TVO_ATTRS)
		2034	return BadMatch;
		2035	}
		2036
		2037	//2006021923
		2038	// else
		2039	// return BadMatch;
1922		2040
1923	return Success;	2041	return Success;
1924	}	2042	}

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	}




/*********************************************************************
 *
 * $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 81-86 Link Here

(-)src/Makefile.in.orig (-5 / +74 lines)
81	am__installdirs = "$(DESTDIR)$(ati_drv_ladir)" \	81	am__installdirs = "$(DESTDIR)$(ati_drv_ladir)" \
82	"$(DESTDIR)$(atimisc_drv_ladir)" "$(DESTDIR)$(r128_drv_ladir)" \	82	"$(DESTDIR)$(atimisc_drv_ladir)" "$(DESTDIR)$(r128_drv_ladir)" \
83	"$(DESTDIR)$(radeon_drv_ladir)" \	83	"$(DESTDIR)$(radeon_drv_ladir)" \
		84	"$(DESTDIR)$(theater_out_drv_ladir)" \
84	"$(DESTDIR)$(theatre200_drv_ladir)" \	85	"$(DESTDIR)$(theatre200_drv_ladir)" \
85	"$(DESTDIR)$(theatre_detect_drv_ladir)" \	86	"$(DESTDIR)$(theatre_detect_drv_ladir)" \
86	"$(DESTDIR)$(theatre_drv_ladir)"	87	"$(DESTDIR)$(theatre_drv_ladir)"
Lines 88-98 Link Here
88	atimisc_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	89	atimisc_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
89	r128_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	90	r128_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
90	radeon_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	91	radeon_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
		92	theater_out_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
91	theatre200_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	93	theatre200_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
92	theatre_detect_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	94	theatre_detect_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
93	theatre_drv_laLTLIBRARIES_INSTALL = $(INSTALL)	95	theatre_drv_laLTLIBRARIES_INSTALL = $(INSTALL)
94	LTLIBRARIES = $(ati_drv_la_LTLIBRARIES) $(atimisc_drv_la_LTLIBRARIES) \	96	LTLIBRARIES = $(ati_drv_la_LTLIBRARIES) $(atimisc_drv_la_LTLIBRARIES) \
95	$(r128_drv_la_LTLIBRARIES) $(radeon_drv_la_LTLIBRARIES) \	97	$(r128_drv_la_LTLIBRARIES) $(radeon_drv_la_LTLIBRARIES) \
		98	$(theater_out_drv_la_LTLIBRARIES) \
96	$(theatre200_drv_la_LTLIBRARIES) \	99	$(theatre200_drv_la_LTLIBRARIES) \
97	$(theatre_detect_drv_la_LTLIBRARIES) \	100	$(theatre_detect_drv_la_LTLIBRARIES) \
98	$(theatre_drv_la_LTLIBRARIES)	101	$(theatre_drv_la_LTLIBRARIES)
Lines 148-153 Link Here
148	radeon_video.lo radeon_bios.lo radeon_mm_i2c.lo radeon_vip.lo \	151	radeon_video.lo radeon_bios.lo radeon_mm_i2c.lo radeon_vip.lo \
149	radeon_misc.lo $(am__objects_7) $(am__objects_8)	152	radeon_misc.lo $(am__objects_7) $(am__objects_8)
150	radeon_drv_la_OBJECTS = $(am_radeon_drv_la_OBJECTS)	153	radeon_drv_la_OBJECTS = $(am_radeon_drv_la_OBJECTS)
		154	theatre_out_drv_la_LIBADD =
		155	am_theater_out_drv_la_OBJECTS = theater_out_drv_la-theater_out.lo \
		156	theater_out_drv_la-theater_out_module.lo
		157	theater_out_drv_la_OBJECTS = $(am_theater_out_drv_la_OBJECTS)
151	theatre200_drv_la_LIBADD =	158	theatre200_drv_la_LIBADD =
152	am_theatre200_drv_la_OBJECTS = theatre200_drv_la-theatre200.lo \	159	am_theatre200_drv_la_OBJECTS = theatre200_drv_la-theatre200.lo \
153	theatre200_drv_la-theatre200_module.lo	160	theatre200_drv_la-theatre200_module.lo
Lines 172-184 Link Here
172	$(AM_LDFLAGS) $(LDFLAGS) -o $@	179	$(AM_LDFLAGS) $(LDFLAGS) -o $@
173	SOURCES = $(ati_drv_la_SOURCES) $(atimisc_drv_la_SOURCES) \	180	SOURCES = $(ati_drv_la_SOURCES) $(atimisc_drv_la_SOURCES) \
174	$(r128_drv_la_SOURCES) $(radeon_drv_la_SOURCES) \	181	$(r128_drv_la_SOURCES) $(radeon_drv_la_SOURCES) \
175	$(theatre200_drv_la_SOURCES) $(theatre_detect_drv_la_SOURCES) \	182	$(theater_out_drv_la_SOURCES) $(theatre200_drv_la_SOURES) \
176	$(theatre_drv_la_SOURCES)	183	$(theatre_detect_drv_la_SOURCES) $(theatre_drv_la_SOURCES)
177	DIST_SOURCES = $(am__ati_drv_la_SOURCES_DIST) \	184	DIST_SOURCES = $(am__ati_drv_la_SOURCES_DIST) \
178	$(am__atimisc_drv_la_SOURCES_DIST) \	185	$(am__atimisc_drv_la_SOURCES_DIST) \
179	$(am__r128_drv_la_SOURCES_DIST) \	186	$(am__r128_drv_la_SOURCES_DIST) \
180	$(am__radeon_drv_la_SOURCES_DIST) $(theatre200_drv_la_SOURCES) \	187	$(am__radeon_drv_la_SOURCES_DIST) $(theater_out_drv_la_SOURCES) \
181	$(theatre_detect_drv_la_SOURCES) $(theatre_drv_la_SOURCES)	188	$(theatre200_drv_la_SOURCES) $(theatre_detect_drv_la_SOURCES) \
		189	$(theatre_drv_la_SOURCES)
182	ETAGS = etags	190	ETAGS = etags
183	CTAGS = ctags	191	CTAGS = ctags
184	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)	192	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
Lines 379-384 Link Here
379	theatre_drv_la_SOURCES = \	387	theatre_drv_la_SOURCES = \
380	theatre.c theatre_module.c	388	theatre.c theatre_module.c
381		389
		390	theater_out_drv_la_LTLIBRARIES = theater_out_drv.la
		391	theater_out_drv_la_LDFLAGS = -module -avoid-version
		392	theater_out_drv_ladir = @moduledir@/multimedia
		393	theater_out_drv_la_CFLAGS = \
		394	$(AM_CFLAGS) -DMICROC_DIR=\"$(theater_out_drv_ladir)\"
		395
		396	theater_out_drv_la_SOURCES = \
		397	theater_out.c theater_out_module.c
		398
382	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la	399	theatre200_drv_la_LTLIBRARIES = theatre200_drv.la
383	theatre200_drv_la_LDFLAGS = -module -avoid-version	400	theatre200_drv_la_LDFLAGS = -module -avoid-version
384	theatre200_drv_ladir = @moduledir@/multimedia	401	theatre200_drv_ladir = @moduledir@/multimedia
Lines 474-479 Link Here
474	radeon_sarea.h \	491	radeon_sarea.h \
475	radeon_version.h \	492	radeon_version.h \
476	radeon_video.h \	493	radeon_video.h \
		494	theater_out.h \
477	theatre200.h \	495	theatre200.h \
478	theatre_detect.h \	496	theatre_detect.h \
479	theatre.h \	497	theatre.h \
Lines 621-626 Link Here
621	echo "rm -f \"$${dir}/so_locations\""; \	639	echo "rm -f \"$${dir}/so_locations\""; \
622	rm -f "$${dir}/so_locations"; \	640	rm -f "$${dir}/so_locations"; \
623	done	641	done
		642	install-theater_out_drv_laLTLIBRARIES: $(theater_out_drv_la_LTLIBRARIES)
		643	@$(NORMAL_INSTALL)
		644	test -z "$(theater_out_drv_ladir)" \|\| $(mkdir_p) "$(DESTDIR)$(theater_out_drv_ladir)"
		645	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		646	if test -f $$p; then \
		647	f=$(am__strip_dir) \
		648	echo " $(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(theater_out_drv_ladir)/$$f'"; \
		649	$(LIBTOOL) --mode=install $(theater_out_drv_laLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(theater_out_drv_ladir)/$$f"; \
		650	else :; fi; \
		651	done
		652
		653	uninstall-theater_out_drv_laLTLIBRARIES:
		654	@$(NORMAL_UNINSTALL)
		655	@set -x; list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		656	p=$(am__strip_dir) \
		657	echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(theater_out_drv_ladir)/$$p'"; \
		658	$(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(theater_out_drv_ladir)/$$p"; \
		659	done
		660
		661	clean-theater_out_drv_laLTLIBRARIES:
		662	-test -z "$(theater_out_drv_la_LTLIBRARIES)" \|\| rm -f $(theater_out_drv_la_LTLIBRARIES)
		663	@list='$(theater_out_drv_la_LTLIBRARIES)'; for p in $$list; do \
		664	dir="`echo $$p \| sed -e 's\|/[^/]*$$\|\|'`"; \
		665	test "$$dir" != "$$p" \|\| dir=.; \
		666	echo "rm -f \"$${dir}/so_locations\""; \
		667	rm -f "$${dir}/so_locations"; \
		668	done
624	install-theatre200_drv_laLTLIBRARIES: $(theatre200_drv_la_LTLIBRARIES)	669	install-theatre200_drv_laLTLIBRARIES: $(theatre200_drv_la_LTLIBRARIES)
625	@$(NORMAL_INSTALL)	670	@$(NORMAL_INSTALL)
626	test -z "$(theatre200_drv_ladir)" \|\| $(mkdir_p) "$(DESTDIR)$(theatre200_drv_ladir)"	671	test -z "$(theatre200_drv_ladir)" \|\| $(mkdir_p) "$(DESTDIR)$(theatre200_drv_ladir)"
Lines 710-715 Link Here
710	$(LINK) -rpath $(r128_drv_ladir) $(r128_drv_la_LDFLAGS) $(r128_drv_la_OBJECTS) $(r128_drv_la_LIBADD) $(LIBS)	755	$(LINK) -rpath $(r128_drv_ladir) $(r128_drv_la_LDFLAGS) $(r128_drv_la_OBJECTS) $(r128_drv_la_LIBADD) $(LIBS)
711	radeon_drv.la: $(radeon_drv_la_OBJECTS) $(radeon_drv_la_DEPENDENCIES)	756	radeon_drv.la: $(radeon_drv_la_OBJECTS) $(radeon_drv_la_DEPENDENCIES)
712	$(LINK) -rpath $(radeon_drv_ladir) $(radeon_drv_la_LDFLAGS) $(radeon_drv_la_OBJECTS) $(radeon_drv_la_LIBADD) $(LIBS)	757	$(LINK) -rpath $(radeon_drv_ladir) $(radeon_drv_la_LDFLAGS) $(radeon_drv_la_OBJECTS) $(radeon_drv_la_LIBADD) $(LIBS)
		758	theater_out_drv.la: $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_DEPENDENCIES)
		759	$(LINK) -rpath $(theater_out_drv_ladir) $(theater_out_drv_la_LDFLAGS) $(theater_out_drv_la_OBJECTS) $(theater_out_drv_la_LIBADD) $(LIBS)
713	theatre200_drv.la: $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_DEPENDENCIES)	760	theatre200_drv.la: $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_DEPENDENCIES)
714	$(LINK) -rpath $(theatre200_drv_ladir) $(theatre200_drv_la_LDFLAGS) $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_LIBADD) $(LIBS)	761	$(LINK) -rpath $(theatre200_drv_ladir) $(theatre200_drv_la_LDFLAGS) $(theatre200_drv_la_OBJECTS) $(theatre200_drv_la_LIBADD) $(LIBS)
715	theatre_detect_drv.la: $(theatre_detect_drv_la_OBJECTS) $(theatre_detect_drv_la_DEPENDENCIES)	762	theatre_detect_drv.la: $(theatre_detect_drv_la_OBJECTS) $(theatre_detect_drv_la_DEPENDENCIES)
Lines 791-796 Link Here
791	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_probe.Plo@am__quote@	838	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_probe.Plo@am__quote@
792	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_video.Plo@am__quote@	839	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_video.Plo@am__quote@
793	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_vip.Plo@am__quote@	840	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/radeon_vip.Plo@am__quote@
		841	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out.Plo@am__quote@
		842	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo@am__quote@
794	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre.Plo@am__quote@	843	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre.Plo@am__quote@
795	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200.Plo@am__quote@	844	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200.Plo@am__quote@
796	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo@am__quote@	845	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/theatre200_drv_la-theatre200_module.Plo@am__quote@
Lines 819-824 Link Here
819	@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@	868	@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
820	@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<	869	@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
821		870
		871	theater_out_drv_la-theater_out.lo: theater_out.c
		872	@am__fastdepCC_TRUE@ if $(LIBTOOL) --tag=CC --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" -c -o theater_out_drv_la-theater_out.lo `test -f 'theater_out.c' \|\| echo '$(srcdir)/'`theater_out.c; \
		873	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out.Plo"; else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out.Tpo"; exit 1; fi
		874	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out.c' object='theater_out_drv_la-theater_out.lo' libtool=yes @AMDEPBACKSLASH@
		875	@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		876	@am__fastdepCC_FALSE@ $(LIBTOOL) --tag=CC --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
		877
		878	theater_out_drv_la-theater_out_module.lo: theater_out_module.c
		879	@am__fastdepCC_TRUE@ if $(LIBTOOL) --tag=CC --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" -c -o theater_out_drv_la-theater_out_module.lo `test -f 'theater_out_module.c' \|\| echo '$(srcdir)/'`theater_out_module.c; \
		880	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo" "$(DEPDIR)/theater_out_drv_la-theater_out_module.Plo"; else rm -f "$(DEPDIR)/theater_out_drv_la-theater_out_module.Tpo"; exit 1; fi
		881	@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='theater_out_module.c' object='theater_out_drv_la-theater_out_module.lo' libtool=yes @AMDEPBACKSLASH@
		882	@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
		883	@am__fastdepCC_FALSE@ $(LIBTOOL) --tag=CC --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
		884
822	theatre200_drv_la-theatre200.lo: theatre200.c	885	theatre200_drv_la-theatre200.lo: theatre200.c
823	@am__fastdepCC_TRUE@ if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theatre200_drv_la_CFLAGS) $(CFLAGS) -MT theatre200_drv_la-theatre200.lo -MD -MP -MF "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" -c -o theatre200_drv_la-theatre200.lo `test -f 'theatre200.c' \|\| echo '$(srcdir)/'`theatre200.c; \	886	@am__fastdepCC_TRUE@ if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(theatre200_drv_la_CFLAGS) $(CFLAGS) -MT theatre200_drv_la-theatre200.lo -MD -MP -MF "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" -c -o theatre200_drv_la-theatre200.lo `test -f 'theatre200.c' \|\| echo '$(srcdir)/'`theatre200.c; \
824	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" "$(DEPDIR)/theatre200_drv_la-theatre200.Plo"; else rm -f "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo"; exit 1; fi	887	@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo" "$(DEPDIR)/theatre200_drv_la-theatre200.Plo"; else rm -f "$(DEPDIR)/theatre200_drv_la-theatre200.Tpo"; exit 1; fi
Lines 922-928 Link Here
922	check: check-am	985	check: check-am
923	all-am: Makefile $(LTLIBRARIES)	986	all-am: Makefile $(LTLIBRARIES)
924	installdirs:	987	installdirs:
925	for dir in "$(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)"; do \	988	for dir in "$(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)"; do \
926	test -z "$$dir" \|\| $(mkdir_p) "$$dir"; \	989	test -z "$$dir" \|\| $(mkdir_p) "$$dir"; \
927	done	990	done
928	install: install-am	991	install: install-am
Lines 954-959 Link Here
954	clean-am: clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \	1017	clean-am: clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
955	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \	1018	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
956	clean-radeon_drv_laLTLIBRARIES \	1019	clean-radeon_drv_laLTLIBRARIES \
		1020	clean-theater_out_drv_laLTLIBRARIES \
957	clean-theatre200_drv_laLTLIBRARIES \	1021	clean-theatre200_drv_laLTLIBRARIES \
958	clean-theatre_detect_drv_laLTLIBRARIES \	1022	clean-theatre_detect_drv_laLTLIBRARIES \
959	clean-theatre_drv_laLTLIBRARIES mostlyclean-am	1023	clean-theatre_drv_laLTLIBRARIES mostlyclean-am
Lines 978-983 Link Here
978	install-atimisc_drv_laLTLIBRARIES \	1042	install-atimisc_drv_laLTLIBRARIES \
979	install-r128_drv_laLTLIBRARIES \	1043	install-r128_drv_laLTLIBRARIES \
980	install-radeon_drv_laLTLIBRARIES \	1044	install-radeon_drv_laLTLIBRARIES \
		1045	install-theater_out_drv_laLTLIBRARIES \
981	install-theatre200_drv_laLTLIBRARIES \	1046	install-theatre200_drv_laLTLIBRARIES \
982	install-theatre_detect_drv_laLTLIBRARIES \	1047	install-theatre_detect_drv_laLTLIBRARIES \
983	install-theatre_drv_laLTLIBRARIES	1048	install-theatre_drv_laLTLIBRARIES
Lines 1012-1017 Link Here
1012	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \	1077	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
1013	uninstall-r128_drv_laLTLIBRARIES \	1078	uninstall-r128_drv_laLTLIBRARIES \
1014	uninstall-radeon_drv_laLTLIBRARIES \	1079	uninstall-radeon_drv_laLTLIBRARIES \
		1080	uninstall-theater_out_drv_laLTLIBRARIES \
1015	uninstall-theatre200_drv_laLTLIBRARIES \	1081	uninstall-theatre200_drv_laLTLIBRARIES \
1016	uninstall-theatre_detect_drv_laLTLIBRARIES \	1082	uninstall-theatre_detect_drv_laLTLIBRARIES \
1017	uninstall-theatre_drv_laLTLIBRARIES	1083	uninstall-theatre_drv_laLTLIBRARIES
Lines 1020-1025 Link Here
1020	clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \	1086	clean-ati_drv_laLTLIBRARIES clean-atimisc_drv_laLTLIBRARIES \
1021	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \	1087	clean-generic clean-libtool clean-r128_drv_laLTLIBRARIES \
1022	clean-radeon_drv_laLTLIBRARIES \	1088	clean-radeon_drv_laLTLIBRARIES \
		1089	clean-theater_out_drv_laLTLIBRARIES \
1023	clean-theatre200_drv_laLTLIBRARIES \	1090	clean-theatre200_drv_laLTLIBRARIES \
1024	clean-theatre_detect_drv_laLTLIBRARIES \	1091	clean-theatre_detect_drv_laLTLIBRARIES \
1025	clean-theatre_drv_laLTLIBRARIES ctags distclean \	1092	clean-theatre_drv_laLTLIBRARIES ctags distclean \
Lines 1030-1035 Link Here
1030	install-exec install-exec-am install-info install-info-am \	1097	install-exec install-exec-am install-info install-info-am \
1031	install-man install-r128_drv_laLTLIBRARIES \	1098	install-man install-r128_drv_laLTLIBRARIES \
1032	install-radeon_drv_laLTLIBRARIES install-strip \	1099	install-radeon_drv_laLTLIBRARIES install-strip \
		1100	install-theater_out_drv_laLTLIBRARIES \
1033	install-theatre200_drv_laLTLIBRARIES \	1101	install-theatre200_drv_laLTLIBRARIES \
1034	install-theatre_detect_drv_laLTLIBRARIES \	1102	install-theatre_detect_drv_laLTLIBRARIES \
1035	install-theatre_drv_laLTLIBRARIES installcheck installcheck-am \	1103	install-theatre_drv_laLTLIBRARIES installcheck installcheck-am \
Lines 1040-1045 Link Here
1040	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \	1108	uninstall-atimisc_drv_laLTLIBRARIES uninstall-info-am \
1041	uninstall-r128_drv_laLTLIBRARIES \	1109	uninstall-r128_drv_laLTLIBRARIES \
1042	uninstall-radeon_drv_laLTLIBRARIES \	1110	uninstall-radeon_drv_laLTLIBRARIES \
		1111	uninstall-theater_out_drv_laLTLIBRARIES \
1043	uninstall-theatre200_drv_laLTLIBRARIES \	1112	uninstall-theatre200_drv_laLTLIBRARIES \
1044	uninstall-theatre_detect_drv_laLTLIBRARIES \	1113	uninstall-theatre_detect_drv_laLTLIBRARIES \
1045	uninstall-theatre_drv_laLTLIBRARIES	1114	uninstall-theatre_drv_laLTLIBRARIES

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	}