diff options
Diffstat (limited to 'Source/DirectFB/gfxdrivers/ati128')
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/Makefile.am | 41 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/Makefile.in | 603 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/ati128.c | 842 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/ati128.h | 76 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/ati128_overlay.c | 447 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/ati128_state.c | 314 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/ati128_state.h | 62 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/mmio.h | 121 | ||||
| -rwxr-xr-x | Source/DirectFB/gfxdrivers/ati128/regs.h | 919 |
9 files changed, 3425 insertions, 0 deletions
diff --git a/Source/DirectFB/gfxdrivers/ati128/Makefile.am b/Source/DirectFB/gfxdrivers/ati128/Makefile.am new file mode 100755 index 0000000..aaa6b04 --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/Makefile.am @@ -0,0 +1,41 @@ +## Makefile.am for DirectFB/src/core/gfxcards/ati128 + +INCLUDES = \ + -I$(top_builddir)/include \ + -I$(top_srcdir)/include \ + -I$(top_builddir)/lib \ + -I$(top_srcdir)/lib \ + -I$(top_srcdir)/systems \ + -I$(top_srcdir)/src + + +ati128dir = $(MODULEDIR)/gfxdrivers + +ati128_LTLIBRARIES = libdirectfb_ati128.la + +if BUILD_STATIC +ati128_DATA = $(ati128_LTLIBRARIES:.la=.o) +endif + + +libdirectfb_ati128_la_SOURCES = \ + ati128.c \ + ati128.h \ + ati128_overlay.c \ + ati128_state.c \ + ati128_state.h \ + regs.h \ + mmio.h + +libdirectfb_ati128_la_LDFLAGS = \ + -module \ + -avoid-version \ + $(DFB_LDFLAGS) + +libdirectfb_ati128_la_LIBADD = \ + $(top_builddir)/lib/direct/libdirect.la \ + $(top_builddir)/src/libdirectfb.la + + +include $(top_srcdir)/rules/libobject.make + diff --git a/Source/DirectFB/gfxdrivers/ati128/Makefile.in b/Source/DirectFB/gfxdrivers/ati128/Makefile.in new file mode 100755 index 0000000..a1c01ee --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/Makefile.in @@ -0,0 +1,603 @@ +# Makefile.in generated by automake 1.10.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +target_triplet = @target@ +DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ + $(top_srcdir)/rules/libobject.make +subdir = gfxdrivers/ati128 +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/as-ac-expand.m4 \ + $(top_srcdir)/configure.in +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = `echo $$p | sed -e 's|^.*/||'`; +am__installdirs = "$(DESTDIR)$(ati128dir)" "$(DESTDIR)$(ati128dir)" +ati128LTLIBRARIES_INSTALL = $(INSTALL) +LTLIBRARIES = $(ati128_LTLIBRARIES) +libdirectfb_ati128_la_DEPENDENCIES = \ + $(top_builddir)/lib/direct/libdirect.la \ + $(top_builddir)/src/libdirectfb.la +am_libdirectfb_ati128_la_OBJECTS = ati128.lo ati128_overlay.lo \ + ati128_state.lo +libdirectfb_ati128_la_OBJECTS = $(am_libdirectfb_ati128_la_OBJECTS) +libdirectfb_ati128_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(libdirectfb_ati128_la_LDFLAGS) $(LDFLAGS) -o $@ +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +CCLD = $(CC) +LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ +SOURCES = $(libdirectfb_ati128_la_SOURCES) +DIST_SOURCES = $(libdirectfb_ati128_la_SOURCES) +ati128DATA_INSTALL = $(INSTALL_DATA) +DATA = $(ati128_DATA) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AR = @AR@ +AS = @AS@ +ASFLAGS = @ASFLAGS@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCAS = @CCAS@ +CCASDEPMODE = @CCASDEPMODE@ +CCASFLAGS = @CCASFLAGS@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DATADIR = @DATADIR@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DFB_CFLAGS_OMIT_FRAME_POINTER = @DFB_CFLAGS_OMIT_FRAME_POINTER@ +DFB_INTERNAL_CFLAGS = @DFB_INTERNAL_CFLAGS@ +DFB_LDFLAGS = @DFB_LDFLAGS@ +DFB_SMOOTH_SCALING = @DFB_SMOOTH_SCALING@ +DIRECTFB_BINARY_AGE = @DIRECTFB_BINARY_AGE@ +DIRECTFB_CSOURCE = @DIRECTFB_CSOURCE@ +DIRECTFB_INTERFACE_AGE = @DIRECTFB_INTERFACE_AGE@ +DIRECTFB_MAJOR_VERSION = @DIRECTFB_MAJOR_VERSION@ +DIRECTFB_MICRO_VERSION = @DIRECTFB_MICRO_VERSION@ +DIRECTFB_MINOR_VERSION = @DIRECTFB_MINOR_VERSION@ +DIRECTFB_VERSION = @DIRECTFB_VERSION@ +DIRECT_BUILD_DEBUG = @DIRECT_BUILD_DEBUG@ +DIRECT_BUILD_DEBUGS = @DIRECT_BUILD_DEBUGS@ +DIRECT_BUILD_GETTID = @DIRECT_BUILD_GETTID@ +DIRECT_BUILD_NETWORK = @DIRECT_BUILD_NETWORK@ +DIRECT_BUILD_STDBOOL = @DIRECT_BUILD_STDBOOL@ +DIRECT_BUILD_TEXT = @DIRECT_BUILD_TEXT@ +DIRECT_BUILD_TRACE = @DIRECT_BUILD_TRACE@ +DSYMUTIL = @DSYMUTIL@ +DYNLIB = @DYNLIB@ +ECHO = @ECHO@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +F77 = @F77@ +FFLAGS = @FFLAGS@ +FREETYPE_CFLAGS = @FREETYPE_CFLAGS@ +FREETYPE_LIBS = @FREETYPE_LIBS@ +FREETYPE_PROVIDER = @FREETYPE_PROVIDER@ +FUSION_BUILD_KERNEL = @FUSION_BUILD_KERNEL@ +FUSION_BUILD_MULTI = @FUSION_BUILD_MULTI@ +FUSION_MESSAGE_SIZE = @FUSION_MESSAGE_SIZE@ +GIF_PROVIDER = @GIF_PROVIDER@ +GREP = @GREP@ +HAVE_LINUX = @HAVE_LINUX@ +INCLUDEDIR = @INCLUDEDIR@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +INTERNALINCLUDEDIR = @INTERNALINCLUDEDIR@ +JPEG_PROVIDER = @JPEG_PROVIDER@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBJPEG = @LIBJPEG@ +LIBOBJS = @LIBOBJS@ +LIBPNG = @LIBPNG@ +LIBPNG_CONFIG = @LIBPNG_CONFIG@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +LT_AGE = @LT_AGE@ +LT_BINARY = @LT_BINARY@ +LT_CURRENT = @LT_CURRENT@ +LT_RELEASE = @LT_RELEASE@ +LT_REVISION = @LT_REVISION@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +MAN2HTML = @MAN2HTML@ +MKDIR_P = @MKDIR_P@ +MODULEDIR = @MODULEDIR@ +MODULEDIRNAME = @MODULEDIRNAME@ +NMEDIT = @NMEDIT@ +OBJEXT = @OBJEXT@ +OSX_LIBS = @OSX_LIBS@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PKG_CONFIG = @PKG_CONFIG@ +PNG_PROVIDER = @PNG_PROVIDER@ +RANLIB = @RANLIB@ +RUNTIME_SYSROOT = @RUNTIME_SYSROOT@ +SDL_CFLAGS = @SDL_CFLAGS@ +SDL_LIBS = @SDL_LIBS@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +SOPATH = @SOPATH@ +STRIP = @STRIP@ +SYSCONFDIR = @SYSCONFDIR@ +SYSFS_LIBS = @SYSFS_LIBS@ +THREADFLAGS = @THREADFLAGS@ +THREADLIB = @THREADLIB@ +TSLIB_CFLAGS = @TSLIB_CFLAGS@ +TSLIB_LIBS = @TSLIB_LIBS@ +VERSION = @VERSION@ +VNC_CFLAGS = @VNC_CFLAGS@ +VNC_CONFIG = @VNC_CONFIG@ +VNC_LIBS = @VNC_LIBS@ +X11_CFLAGS = @X11_CFLAGS@ +X11_LIBS = @X11_LIBS@ +ZLIB_LIBS = @ZLIB_LIBS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_F77 = @ac_ct_F77@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target = @target@ +target_alias = @target_alias@ +target_cpu = @target_cpu@ +target_os = @target_os@ +target_vendor = @target_vendor@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +INCLUDES = \ + -I$(top_builddir)/include \ + -I$(top_srcdir)/include \ + -I$(top_builddir)/lib \ + -I$(top_srcdir)/lib \ + -I$(top_srcdir)/systems \ + -I$(top_srcdir)/src + +ati128dir = $(MODULEDIR)/gfxdrivers +ati128_LTLIBRARIES = libdirectfb_ati128.la +@BUILD_STATIC_TRUE@ati128_DATA = $(ati128_LTLIBRARIES:.la=.o) +libdirectfb_ati128_la_SOURCES = \ + ati128.c \ + ati128.h \ + ati128_overlay.c \ + ati128_state.c \ + ati128_state.h \ + regs.h \ + mmio.h + +libdirectfb_ati128_la_LDFLAGS = \ + -module \ + -avoid-version \ + $(DFB_LDFLAGS) + +libdirectfb_ati128_la_LIBADD = \ + $(top_builddir)/lib/direct/libdirect.la \ + $(top_builddir)/src/libdirectfb.la + +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .lo .o .obj +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(top_srcdir)/rules/libobject.make $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu gfxdrivers/ati128/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu gfxdrivers/ati128/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +install-ati128LTLIBRARIES: $(ati128_LTLIBRARIES) + @$(NORMAL_INSTALL) + test -z "$(ati128dir)" || $(MKDIR_P) "$(DESTDIR)$(ati128dir)" + @list='$(ati128_LTLIBRARIES)'; for p in $$list; do \ + if test -f $$p; then \ + f=$(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(ati128LTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(ati128dir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(ati128LTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(ati128dir)/$$f"; \ + else :; fi; \ + done + +uninstall-ati128LTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(ati128_LTLIBRARIES)'; for p in $$list; do \ + p=$(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(ati128dir)/$$p'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(ati128dir)/$$p"; \ + done + +clean-ati128LTLIBRARIES: + -test -z "$(ati128_LTLIBRARIES)" || rm -f $(ati128_LTLIBRARIES) + @list='$(ati128_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 +libdirectfb_ati128.la: $(libdirectfb_ati128_la_OBJECTS) $(libdirectfb_ati128_la_DEPENDENCIES) + $(libdirectfb_ati128_la_LINK) -rpath $(ati128dir) $(libdirectfb_ati128_la_OBJECTS) $(libdirectfb_ati128_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ati128.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ati128_overlay.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ati128_state.Plo@am__quote@ + +.c.o: +@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c $< + +.c.obj: +@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'` + +.c.lo: +@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs +install-ati128DATA: $(ati128_DATA) + @$(NORMAL_INSTALL) + test -z "$(ati128dir)" || $(MKDIR_P) "$(DESTDIR)$(ati128dir)" + @list='$(ati128_DATA)'; for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + f=$(am__strip_dir) \ + echo " $(ati128DATA_INSTALL) '$$d$$p' '$(DESTDIR)$(ati128dir)/$$f'"; \ + $(ati128DATA_INSTALL) "$$d$$p" "$(DESTDIR)$(ati128dir)/$$f"; \ + done + +uninstall-ati128DATA: + @$(NORMAL_UNINSTALL) + @list='$(ati128_DATA)'; for p in $$list; do \ + f=$(am__strip_dir) \ + echo " rm -f '$(DESTDIR)$(ati128dir)/$$f'"; \ + rm -f "$(DESTDIR)$(ati128dir)/$$f"; \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonemtpy = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$tags$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(DATA) +installdirs: + for dir in "$(DESTDIR)$(ati128dir)" "$(DESTDIR)$(ati128dir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-ati128LTLIBRARIES clean-generic clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +info: info-am + +info-am: + +install-data-am: install-ati128DATA install-ati128LTLIBRARIES + +install-dvi: install-dvi-am + +install-exec-am: + +install-html: install-html-am + +install-info: install-info-am + +install-man: + +install-pdf: install-pdf-am + +install-ps: install-ps-am + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-ati128DATA uninstall-ati128LTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean \ + clean-ati128LTLIBRARIES clean-generic clean-libtool ctags \ + distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-ati128DATA \ + install-ati128LTLIBRARIES install-data install-data-am \ + install-dvi install-dvi-am install-exec install-exec-am \ + install-html install-html-am install-info install-info-am \ + install-man install-pdf install-pdf-am install-ps \ + install-ps-am install-strip installcheck installcheck-am \ + installdirs maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \ + uninstall-am uninstall-ati128DATA uninstall-ati128LTLIBRARIES + +%.o: .libs/%.a %.la + rm -f $<.tmp/*.o + if test -d $<.tmp; then rmdir $<.tmp; fi + mkdir $<.tmp + (cd $<.tmp && $(AR) x ../../$<) + $(LD) -o $@ -r $<.tmp/*.o + rm -f $<.tmp/*.o && rmdir $<.tmp + +.PHONY: $(LTLIBRARIES:%.la=.libs/%.a) +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/Source/DirectFB/gfxdrivers/ati128/ati128.c b/Source/DirectFB/gfxdrivers/ati128/ati128.c new file mode 100755 index 0000000..4ae34c6 --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/ati128.c @@ -0,0 +1,842 @@ +/* + (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org) + (c) Copyright 2000-2004 Convergence (integrated media) GmbH + + All rights reserved. + + Written by Denis Oliver Kropp <dok@directfb.org>, + Andreas Hundt <andi@fischlustig.de>, + Sven Neumann <neo@directfb.org>, + Ville Syrjälä <syrjala@sci.fi> and + Claudio Ciccani <klan@users.sf.net>. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <config.h> + +#include <dfb_types.h> + +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> + +#include <sys/mman.h> +#include <fcntl.h> +#include <sys/ioctl.h> + +#include <fbdev/fb.h> + +#include <directfb.h> + +#include <direct/messages.h> + +#include <core/coredefs.h> +#include <core/coretypes.h> + +#include <core/screens.h> +#include <core/state.h> +#include <core/gfxcard.h> +#include <core/surface.h> + +#include <gfx/convert.h> + +#include <core/graphics_driver.h> + + +DFB_GRAPHICS_DRIVER( ati128 ) + + +#include "regs.h" +#include "mmio.h" +#include "ati128_state.h" +#include "ati128.h" + + +/* driver capability flags */ + + +#ifndef __powerpc__ +#define ATI128_SUPPORTED_DRAWINGFLAGS \ + (DSDRAW_BLEND) +#else +#define ATI128_SUPPORTED_DRAWINGFLAGS \ + (DSDRAW_NOFX) +#endif + +#define ATI128_SUPPORTED_DRAWINGFUNCTIONS \ + (DFXL_FILLRECTANGLE | DFXL_DRAWRECTANGLE | DFXL_DRAWLINE) + +#define ATI128_SUPPORTED_BLITTINGFLAGS \ + (DSBLIT_SRC_COLORKEY | DSBLIT_BLEND_ALPHACHANNEL) + +#define ATI128_SUPPORTED_BLITTINGFUNCTIONS \ + (DFXL_BLIT | DFXL_STRETCHBLIT) + + +/* macro for S12.0 and S14.0 format */ +#define S12(val) (((u16)((s16)(val)))&0x3fff) +#define S14(val) (((u16)((s16)(val)))&0x3fff) + +/** CARD FUNCTIONS **/ +static bool ati128FillRectangle( void *drv, void *dev, DFBRectangle *rect ); +static bool ati128FillBlendRectangle( void *drv, void *dev, DFBRectangle *rect ); +static bool ati128DrawRectangle( void *drv, void *dev, DFBRectangle *rect ); +static bool ati128DrawBlendRectangle( void *drv, void *dev, DFBRectangle *rect ); + +/* required implementations */ + +static DFBResult ati128EngineSync( void *drv, void *dev ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + + ati128_waitidle( adrv, adev ); + + return DFB_OK; +} + +static bool ati128_check_blend( CardState *state ) +{ + if (state->dst_blend == DSBF_SRCALPHASAT) + return false; + + return true; +} + +static void ati128CheckState( void *drv, void *dev, + CardState *state, DFBAccelerationMask accel ) +{ + switch (state->destination->config.format) { + case DSPF_RGB332: + case DSPF_ARGB1555: + case DSPF_RGB16: + case DSPF_RGB24: + case DSPF_RGB32: + case DSPF_ARGB: + break; + default: + return; + } + + /* check for the special drawing function that does not support + the usually supported drawingflags */ + if (accel == DFXL_DRAWLINE && state->drawingflags != DSDRAW_NOFX) + return; + + /* if there are no other drawing flags than the supported */ + if (!(accel & ~ATI128_SUPPORTED_DRAWINGFUNCTIONS) && + !(state->drawingflags & ~ATI128_SUPPORTED_DRAWINGFLAGS)) { + if (state->drawingflags & DSDRAW_BLEND && + !ati128_check_blend( state )) + return; + + state->accel |= ATI128_SUPPORTED_DRAWINGFUNCTIONS; + } + + /* if there are no other blitting flags than the supported + and the source has the minimum size */ + if (!(accel & ~ATI128_SUPPORTED_BLITTINGFUNCTIONS) && + !(state->blittingflags & ~ATI128_SUPPORTED_BLITTINGFLAGS) && + state->source && + state->source->config.size.w >= 8 && + state->source->config.size.h >= 8 ) + { + if (state->blittingflags & DSBLIT_BLEND_ALPHACHANNEL && + !ati128_check_blend( state )) + return; + + switch (state->source->config.format) { + case DSPF_RGB332: + case DSPF_ARGB1555: + case DSPF_RGB16: + case DSPF_RGB24: + case DSPF_RGB32: + case DSPF_ARGB: + state->accel |= ATI128_SUPPORTED_BLITTINGFUNCTIONS; + default: + ; + } + } +} + + +static void ati128SetState( void *drv, void *dev, + GraphicsDeviceFuncs *funcs, + CardState *state, DFBAccelerationMask accel ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + + if (state->mod_hw & SMF_SOURCE) + adev->v_source = 0; + + if (state->mod_hw & SMF_DESTINATION) + adev->v_destination = adev->v_color = 0; + + if (state->mod_hw & SMF_COLOR) + adev->v_color = 0; + + if (state->mod_hw & SMF_SRC_COLORKEY) + adev->v_src_colorkey = 0; + + if (state->mod_hw & SMF_BLITTING_FLAGS) + adev->v_blittingflags = 0; + + if (state->mod_hw & (SMF_SRC_BLEND | SMF_DST_BLEND)) + adev->v_blending_function = 0; + + ati128_set_destination( adrv, adev, state); + + switch (accel) { + case DFXL_FILLRECTANGLE: + case DFXL_DRAWRECTANGLE: + if (state->drawingflags & DSDRAW_BLEND) { + ati128_set_blending_function( adrv, adev, state ); + funcs->FillRectangle = ati128FillBlendRectangle; + funcs->DrawRectangle = ati128DrawBlendRectangle; + } + else { + funcs->FillRectangle = ati128FillRectangle; + funcs->DrawRectangle = ati128DrawRectangle; + } + case DFXL_DRAWLINE: + ati128_set_color( adrv, adev, state ); + state->set |= DFXL_FILLRECTANGLE | DFXL_DRAWLINE | DFXL_DRAWRECTANGLE ; + break; + + case DFXL_BLIT: + case DFXL_STRETCHBLIT: + ati128_set_source( adrv, adev, state ); + if (state->blittingflags & DSBLIT_BLEND_ALPHACHANNEL) + ati128_set_blending_function( adrv, adev, state ); + if (state->blittingflags & DSBLIT_SRC_COLORKEY) + ati128_set_src_colorkey( adrv, adev, state ); + ati128_set_blittingflags( adrv, adev, state ); + state->set |= DFXL_BLIT | DFXL_STRETCHBLIT; + break; + + default: + D_BUG( "unexpected drawing/blitting function" ); + break; + } + + if (state->mod_hw & SMF_CLIP) + ati128_set_clip( adrv, adev, state); + + state->mod_hw = 0; +} + +static bool ati128FillRectangle( void *drv, void *dev, DFBRectangle *rect ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + volatile u8 *mmio = adrv->mmio_base; + + ati128_waitfifo( adrv, adev, 5 ); + /* set the destination datatype */ + ati128_out32( mmio, DP_DATATYPE, adev->ATI_dst_bpp | BRUSH_SOLIDCOLOR ); + /* set direction */ + ati128_out32( mmio, DP_CNTL, DST_X_LEFT_TO_RIGHT | DST_Y_TOP_TO_BOTTOM); + /* set the drawing command */ + ati128_out32( mmio, DP_MIX, ROP3_PATCOPY | DP_SRC_RECT ); + /* set parameters */ + ati128_out32( mmio, DST_Y_X, (S14(rect->y) << 16) | S12(rect->x) ); + /* this executes the drawing command */ + ati128_out32( mmio, DST_HEIGHT_WIDTH, (rect->h << 16) | rect->w ); + + return true; +} + +static bool ati128FillBlendRectangle( void *drv, void *dev, DFBRectangle *rect ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + volatile u8 *mmio = adrv->mmio_base; + + u32 fts = adev->ATI_fake_texture_src + (adev->fake_texture_number & 7)*4; + ati128_waitidle( adrv, adev ); + *((u32*) dfb_gfxcard_memory_virtual(NULL,fts) ) = adev->fake_texture_color; + ati128_waitidle( adrv, adev ); + + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_32BPP ); + ati128_out32( mmio, SCALE_PITCH, 1 ); + /* enable scaling with filtering */ + ati128_out32( mmio, SCALE_3D_CNTL, adev->ATI_blend_function ); + ati128_out32( mmio, DP_DATATYPE, adev->ATI_dst_bpp | SRC_DSTCOLOR ); + ati128_out32( mmio, DP_MIX, ROP3_SRCCOPY | DP_SRC_RECT ); + /* flush the texture cache */ + ati128_out32( mmio, TEX_CNTL, TEX_CNTL_ALPHA_EN_ON | TEX_CNTL_TEX_CACHE_FLUSH_ON); + /* set source offset */ + ati128_out32( mmio, SCALE_OFFSET_0, fts ) ; + /* set height and width of the source */ + ati128_out32( mmio, SCALE_SRC_HEIGHT_WIDTH, (8 << 16) | 8); + /* set the scaling increment registers */ + ati128_out32( mmio, SCALE_X_INC, 0 ); + ati128_out32( mmio, SCALE_Y_INC, 0 ); + /* reset accumulator regs */ + ati128_out32( mmio, SCALE_HACC, 0x00000000 ); + ati128_out32( mmio, SCALE_VACC, 0x00000000 ); + /* set the destination coordinates */ + ati128_out32( mmio, SCALE_DST_X_Y, (S12(rect->x) << 16) | S14(rect->y) ); + /* set destination height and width and perform the blit */ + ati128_out32( mmio, SCALE_DST_HEIGHT_WIDTH, (rect->h << 16) | rect->w ); + /*reset scaling and texture control register */ + ati128_out32( mmio, SCALE_3D_CNTL, 0x00000000 ); + ati128_out32( mmio, TEX_CNTL, 0); + adev->fake_texture_number++; + + return true; +} + +static bool ati128DrawRectangle( void *drv, void *dev, DFBRectangle *rect ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + volatile u8 *mmio = adrv->mmio_base; + + ati128_waitfifo( adrv, adev, 3 ); + /* set the destination datatype */ + ati128_out32( mmio, DP_DATATYPE, adev->ATI_dst_bpp | BRUSH_SOLIDCOLOR ); + /* set direction */ + ati128_out32( mmio, DP_CNTL, DST_X_LEFT_TO_RIGHT | DST_Y_TOP_TO_BOTTOM); + /* set the drawing command */ + ati128_out32( mmio, DP_MIX, ROP3_PATCOPY | DP_SRC_RECT ); + + ati128_waitfifo( adrv, adev, 7 ); + /* first line */ + ati128_out32( mmio, DST_Y_X, (S14(rect->y) << 16) | S12(rect->x)); + ati128_out32( mmio, DST_HEIGHT_WIDTH, (rect->h << 16) | 1); + /* second line */ + ati128_out32( mmio, DST_HEIGHT_WIDTH, (1 << 16) | rect->w ); + /* third line */ + ati128_out32( mmio, DST_Y_X, (S14(rect->y+rect->h-1) << 16) | S12(rect->x)); + ati128_out32( mmio, DST_HEIGHT_WIDTH, (1 << 16) | rect->w ); + /* fourth line */ + ati128_out32( mmio, DST_Y_X, (S14(rect->y) << 16) | S12(rect->x+rect->w-1)); + ati128_out32( mmio, DST_HEIGHT_WIDTH, rect->h << 16 | 1); + + return true; +} + +static bool ati128DrawBlendRectangle( void *drv, void *dev, DFBRectangle *rect ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + volatile u8 *mmio = adrv->mmio_base; + + u32 fts = adev->ATI_fake_texture_src + (adev->fake_texture_number & 7)*4; + + ati128_waitidle( adrv, adev ); + *((u32*) dfb_gfxcard_memory_virtual(NULL,fts) ) = adev->fake_texture_color; + ati128_waitidle( adrv, adev ); + + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_32BPP ); + ati128_out32( mmio, SCALE_PITCH, 1 ); + + /* enable scaling with filtering */ + ati128_out32( mmio, SCALE_3D_CNTL, adev->ATI_blend_function ); + ati128_out32( mmio, TEX_CNTL, TEX_CNTL_ALPHA_EN_ON | TEX_CNTL_TEX_CACHE_FLUSH_ON); + ati128_out32( mmio, DP_DATATYPE, adev->ATI_dst_bpp | SRC_DSTCOLOR ); + ati128_out32( mmio, DP_MIX, ROP3_SRCCOPY | DP_SRC_RECT ); + /* set source offset */ + ati128_out32( mmio, SCALE_OFFSET_0, adev->ATI_fake_texture_src ); + /* set height and width of the source */ + ati128_out32( mmio, SCALE_SRC_HEIGHT_WIDTH, (8 << 16) | 8); + /* set the scaling increment registers */ + ati128_out32( mmio, SCALE_X_INC, 0 ); + ati128_out32( mmio, SCALE_Y_INC, 0 ); + /* reset accumulator regs */ + ati128_out32( mmio, SCALE_HACC, 0x00000000 ); + ati128_out32( mmio, SCALE_VACC, 0x00000000 ); + /* set the destination coordinates */ + + /*-----------------------*/ + /* first line */ + ati128_out32( mmio, SCALE_DST_X_Y, (S12(rect->x) << 16) | S14(rect->y) ); + ati128_out32( mmio, SCALE_DST_HEIGHT_WIDTH, (rect->h << 16) | 1); + /* second line */ + ati128_out32( mmio, SCALE_DST_HEIGHT_WIDTH, (1 << 16) | rect->w ); + /* third line */ + ati128_out32( mmio, SCALE_DST_X_Y, (S12(rect->x) << 16) | S14(rect->y+rect->h-1)); + ati128_out32( mmio, SCALE_DST_HEIGHT_WIDTH, (1 << 16) | rect->w ); + /* fourth line */ + ati128_out32( mmio, SCALE_DST_X_Y, (S12(rect->x+rect->w-1) << 16) | S14(rect->y)); + ati128_out32( mmio, SCALE_DST_HEIGHT_WIDTH, rect->h << 16 | 1); + /*-----------------------*/ + + /* reset scaling and texture control register */ + ati128_out32( mmio, SCALE_3D_CNTL, 0x00000000 ); + ati128_out32( mmio, TEX_CNTL, 0 ); + adev->fake_texture_number++; + + return true; +} + + +static bool ati128DrawLine( void *drv, void *dev, DFBRegion *line ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + volatile u8 *mmio = adrv->mmio_base; + + int dx, dy; + int small, large; + int x_dir, y_dir, y_major; + int err, inc, dec; + + /* Determine x & y deltas and x & y direction bits. */ + if (line->x1 < line->x2) { + dx = line->x2 - line->x1; + x_dir = 1 << 31; + } + else { + dx = line->x1 - line->x2; + x_dir = 0 << 31; + } + + if (line->y1 < line->y2) { + dy = line->y2 - line->y1; + y_dir = 1 << 15; + } + else { + dy = line->y1 - line->y2; + y_dir = 0 << 15; + } + + /* Determine x & y min and max values; also determine y major bit. */ + if (dx < dy) { + small = dx; + large = dy; + y_major = 1 << 2; + } + else { + small = dy; + large = dx; + y_major = 0 << 2; + } + + /* Calculate Bresenham parameters and draw line. */ + err = -large; + inc = small * 2; + dec = large *(-2); + + ati128_waitfifo( adrv, adev, 8 ); + /* set the destination datatype */ + ati128_out32( mmio, DP_DATATYPE, adev->ATI_dst_bpp | BRUSH_SOLIDCOLOR | ROP3_SRCCOPY ); + ati128_out32( mmio, DP_MIX, ROP3_PATCOPY ); + + /* set start coorinates */ + ati128_out32( mmio, DST_Y_X, (S14(line->y1) << 16) | S12(line->x1)); + /* allow setting of last pel bit and polygon + outline bit for line drawing */ + ati128_out32( mmio, DP_CNTL_XDIR_YDIR_YMAJOR, + y_major | y_dir | x_dir ); + /* set bresenham registers and start drawing */ + ati128_out32( mmio, DST_BRES_ERR, err ); + ati128_out32( mmio, DST_BRES_INC, inc ); + ati128_out32( mmio, DST_BRES_DEC, dec ); + ati128_out32( mmio, DST_BRES_LNTH, large + 1 ); + + return true; +} + +static bool ati128StretchBlit( void *drv, void *dev, DFBRectangle *sr, DFBRectangle *dr ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + volatile u8 *mmio = adrv->mmio_base; + + u32 src = 0; + + u32 scalex = (u32)(((double)sr->w/(double)dr->w) * 65536); + u32 scaley = (u32)(((double)sr->h/(double)dr->h) * 65536); + + ati128_waitfifo( adrv, adev, 9 ); + + /* make sure that color compare register is restored to last state */ + + ati128_out32( mmio, CLR_CMP_CNTL, adev->ATI_color_compare ); + + switch (adev->source->config.format) { + case DSPF_RGB332: + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_8BPP_RGB332 ); + + ati128_out32( mmio, SCALE_PITCH, + adev->src->pitch >>3); + + src = adev->src->offset + + sr->y * + adev->src->pitch + sr->x; + + ati128_out32( mmio, TEX_CNTL, 0); + + break; + case DSPF_ARGB1555: /* FIXME: alpha channel will be zero ;( */ + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_15BPP ); + + ati128_out32( mmio, SCALE_PITCH, + adev->src->pitch >>4); + + src = adev->src->offset + + sr->y * + adev->src->pitch + sr->x*2; + + ati128_out32( mmio, TEX_CNTL, 0); + + break; + case DSPF_RGB16: + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_16BPP ); + + ati128_out32( mmio, SCALE_PITCH, + adev->src->pitch >>4); + + src = adev->src->offset + + sr->y * + adev->src->pitch + sr->x*2; + + ati128_out32( mmio, TEX_CNTL, 0); + + break; + case DSPF_RGB24: + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_24BPP ); + + ati128_out32( mmio, SCALE_PITCH, + adev->src->pitch >>3); + + src = adev->src->offset + + sr->y * + adev->src->pitch + sr->x*3; + + ati128_out32( mmio, TEX_CNTL, 0); + + break; + case DSPF_RGB32: + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_32BPP ); + + ati128_out32( mmio, SCALE_PITCH, + adev->src->pitch >>5); + + src = adev->src->offset + + sr->y * + adev->src->pitch + sr->x*4; + + ati128_out32( mmio, TEX_CNTL, 0); + + break; + case DSPF_ARGB: + ati128_out32( mmio, SCALE_3D_DATATYPE, DST_32BPP ); + + ati128_out32( mmio, SCALE_PITCH, + adev->src->pitch >>5); + + src = adev->src->offset + + sr->y * + adev->src->pitch + sr->x*4; + + if (adev->blittingflags & DSBLIT_BLEND_ALPHACHANNEL) + ati128_out32( mmio, TEX_CNTL, TEX_CNTL_ALPHA_EN_ON ); + else + ati128_out32( mmio, TEX_CNTL, 0 ); + break; + default: + D_BUG( "unexpected pixelformat!" ); + return false; + } + + ati128_out32( mmio, DP_DATATYPE, adev->ATI_dst_bpp | SRC_DSTCOLOR ); + + /* set the blend function */ + if (adev->blittingflags & DSBLIT_BLEND_ALPHACHANNEL) + ati128_out32( mmio, SCALE_3D_CNTL, adev->ATI_blend_function ); + else + ati128_out32( mmio, SCALE_3D_CNTL, SCALE_3D_CNTL_SCALE_3D_FN_SCALE ); + + /* set up source data and copy type */ + ati128_out32( mmio, DP_MIX, ROP3_SRCCOPY | DP_SRC_RECT ); + /* set source offset */ + ati128_out32( mmio, SCALE_OFFSET_0, src); + /* set height and width of the source */ + ati128_out32( mmio, SCALE_SRC_HEIGHT_WIDTH, (sr->h << 16) | sr->w); + + ati128_waitfifo( adrv, adev, 9 ); + /* set the scaling increment registers */ + ati128_out32( mmio, SCALE_X_INC, scalex ); + ati128_out32( mmio, SCALE_Y_INC, scaley ); + /* reset accumulator regs */ + ati128_out32( mmio, SCALE_HACC, 0x00000000 ); + ati128_out32( mmio, SCALE_VACC, 0x00000000 ); + /* set the destination coordinates */ + ati128_out32( mmio, SCALE_DST_X_Y, (S12(dr->x) << 16) | S14(dr->y) ); + /* set destination height and width and perform the blit */ + ati128_out32( mmio, SCALE_DST_HEIGHT_WIDTH, (dr->h << 16) | dr->w ); + /*reset scaling and texture control register */ + ati128_out32( mmio, SCALE_3D_CNTL, 0x00000000 ); + ati128_out32( mmio, TEX_CNTL, 0x00000000 ); + + /* set CLR_CMP_CNTL to zero, to insure that drawing funcions work corrently */ + if (adev->ATI_color_compare) + ati128_out32( mmio, CLR_CMP_CNTL, 0 ); + + return true; +} + +static bool ati128Blit( void *drv, void *dev, DFBRectangle *rect, int dx, int dy ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) drv; + ATI128DeviceData *adev = (ATI128DeviceData*) dev; + volatile u8 *mmio = adrv->mmio_base; + + u32 dir_cmd = 0; + + if ((adev->source->config.format != adev->destination->config.format) || + (adev->blittingflags & DSBLIT_BLEND_ALPHACHANNEL)) + { + DFBRectangle sr = { rect->x, rect->y, rect->w, rect->h }; + DFBRectangle dr = { dx, dy, rect->w, rect->h }; + ati128StretchBlit( adrv, adev, &sr, &dr ); + return true; + } + + /* check which blitting direction should be used */ + if (rect->x <= dx) { + dir_cmd |= DST_X_RIGHT_TO_LEFT; + rect->x += rect->w-1; + dx += rect->w-1; + } + else { + dir_cmd |= DST_X_LEFT_TO_RIGHT; + } + if (rect->y <= dy) { + dir_cmd |= DST_Y_BOTTOM_TO_TOP; + rect->y += rect->h-1; + dy += rect->h-1; + } + else { + dir_cmd |= DST_Y_TOP_TO_BOTTOM; + } + + ati128_waitfifo( adrv, adev, 9 ); + + /* make sure that color compare register is restored to last state */ + ati128_out32( mmio, CLR_CMP_CNTL, adev->ATI_color_compare ); + + /* set blitting direction */ + ati128_out32( mmio, DP_CNTL, dir_cmd ); + + ati128_out32( mmio, DP_DATATYPE, adev->ATI_dst_bpp | SRC_DSTCOLOR ); + ati128_out32( mmio, DP_MIX, ROP3_SRCCOPY | DP_SRC_RECT ); + + ati128_out32( mmio, SRC_Y_X, (rect->y << 16) | rect->x); + ati128_out32( mmio, DST_Y_X, (S14(dy) << 16) | S12(dx) ); + ati128_out32( mmio, DST_HEIGHT_WIDTH, (rect->h << 16) | rect->w); + + /* set CLR_CMP_CNTL to zero, to insure that drawing funcions work corrently */ + if (adev->ATI_color_compare) + ati128_out32( mmio, CLR_CMP_CNTL, 0 ); + + if (dir_cmd != (DST_Y_TOP_TO_BOTTOM | DST_X_LEFT_TO_RIGHT)) { + ati128_out32( mmio, DP_CNTL, DST_X_LEFT_TO_RIGHT | + DST_Y_TOP_TO_BOTTOM ); + } + + return true; +} + +/* exported symbols */ + +static int +driver_probe( CoreGraphicsDevice *device ) +{ + switch (dfb_gfxcard_get_accelerator( device )) { + case FB_ACCEL_ATI_RAGE128: /* ATI Rage 128 */ + return 1; + } + + return 0; +} + + +static void +driver_get_info( CoreGraphicsDevice *device, + GraphicsDriverInfo *info ) +{ + /* fill driver info structure */ + snprintf( info->name, + DFB_GRAPHICS_DRIVER_INFO_NAME_LENGTH, + "ATI Rage 128 Driver" ); + + snprintf( info->vendor, + DFB_GRAPHICS_DRIVER_INFO_VENDOR_LENGTH, + "directfb.org" ); + + info->version.major = 0; + info->version.minor = 2; + + info->driver_data_size = sizeof (ATI128DriverData); + info->device_data_size = sizeof (ATI128DeviceData); +} + +static DFBResult +driver_init_driver( CoreGraphicsDevice *device, + GraphicsDeviceFuncs *funcs, + void *driver_data, + void *device_data, + CoreDFB *core ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + + adrv->mmio_base = (volatile u8*) dfb_gfxcard_map_mmio( device, 0, -1 ); + if (!adrv->mmio_base) + return DFB_IO; + + funcs->CheckState = ati128CheckState; + funcs->SetState = ati128SetState; + funcs->EngineSync = ati128EngineSync; + + funcs->FillRectangle = ati128FillRectangle; + funcs->DrawRectangle = ati128DrawRectangle; + funcs->DrawLine = ati128DrawLine; + funcs->Blit = ati128Blit; + funcs->StretchBlit = ati128StretchBlit; + + /* overlay support */ + dfb_layers_register( dfb_screens_at(DSCID_PRIMARY), + driver_data, &atiOverlayFuncs ); + + return DFB_OK; +} + + +static DFBResult +driver_init_device( CoreGraphicsDevice *device, + GraphicsDeviceInfo *device_info, + void *driver_data, + void *device_data ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + ATI128DeviceData *adev = (ATI128DeviceData*) device_data; + volatile u8 *mmio = adrv->mmio_base; + + /* fill device info */ + snprintf( device_info->name, + DFB_GRAPHICS_DEVICE_INFO_NAME_LENGTH, "Rage 128" ); + + snprintf( device_info->vendor, + DFB_GRAPHICS_DEVICE_INFO_VENDOR_LENGTH, "ATI" ); + + + device_info->caps.flags = CCF_CLIPPING; + device_info->caps.accel = ATI128_SUPPORTED_DRAWINGFUNCTIONS | + ATI128_SUPPORTED_BLITTINGFUNCTIONS; + device_info->caps.drawing = ATI128_SUPPORTED_DRAWINGFLAGS; + device_info->caps.blitting = ATI128_SUPPORTED_BLITTINGFLAGS; + + device_info->limits.surface_byteoffset_alignment = 32 * 4; + device_info->limits.surface_pixelpitch_alignment = 32; + + + /* initialize card */ + ati128_waitfifo( adrv, adev, 6 ); + + ati128_out32( mmio, DP_GUI_MASTER_CNTL, + GMC_SRC_PITCH_OFFSET_DEFAULT | + GMC_DST_PITCH_OFFSET_DEFAULT | + GMC_SRC_CLIP_DEFAULT | + GMC_DST_CLIP_DEFAULT | + GMC_BRUSH_SOLIDCOLOR | + GMC_SRC_DSTCOLOR | + GMC_BYTE_ORDER_MSB_TO_LSB | + GMC_DP_CONVERSION_TEMP_6500 | + ROP3_PATCOPY | + GMC_DP_SRC_RECT | + GMC_3D_FCN_EN_CLR | + GMC_DST_CLR_CMP_FCN_CLEAR | + GMC_AUX_CLIP_CLEAR | + GMC_WRITE_MASK_SET); + + ati128_out32( mmio, SCALE_3D_CNTL, 0x00000000 ); + ati128_out32( mmio, TEX_CNTL, 0x00000000 ); + + /* reserve 32bit pixel for fake texture at end of framebuffer */ + adev->ATI_fake_texture_src = dfb_gfxcard_reserve_memory( device, 4*32 ); + + return DFB_OK; +} + +static void +driver_close_device( CoreGraphicsDevice *device, + void *driver_data, + void *device_data ) +{ + ATI128DeviceData *adev = (ATI128DeviceData*) device_data; + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + volatile u8 *mmio = adrv->mmio_base; + + D_DEBUG( "DirectFB/ATI128: FIFO Performance Monitoring:\n" ); + D_DEBUG( "DirectFB/ATI128: %9d ati128_waitfifo calls\n", + adev->waitfifo_calls ); + D_DEBUG( "DirectFB/ATI128: %9d register writes (ati128_waitfifo sum)\n", + adev->waitfifo_sum ); + D_DEBUG( "DirectFB/ATI128: %9d FIFO wait cycles (depends on CPU)\n", + adev->fifo_waitcycles ); + D_DEBUG( "DirectFB/ATI128: %9d IDLE wait cycles (depends on CPU)\n", + adev->idle_waitcycles ); + D_DEBUG( "DirectFB/ATI128: %9d FIFO space cache hits(depends on CPU)\n", + adev->fifo_cache_hits ); + D_DEBUG( "DirectFB/ATI128: Conclusion:\n" ); + D_DEBUG( "DirectFB/ATI128: Average register writes/ati128_waitfifo" + "call:%.2f\n", + adev->waitfifo_sum/(float)(adev->waitfifo_calls) ); + D_DEBUG( "DirectFB/ATI128: Average wait cycles/ati128_waitfifo call:" + " %.2f\n", + adev->fifo_waitcycles/(float)(adev->waitfifo_calls) ); + D_DEBUG( "DirectFB/ATI128: Average fifo space cache hits: %02d%%\n", + (int)(100 * adev->fifo_cache_hits/ + (float)(adev->waitfifo_calls)) ); + + /* clean up, make sure that aty128fb does not hang in kernel space + afterwards */ + ati128_waitfifo( adrv, adev, 3 ); + + ati128_out32( mmio, DP_GUI_MASTER_CNTL, + GMC_SRC_PITCH_OFFSET_DEFAULT | + GMC_DST_PITCH_OFFSET_DEFAULT | + GMC_SRC_CLIP_DEFAULT | + GMC_DST_CLIP_DEFAULT | + GMC_BRUSH_SOLIDCOLOR | + GMC_SRC_DSTCOLOR | + GMC_BYTE_ORDER_MSB_TO_LSB | + GMC_DP_CONVERSION_TEMP_6500 | + ROP3_PATCOPY | + GMC_DP_SRC_RECT | + GMC_3D_FCN_EN_CLR | + GMC_DST_CLR_CMP_FCN_CLEAR | + GMC_AUX_CLIP_CLEAR | + GMC_WRITE_MASK_SET); + + ati128_out32( mmio, SCALE_3D_CNTL, 0x00000000 ); + ati128_out32( mmio, TEX_CNTL, 0x00000000 ); +} + +static void +driver_close_driver( CoreGraphicsDevice *device, + void *driver_data ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + + dfb_gfxcard_unmap_mmio( device, adrv->mmio_base, -1 ); +} diff --git a/Source/DirectFB/gfxdrivers/ati128/ati128.h b/Source/DirectFB/gfxdrivers/ati128/ati128.h new file mode 100755 index 0000000..9b6d149 --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/ati128.h @@ -0,0 +1,76 @@ +/* + (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org) + (c) Copyright 2000-2004 Convergence (integrated media) GmbH + + All rights reserved. + + Written by Denis Oliver Kropp <dok@directfb.org>, + Andreas Hundt <andi@fischlustig.de>, + Sven Neumann <neo@directfb.org>, + Ville Syrjälä <syrjala@sci.fi> and + Claudio Ciccani <klan@users.sf.net>. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifndef ___ATI128_H__ +#define ___ATI128_H__ + +#include <dfb_types.h> +#include <core/coretypes.h> +#include <core/layers.h> + +typedef struct { + volatile u8 *mmio_base; +} ATI128DriverData; + +typedef struct { + CoreSurface *source; + CoreSurface *destination; + CoreSurfaceBufferLock *src; + DFBSurfaceBlittingFlags blittingflags; + + /* store some ATI register values in native format */ + u32 ATI_dst_bpp; + u32 ATI_color_compare; + u32 ATI_blend_function; + + /* used for the fake texture hack */ + u32 ATI_fake_texture_src; + u32 fake_texture_color; + unsigned int fake_texture_number; + + /* state validation */ + int v_destination; + int v_color; + int v_blending_function; + int v_source; + int v_src_colorkey; + int v_blittingflags; + + /* for fifo/performance monitoring */ + unsigned int fifo_space; + + unsigned int waitfifo_sum; + unsigned int waitfifo_calls; + unsigned int fifo_waitcycles; + unsigned int idle_waitcycles; + unsigned int fifo_cache_hits; +} ATI128DeviceData; + +extern DisplayLayerFuncs atiOverlayFuncs; + +#endif diff --git a/Source/DirectFB/gfxdrivers/ati128/ati128_overlay.c b/Source/DirectFB/gfxdrivers/ati128/ati128_overlay.c new file mode 100755 index 0000000..0a96f7c --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/ati128_overlay.c @@ -0,0 +1,447 @@ +/* + (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org) + (c) Copyright 2000-2004 Convergence (integrated media) GmbH + + All rights reserved. + + Written by Denis Oliver Kropp <dok@directfb.org>, + Andreas Hundt <andi@fischlustig.de>, + Sven Neumann <neo@directfb.org>, + Ville Syrjälä <syrjala@sci.fi> and + Claudio Ciccani <klan@users.sf.net>. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <config.h> + +#include <stdio.h> + +#include <direct/messages.h> + +#include <core/coredefs.h> +#include <core/layers.h> +#include <core/surface.h> + +#include "regs.h" +#include "mmio.h" +#include "ati128.h" + +typedef struct { + CoreLayerRegionConfig config; + + /* overlay registers */ + struct { + u32 H_INC; + u32 STEP_BY; + u32 Y_X_START; + u32 Y_X_END; + u32 V_INC; + u32 P1_BLANK_LINES_AT_TOP; + u32 P23_BLANK_LINES_AT_TOP; + u32 VID_BUF_PITCH0_VALUE; + u32 VID_BUF_PITCH1_VALUE; + u32 P1_X_START_END; + u32 P2_X_START_END; + u32 P3_X_START_END; + u32 VID_BUF0_BASE_ADRS; + u32 VID_BUF1_BASE_ADRS; + u32 VID_BUF2_BASE_ADRS; + u32 P1_V_ACCUM_INIT; + u32 P23_V_ACCUM_INIT; + u32 P1_H_ACCUM_INIT; + u32 P23_H_ACCUM_INIT; + u32 SCALE_CNTL; + } regs; +} ATIOverlayLayerData; + +static void ov0_set_regs( ATI128DriverData *adrv, ATIOverlayLayerData *aov0 ); +static void ov0_calc_regs( ATI128DriverData *adrv, ATIOverlayLayerData *aov0, + CoreLayerRegionConfig *config, CoreSurface *surface, + CoreSurfaceBufferLock *lock ); + +#define OV0_SUPPORTED_OPTIONS (DLOP_NONE) + +/**********************/ + +static int +ov0LayerDataSize( void ) +{ + return sizeof(ATIOverlayLayerData); +} + +static DFBResult +ov0InitLayer( CoreLayer *layer, + void *driver_data, + void *layer_data, + DFBDisplayLayerDescription *description, + DFBDisplayLayerConfig *config, + DFBColorAdjustment *adjustment ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + volatile u8 *mmio = adrv->mmio_base; + + /* set capabilities and type */ + description->caps = DLCAPS_SCREEN_LOCATION | DLCAPS_SURFACE; + description->type = DLTF_VIDEO | DLTF_STILL_PICTURE; + + /* set name */ + snprintf( description->name, + DFB_DISPLAY_LAYER_DESC_NAME_LENGTH, "ATI128 Overlay" ); + + /* fill out the default configuration */ + config->flags = DLCONF_WIDTH | DLCONF_HEIGHT | + DLCONF_PIXELFORMAT | DLCONF_BUFFERMODE | + DLCONF_OPTIONS; + config->width = 640; + config->height = 480; + config->pixelformat = DSPF_YUY2; + config->buffermode = DLBM_FRONTONLY; + config->options = DLOP_NONE; + + /* fill out default color adjustment, + only fields set in flags will be accepted from applications */ + adjustment->flags = DCAF_NONE; + + /* reset overlay */ + ati128_out32( mmio, OV0_SCALE_CNTL, 0x80000000 ); + ati128_out32( mmio, OV0_EXCLUSIVE_HORZ, 0 ); + ati128_out32( mmio, OV0_AUTO_FLIP_CNTL, 0 ); + ati128_out32( mmio, OV0_FILTER_CNTL, 0x0000000f ); + ati128_out32( mmio, OV0_COLOR_CNTL, 0x00101000 ); + ati128_out32( mmio, OV0_KEY_CNTL, 0x10 ); + ati128_out32( mmio, OV0_TEST, 0 ); + + return DFB_OK; +} + + +static void +ov0OnOff( ATI128DriverData *adrv, + ATIOverlayLayerData *aov0, + int on ) +{ + /* set/clear enable bit */ + if (on) + aov0->regs.SCALE_CNTL |= R128_SCALER_ENABLE; + else + aov0->regs.SCALE_CNTL &= ~R128_SCALER_ENABLE; + + /* write back to card */ + ati128_out32( adrv->mmio_base, OV0_SCALE_CNTL, aov0->regs.SCALE_CNTL ); +} + +static DFBResult +ov0TestRegion( CoreLayer *layer, + void *driver_data, + void *layer_data, + CoreLayerRegionConfig *config, + CoreLayerRegionConfigFlags *failed ) +{ + CoreLayerRegionConfigFlags fail = 0; + + /* check for unsupported options */ + if (config->options & ~OV0_SUPPORTED_OPTIONS) + fail |= CLRCF_OPTIONS; + + /* check pixel format */ + switch (config->format) { + case DSPF_YUY2: + case DSPF_UYVY: + case DSPF_I420: + case DSPF_YV12: + break; + + default: + fail |= CLRCF_FORMAT; + } + + /* check width */ + if (config->width > 2048 || config->width < 1) + fail |= CLRCF_WIDTH; + + /* check height */ + if (config->height > 1024 || config->height < 1) + fail |= CLRCF_HEIGHT; + + /* write back failing fields */ + if (failed) + *failed = fail; + + /* return failure if any field failed */ + if (fail) + return DFB_UNSUPPORTED; + + return DFB_OK; +} + +static DFBResult +ov0SetRegion( CoreLayer *layer, + void *driver_data, + void *layer_data, + void *region_data, + CoreLayerRegionConfig *config, + CoreLayerRegionConfigFlags updated, + CoreSurface *surface, + CorePalette *palette, + CoreSurfaceBufferLock *lock ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + ATIOverlayLayerData *aov0 = (ATIOverlayLayerData*) layer_data; + + /* remember configuration */ + aov0->config = *config; + + ov0_calc_regs( adrv, aov0, config, surface, lock ); + ov0_set_regs( adrv, aov0 ); + + /* enable overlay */ + ov0OnOff( adrv, aov0, 1 ); + + return DFB_OK; +} + +static DFBResult +ov0RemoveRegion( CoreLayer *layer, + void *driver_data, + void *layer_data, + void *region_data ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + ATIOverlayLayerData *aov0 = (ATIOverlayLayerData*) layer_data; + + /* disable overlay */ + ov0OnOff( adrv, aov0, 0 ); + + return DFB_OK; +} + +static DFBResult +ov0FlipRegion( CoreLayer *layer, + void *driver_data, + void *layer_data, + void *region_data, + CoreSurface *surface, + DFBSurfaceFlipFlags flags, + CoreSurfaceBufferLock *lock ) +{ + ATI128DriverData *adrv = (ATI128DriverData*) driver_data; + ATIOverlayLayerData *aov0 = (ATIOverlayLayerData*) layer_data; + + dfb_surface_flip( surface, false ); + + ov0_calc_regs( adrv, aov0, &aov0->config, surface, lock ); + ov0_set_regs( adrv, aov0 ); + + return DFB_OK; +} + + +DisplayLayerFuncs atiOverlayFuncs = { + .LayerDataSize = ov0LayerDataSize, + .InitLayer = ov0InitLayer, + + .TestRegion = ov0TestRegion, + .SetRegion = ov0SetRegion, + .RemoveRegion = ov0RemoveRegion, + .FlipRegion = ov0FlipRegion, +}; + +/* internal */ + +static void ov0_set_regs( ATI128DriverData *adrv, ATIOverlayLayerData *aov0 ) +{ + volatile u8 *mmio = adrv->mmio_base; + + ati128_out32( mmio, OV0_REG_LOAD_CNTL, 1 ); + while (!(ati128_in32( mmio, OV0_REG_LOAD_CNTL ) & (1 << 3))); + + ati128_out32( mmio, OV0_H_INC, + aov0->regs.H_INC ); + + ati128_out32( mmio, OV0_STEP_BY, + aov0->regs.STEP_BY ); + + ati128_out32( mmio, OV0_Y_X_START, + aov0->regs.Y_X_START ); + + ati128_out32( mmio, OV0_Y_X_END, + aov0->regs.Y_X_END ); + + ati128_out32( mmio, OV0_V_INC, + aov0->regs.V_INC ); + + ati128_out32( mmio, OV0_P1_BLANK_LINES_AT_TOP, + aov0->regs.P1_BLANK_LINES_AT_TOP ); + + ati128_out32( mmio, OV0_P23_BLANK_LINES_AT_TOP, + aov0->regs.P23_BLANK_LINES_AT_TOP ); + + ati128_out32( mmio, OV0_VID_BUF_PITCH0_VALUE, + aov0->regs.VID_BUF_PITCH0_VALUE ); + + ati128_out32( mmio, OV0_VID_BUF_PITCH1_VALUE, + aov0->regs.VID_BUF_PITCH1_VALUE ); + + ati128_out32( mmio, OV0_P1_X_START_END, + aov0->regs.P1_X_START_END ); + + ati128_out32( mmio, OV0_P2_X_START_END, + aov0->regs.P2_X_START_END ); + + ati128_out32( mmio, OV0_P3_X_START_END, + aov0->regs.P3_X_START_END ); + + ati128_out32( mmio, OV0_VID_BUF0_BASE_ADRS, + aov0->regs.VID_BUF0_BASE_ADRS ); + + ati128_out32( mmio, OV0_VID_BUF1_BASE_ADRS, + aov0->regs.VID_BUF1_BASE_ADRS ); + + ati128_out32( mmio, OV0_VID_BUF2_BASE_ADRS, + aov0->regs.VID_BUF2_BASE_ADRS ); + + ati128_out32( mmio, OV0_P1_V_ACCUM_INIT, + aov0->regs.P1_V_ACCUM_INIT ); + + ati128_out32( mmio, OV0_P23_V_ACCUM_INIT, + aov0->regs.P23_V_ACCUM_INIT ); + + ati128_out32( mmio, OV0_P1_H_ACCUM_INIT, + aov0->regs.P1_H_ACCUM_INIT ); + + ati128_out32( mmio, OV0_P23_H_ACCUM_INIT, + aov0->regs.P23_H_ACCUM_INIT ); + + ati128_out32( mmio, OV0_SCALE_CNTL, + aov0->regs.SCALE_CNTL ); + + ati128_out32( mmio, OV0_REG_LOAD_CNTL, 0 ); +} + +static void ov0_calc_regs( ATI128DriverData *adrv, + ATIOverlayLayerData *aov0, + CoreLayerRegionConfig *config, + CoreSurface *surface, + CoreSurfaceBufferLock *lock ) +{ + int h_inc, v_inc, step_by, tmp; + int p1_h_accum_init, p23_h_accum_init; + int p1_v_accum_init, p23_v_accum_init; + + DFBRegion dstBox; + int dst_w; + int dst_h; + u32 offset_u = 0, offset_v = 0; + + /* destination box */ + dstBox.x1 = config->dest.x; + dstBox.y1 = config->dest.y; + dstBox.x2 = config->dest.x + config->dest.w; + dstBox.y2 = config->dest.y + config->dest.h; + + /* destination size */ + dst_w = config->dest.w; + dst_h = config->dest.h; + + /* clear everything but the enable bit that may be set*/ + aov0->regs.SCALE_CNTL &= R128_SCALER_ENABLE; + + + /* calculate incrementors */ + h_inc = (surface->config.size.w << 12) / dst_w; + v_inc = (surface->config.size.h << 20) / dst_h; + step_by = 1; + + while (h_inc >= (2 << 12)) { + step_by++; + h_inc >>= 1; + } + + /* calculate values for horizontal accumulators */ + tmp = 0x00028000 + (h_inc << 3); + p1_h_accum_init = ((tmp << 4) & 0x000f8000) | ((tmp << 12) & 0xf0000000); + + tmp = 0x00028000 + (h_inc << 2); + p23_h_accum_init = ((tmp << 4) & 0x000f8000) | ((tmp << 12) & 0x70000000); + + /* calculate values for vertical accumulators */ + tmp = 0x00018000; + p1_v_accum_init = ((tmp << 4) & 0x03ff8000) | 0x00000001; + + tmp = 0x00018000; + p23_v_accum_init = ((tmp << 4) & 0x01ff8000) | 0x00000001; + + /* choose pixel format and calculate buffer offsets for planar modes */ + switch (surface->config.format) { + case DSPF_UYVY: + aov0->regs.SCALE_CNTL = R128_SCALER_SOURCE_YVYU422; + break; + + case DSPF_YUY2: + aov0->regs.SCALE_CNTL = R128_SCALER_SOURCE_VYUY422; + break; + + case DSPF_I420: + aov0->regs.SCALE_CNTL = R128_SCALER_SOURCE_YUV12; + + offset_u = lock->offset + + surface->config.size.h * lock->pitch; + offset_v = offset_u + + (surface->config.size.h >> 1) * (lock->pitch >> 1); + break; + + case DSPF_YV12: + aov0->regs.SCALE_CNTL = R128_SCALER_SOURCE_YUV12; + + offset_v = lock->offset + + surface->config.size.h * lock->pitch; + offset_u = offset_v + + (surface->config.size.h >> 1) * (lock->pitch >> 1); + break; + + default: + D_BUG("unexpected pixelformat"); + aov0->regs.SCALE_CNTL = 0; + return; + } + + aov0->regs.SCALE_CNTL |= R128_SCALER_DOUBLE_BUFFER | + R128_SCALER_BURST_PER_PLANE | + R128_SCALER_Y2R_TEMP | + R128_SCALER_PIX_EXPAND; + + aov0->regs.H_INC = h_inc | ((h_inc >> 1) << 16); + aov0->regs.V_INC = v_inc; + aov0->regs.STEP_BY = step_by | (step_by << 8); + aov0->regs.Y_X_START = dstBox.x1 | (dstBox.y1 << 16); + aov0->regs.Y_X_END = dstBox.x2 | (dstBox.y2 << 16); + aov0->regs.P1_BLANK_LINES_AT_TOP = 0x00000fff | ((surface->config.size.h - 1) << 16); + aov0->regs.P23_BLANK_LINES_AT_TOP = 0x000007ff | ((((surface->config.size.h + 1) >> 1) - 1) << 16); + aov0->regs.VID_BUF_PITCH0_VALUE = lock->pitch; + aov0->regs.VID_BUF_PITCH1_VALUE = lock->pitch >> 1; + aov0->regs.P1_X_START_END = surface->config.size.w - 1; + aov0->regs.P2_X_START_END = (surface->config.size.w >> 1) - 1; + aov0->regs.P3_X_START_END = (surface->config.size.w >> 1) - 1; + aov0->regs.VID_BUF0_BASE_ADRS = lock->offset & 0x03fffff0; + aov0->regs.VID_BUF1_BASE_ADRS = (offset_u & 0x03fffff0) | 1; + aov0->regs.VID_BUF2_BASE_ADRS = (offset_v & 0x03fffff0) | 1; + aov0->regs.P1_H_ACCUM_INIT = p1_h_accum_init; + aov0->regs.P23_H_ACCUM_INIT = p23_h_accum_init; + aov0->regs.P1_V_ACCUM_INIT = p1_v_accum_init; + aov0->regs.P23_V_ACCUM_INIT = p23_v_accum_init; +} + diff --git a/Source/DirectFB/gfxdrivers/ati128/ati128_state.c b/Source/DirectFB/gfxdrivers/ati128/ati128_state.c new file mode 100755 index 0000000..ebe52d7 --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/ati128_state.c @@ -0,0 +1,314 @@ +/* + (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org) + (c) Copyright 2000-2004 Convergence (integrated media) GmbH + + All rights reserved. + + Written by Denis Oliver Kropp <dok@directfb.org>, + Andreas Hundt <andi@fischlustig.de>, + Sven Neumann <neo@directfb.org>, + Ville Syrjälä <syrjala@sci.fi> and + Claudio Ciccani <klan@users.sf.net>. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <config.h> + +#include <directfb.h> + +#include <direct/messages.h> + +#include <core/coredefs.h> +#include <core/coretypes.h> + +#include <core/state.h> +#include <core/gfxcard.h> +#include <core/surface.h> + +#include <gfx/convert.h> + +#include "regs.h" +#include "mmio.h" +#include "ati128.h" + +#include "ati128_state.h" + + +static u32 ati128SourceBlend[] = { + SCALE_3D_CNTL_ALPHA_BLEND_SRC_ZERO, /* DSBF_ZERO */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_ONE, /* DSBF_ONE */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_SRCCOLOR, /* DSBF_SRCCOLOR */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVSRCCOLOR, /* DSBF_INVSRCCOLOR */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_SRCALPHA, /* DSBF_SRCALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVSRCALPHA, /* DSBF_INVSRCALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_DSTALPHA, /* DSBF_DESTALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVDSTALPHA, /* DSBF_INVDESTALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_DSTCOLOR, /* DSBF_DESTCOLOR */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVDSTCOLOR, /* DSBF_INVDESTCOLOR */ + SCALE_3D_CNTL_ALPHA_BLEND_SRC_SAT /* DSBF_SRCALPHASAT */ +}; + +static u32 ati128DestBlend[] = { + SCALE_3D_CNTL_ALPHA_BLEND_DST_ZERO, /* DSBF_ZERO */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_ONE, /* DSBF_ONE */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_SRCCOLOR, /* DSBF_SRCCOLOR */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_INVSRCCOLOR, /* DSBF_INVSRCCOLOR */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_SRCALPHA, /* DSBF_SRCALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_INVSRCALPHA, /* DSBF_INVSRCALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_DSTALPHA, /* DSBF_DESTALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_INVDSTALPHA, /* DSBF_INVDESTALPHA */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_DSTCOLOR, /* DSBF_DESTCOLOR */ + SCALE_3D_CNTL_ALPHA_BLEND_DST_INVDSTCOLOR, /* DSBF_INVDESTCOLOR */ + 0 /* DSBF_SRCALPHASAT */ +}; + +void ati128_set_destination( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ) +{ + CoreSurface *destination = state->destination; + + if (adev->v_destination) + return; + + ati128_waitfifo( adrv, adev, 1 ); + + switch (destination->config.format) { + case DSPF_RGB332: + ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET, + ((state->dst.pitch >> 3) << 21) | + (state->dst.offset >> 5)); + + adev->ATI_dst_bpp = DST_8BPP_RGB332; + break; + case DSPF_ARGB1555: + ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET, + ((state->dst.pitch >> 4) << 21) | + (state->dst.offset >> 5)); + + adev->ATI_dst_bpp = DST_15BPP; + break; + case DSPF_RGB16: + ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET, + ((state->dst.pitch >> 4) << 21) | + (state->dst.offset >> 5)); + + adev->ATI_dst_bpp = DST_16BPP; + break; + case DSPF_RGB24: + ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET, + ((state->dst.pitch >> 3) << 21) | + (state->dst.offset >> 5)); + + adev->ATI_dst_bpp = DST_24BPP; + break; + case DSPF_RGB32: + case DSPF_ARGB: + ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET, + ((state->dst.pitch >> 5) << 21) | + (state->dst.offset >> 5)); + + adev->ATI_dst_bpp = DST_32BPP; + break; + default: + D_BUG( "unexpected pixelformat!" ); + break; + } + adev->destination = destination; + + adev->v_destination = 1; +} + +void ati128_set_source( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ) +{ + + if (adev->v_source) + return; + + ati128_waitfifo( adrv, adev, 3 ); + + switch (state->source->config.format) { + case DSPF_RGB332: + ati128_out32( adrv->mmio_base, SRC_PITCH, + state->src.pitch >> 3); + + ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x000000FF ); + break; + case DSPF_ARGB1555: + ati128_out32( adrv->mmio_base, SRC_PITCH, + state->src.pitch >> 4); + + ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x00007FFF ); + break; + case DSPF_RGB16: + ati128_out32( adrv->mmio_base, SRC_PITCH, + state->src.pitch >> 4); + + ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x0000FFFF ); + break; + case DSPF_RGB24: + ati128_out32( adrv->mmio_base, SRC_PITCH, + state->src.pitch >> 3); + + ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x00FFFFFF ); + break; + case DSPF_RGB32: + case DSPF_ARGB: + ati128_out32( adrv->mmio_base, SRC_PITCH, + state->src.pitch >> 5); + + ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x00FFFFFF ); + break; + default: + D_BUG( "unexpected pixelformat!" ); + break; + } + + ati128_out32( adrv->mmio_base, SRC_OFFSET, + state->src.offset ); + + adev->source = state->source; + adev->src = &state->src; + adev->v_source = 1; +} + +void ati128_set_clip( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ) +{ + + ati128_waitfifo( adrv, adev, 2 ); + + /* 24bpp needs special treatment */ + if (state->destination->config.format == DSPF_RGB24) { + ati128_out32( adrv->mmio_base, SC_TOP_LEFT, + (state->clip.y1 << 16) | (state->clip.x1*3) ); + + ati128_out32( adrv->mmio_base, SC_BOTTOM_RIGHT, + (state->clip.y2 << 16) | ((state->clip.x2*3) + 3)); + } + else { + ati128_out32( adrv->mmio_base, SC_TOP_LEFT, + (state->clip.y1 << 16) | state->clip.x1 ); + + ati128_out32( adrv->mmio_base, SC_BOTTOM_RIGHT, + (state->clip.y2 << 16) | state->clip.x2 ); + } +} + +void ati128_set_color( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ) +{ + u32 fill_color = 0; + + if (adev->v_color) + return; + + switch (state->destination->config.format) { + case DSPF_RGB332: + fill_color = PIXEL_RGB332( state->color.r, + state->color.g, + state->color.b ); + break; + case DSPF_ARGB1555: + fill_color = PIXEL_ARGB1555( state->color.a, + state->color.r, + state->color.g, + state->color.b ); + break; + case DSPF_RGB16: + fill_color = PIXEL_RGB16( state->color.r, + state->color.g, + state->color.b ); + break; + case DSPF_RGB24: + case DSPF_RGB32: + fill_color = PIXEL_RGB32( state->color.r, + state->color.g, + state->color.b ); + break; + case DSPF_ARGB: + fill_color = PIXEL_ARGB( state->color.a, + state->color.r, + state->color.g, + state->color.b ); + break; + default: + D_BUG( "unexpected pixelformat!" ); + break; + } + + ati128_waitfifo( adrv, adev, 1 ); + ati128_out32( adrv->mmio_base, DP_BRUSH_FRGD_CLR, fill_color); + + + adev->fake_texture_color = PIXEL_ARGB( state->color.a, + state->color.r, + state->color.g, + state->color.b ); + + adev->v_color = 1; +} + +void ati128_set_src_colorkey( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ) +{ + if (adev->v_src_colorkey) + return; + + ati128_waitfifo( adrv, adev, 1 ); + ati128_out32( adrv->mmio_base, CLR_CMP_CLR_SRC, state->src_colorkey ); + + adev->v_src_colorkey = 1; +} + +void ati128_set_blittingflags( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ) +{ + if (adev->v_blittingflags) + return; + + if (state->blittingflags & DSBLIT_SRC_COLORKEY) { + adev->ATI_color_compare = (1 << 24) | 5; + } + else { + adev->ATI_color_compare = 0; + } + + adev->blittingflags = state->blittingflags; + adev->v_blittingflags = 1; +} + +void ati128_set_blending_function( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ) +{ + if (adev->v_blending_function) + return; + + adev->ATI_blend_function = SCALE_3D_CNTL_SCALE_3D_FN_SCALE | + ati128SourceBlend[state->src_blend - 1] | + ati128DestBlend [state->dst_blend - 1] | + SCALE_3D_CNTL_TEX_MAP_AEN_ON; + + adev->v_blending_function = 1; +} diff --git a/Source/DirectFB/gfxdrivers/ati128/ati128_state.h b/Source/DirectFB/gfxdrivers/ati128/ati128_state.h new file mode 100755 index 0000000..4cee1cf --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/ati128_state.h @@ -0,0 +1,62 @@ +/* + (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org) + (c) Copyright 2000-2004 Convergence (integrated media) GmbH + + All rights reserved. + + Written by Denis Oliver Kropp <dok@directfb.org>, + Andreas Hundt <andi@fischlustig.de>, + Sven Neumann <neo@directfb.org>, + Ville Syrjälä <syrjala@sci.fi> and + Claudio Ciccani <klan@users.sf.net>. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifndef ___ATI128_STATE_H__ +#define ___ATI128_STATE_H__ + +#include "ati128.h" + +void ati128_set_destination( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ); +void ati128_set_source( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ); + +void ati128_set_blittingflags( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ); + +void ati128_set_clip( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ); + +void ati128_set_color( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ); + +void ati128_set_src_colorkey( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ); + +void ati128_set_blending_function( ATI128DriverData *adrv, + ATI128DeviceData *adev, + CardState *state ); + + +#endif diff --git a/Source/DirectFB/gfxdrivers/ati128/mmio.h b/Source/DirectFB/gfxdrivers/ati128/mmio.h new file mode 100755 index 0000000..d2df943 --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/mmio.h @@ -0,0 +1,121 @@ +/* + (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org) + (c) Copyright 2000-2004 Convergence (integrated media) GmbH + + All rights reserved. + + Written by Denis Oliver Kropp <dok@directfb.org>, + Andreas Hundt <andi@fischlustig.de>, + Sven Neumann <neo@directfb.org>, + Ville Syrjälä <syrjala@sci.fi> and + Claudio Ciccani <klan@users.sf.net>. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + + +#ifndef ___ATI128_MMIO_H__ +#define ___ATI128_MMIO_H__ + +#include <dfb_types.h> + +#include "ati128.h" + +static inline void +ati128_out32(volatile u8 *mmioaddr, u32 reg, u32 value) +{ +#ifdef __powerpc__ + asm volatile("stwbrx %0,%1,%2;eieio" : : "r"(value), "b"(reg), + "r"(mmioaddr) : "memory"); + +#else + *((volatile u32*)(mmioaddr+reg)) = value; +#endif +} + +static inline u32 +ati128_in32(volatile u8 *mmioaddr, u32 reg) +{ +#ifdef __powerpc__ + u32 value; + + asm volatile("lwbrx %0,%1,%2;eieio" : "=r"(value) : "b"(reg), "r"(mmioaddr)); + + return value; +#else + return *((volatile u32*)(mmioaddr+reg)); +#endif +} + +static inline void ati128_waitidle( ATI128DriverData *adrv, + ATI128DeviceData *adev ) +{ + int timeout = 1000000; + + while (timeout--) { + if ((ati128_in32( adrv->mmio_base, GUI_STAT) & 0x00000FFF) == 64) + break; + + adev->idle_waitcycles++; + } + + timeout = 1000000; + + while (timeout--) { + if ((ati128_in32( adrv->mmio_base, GUI_STAT) & (GUI_ACTIVE | ENG_3D_BUSY)) == ENGINE_IDLE) + break; + + adev->idle_waitcycles++; + } + + ati128_out32( adrv->mmio_base, PC_NGUI_CTLSTAT, + ati128_in32( adrv->mmio_base, PC_NGUI_CTLSTAT) | 0x000000ff); + + timeout = 1000000; + while (timeout--) { + if ((ati128_in32( adrv->mmio_base, PC_NGUI_CTLSTAT) & PC_BUSY) != PC_BUSY) + break; + + adev->idle_waitcycles++; + } + adev->fifo_space = 60; +} + +static inline void ati128_waitfifo( ATI128DriverData *adrv, + ATI128DeviceData *adev, + unsigned int requested_fifo_space) +{ + int timeout = 1000000; + + adev->waitfifo_sum += requested_fifo_space; + adev->waitfifo_calls++; + + if (adev->fifo_space < requested_fifo_space) { + while (timeout--) { + adev->fifo_waitcycles++; + + adev->fifo_space = ati128_in32( adrv->mmio_base, GUI_STAT) & 0x00000FFF; + if (adev->fifo_space >= requested_fifo_space) + break; + } + } + else { + adev->fifo_cache_hits++; + } + adev->fifo_space -= requested_fifo_space; +} + +#endif diff --git a/Source/DirectFB/gfxdrivers/ati128/regs.h b/Source/DirectFB/gfxdrivers/ati128/regs.h new file mode 100755 index 0000000..168eeb0 --- /dev/null +++ b/Source/DirectFB/gfxdrivers/ati128/regs.h @@ -0,0 +1,919 @@ +#ifndef REG_RAGE128_H +#define REG_RAGE128_H + +#define CLOCK_CNTL_INDEX 0x0008 +#define CLOCK_CNTL_DATA 0x000c +#define BIOS_0_SCRATCH 0x0010 +#define BUS_CNTL 0x0030 +#define GEN_INT_CNTL 0x0040 +#define CRTC_GEN_CNTL 0x0050 +#define CRTC_EXT_CNTL 0x0054 +#define DAC_CNTL 0x0058 +#define I2C_CNTL_1 0x0094 +#define PALETTE_INDEX 0x00b0 +#define PALETTE_DATA 0x00b4 +#define CONFIG_CNTL 0x00e0 +#define GEN_RESET_CNTL 0x00f0 +#define CONFIG_MEMSIZE 0x00f8 +#define MEM_CNTL 0x0140 +#define AGP_BASE 0x0170 +#define AGP_CNTL 0x0174 +#define AGP_APER_OFFSET 0x0178 +#define PCI_GART_PAGE 0x017c +#define PC_NGUI_MODE 0x0180 +#define PC_NGUI_CTLSTAT 0x0184 +#define MPP_TB_CONFIG 0x01C0 +#define MPP_GP_CONFIG 0x01C8 +#define VIPH_CONTROL 0x01D0 +#define CRTC_H_TOTAL_DISP 0x0200 +#define CRTC_H_SYNC_STRT_WID 0x0204 +#define CRTC_V_TOTAL_DISP 0x0208 +#define CRTC_V_SYNC_STRT_WID 0x020c +#define CRTC_OFFSET 0x0224 +#define CRTC_OFFSET_CNTL 0x0228 +#define CRTC_PITCH 0x022c +#define OVR_CLR 0x0230 +#define OVR_WID_LEFT_RIGHT 0x0234 +#define OVR_WID_TOP_BOTTOM 0x0238 +#define LVDS_GEN_CNTL 0x02d0 +#define DDA_CONFIG 0x02e0 +#define DDA_ON_OFF 0x02e4 +#define VGA_DDA_CONFIG 0x02e8 +#define VGA_DDA_ON_OFF 0x02ec +#define OV0_SCALE_CNTL 0x0420 +#define SUBPIC_CNTL 0x0540 +#define PM4_BUFFER_OFFSET 0x0700 +#define PM4_BUFFER_CNTL 0x0704 +#define PM4_BUFFER_WM_CNTL 0x0708 +#define PM4_BUFFER_DL_RPTR_ADDR 0x070c +#define PM4_BUFFER_DL_RPTR 0x0710 +#define PM4_BUFFER_DL_WPTR 0x0714 +#define PM4_VC_FPU_SETUP 0x071c +#define PM4_FPU_CNTL 0x0720 +#define PM4_VC_FORMAT 0x0724 +#define PM4_VC_CNTL 0x0728 +#define PM4_VC_I01 0x072c +#define PM4_VC_VLOFF 0x0730 +#define PM4_VC_VLSIZE 0x0734 +#define PM4_IW_INDOFF 0x0738 +#define PM4_IW_INDSIZE 0x073c +#define PM4_FPU_FPX0 0x0740 +#define PM4_FPU_FPY0 0x0744 +#define PM4_FPU_FPX1 0x0748 +#define PM4_FPU_FPY1 0x074c +#define PM4_FPU_FPX2 0x0750 +#define PM4_FPU_FPY2 0x0754 +#define PM4_FPU_FPY3 0x0758 +#define PM4_FPU_FPY4 0x075c +#define PM4_FPU_FPY5 0x0760 +#define PM4_FPU_FPY6 0x0764 +#define PM4_FPU_FPR 0x0768 +#define PM4_FPU_FPG 0x076c +#define PM4_FPU_FPB 0x0770 +#define PM4_FPU_FPA 0x0774 +#define PM4_FPU_INTXY0 0x0780 +#define PM4_FPU_INTXY1 0x0784 +#define PM4_FPU_INTXY2 0x0788 +#define PM4_FPU_INTARGB 0x078c +#define PM4_FPU_FPTWICEAREA 0x0790 +#define PM4_FPU_DMAJOR01 0x0794 +#define PM4_FPU_DMAJOR12 0x0798 +#define PM4_FPU_DMAJOR02 0x079c +#define PM4_FPU_STAT 0x07a0 +#define PM4_STAT 0x07b8 +#define PM4_TEST_CNTL 0x07d0 +#define PM4_MICROCODE_ADDR 0x07d4 +#define PM4_MICROCODE_RADDR 0x07d8 +#define PM4_MICROCODE_DATAH 0x07dc +#define PM4_MICROCODE_DATAL 0x07e0 +#define PM4_CMDFIFO_ADDR 0x07e4 +#define PM4_CMDFIFO_DATAH 0x07e8 +#define PM4_CMDFIFO_DATAL 0x07ec +#define PM4_BUFFER_ADDR 0x07f0 +#define PM4_BUFFER_DATAH 0x07f4 +#define PM4_BUFFER_DATAL 0x07f8 +#define PM4_MICRO_CNTL 0x07fc +#define CAP0_TRIG_CNTL 0x0950 +#define CAP1_TRIG_CNTL 0x09c0 + +/****************************************************************************** + * GUI Block Memory Mapped Registers * + * These registers are FIFOed. * + *****************************************************************************/ +#define PM4_FIFO_DATA_EVEN 0x1000 +#define PM4_FIFO_DATA_ODD 0x1004 + +#define DST_OFFSET 0x1404 +#define DST_PITCH 0x1408 +#define DST_WIDTH 0x140c +#define DST_HEIGHT 0x1410 +#define SRC_X 0x1414 +#define SRC_Y 0x1418 +#define DST_X 0x141c +#define DST_Y 0x1420 +#define SRC_PITCH_OFFSET 0x1428 +#define DST_PITCH_OFFSET 0x142c +#define SRC_Y_X 0x1434 +#define DST_Y_X 0x1438 +#define DST_HEIGHT_WIDTH 0x143c +#define DP_GUI_MASTER_CNTL 0x146c +#define BRUSH_SCALE 0x1470 +#define BRUSH_Y_X 0x1474 +#define DP_BRUSH_BKGD_CLR 0x1478 +#define DP_BRUSH_FRGD_CLR 0x147c +#define DST_WIDTH_X 0x1588 +#define DST_HEIGHT_WIDTH_8 0x158c +#define SRC_X_Y 0x1590 +#define DST_X_Y 0x1594 +#define DST_WIDTH_HEIGHT 0x1598 +#define DST_WIDTH_X_INCY 0x159c +#define DST_HEIGHT_Y 0x15a0 +#define DST_X_SUB 0x15a4 +#define DST_Y_SUB 0x15a8 +#define SRC_OFFSET 0x15ac +#define SRC_PITCH 0x15b0 +#define DST_HEIGHT_WIDTH_BW 0x15b4 +#define CLR_CMP_CNTL 0x15c0 +#define CLR_CMP_CLR_SRC 0x15c4 +#define CLR_CMP_CLR_DST 0x15c8 +#define CLR_CMP_MASK 0x15cc +#define DP_SRC_FRGD_CLR 0x15d8 +#define DP_SRC_BKGD_CLR 0x15dc +#define DST_BRES_ERR 0x1628 +#define DST_BRES_INC 0x162c +#define DST_BRES_DEC 0x1630 +#define DST_BRES_LNTH 0x1634 +#define DST_BRES_LNTH_SUB 0x1638 +#define SC_LEFT 0x1640 +#define SC_RIGHT 0x1644 +#define SC_TOP 0x1648 +#define SC_BOTTOM 0x164c +#define SRC_SC_RIGHT 0x1654 +#define SRC_SC_BOTTOM 0x165c +#define GUI_DEBUG0 0x16a0 +#define GUI_DEBUG1 0x16a4 +#define GUI_TIMEOUT 0x16b0 +#define GUI_TIMEOUT0 0x16b4 +#define GUI_TIMEOUT1 0x16b8 +#define GUI_PROBE 0x16bc +#define DP_CNTL 0x16c0 +#define DP_DATATYPE 0x16c4 +#define DP_MIX 0x16c8 +#define DP_WRITE_MASK 0x16cc +#define DP_CNTL_XDIR_YDIR_YMAJOR 0x16d0 +#define DEFAULT_OFFSET 0x16e0 +#define DEFAULT_PITCH 0x16e4 +#define DEFAULT_SC_BOTTOM_RIGHT 0x16e8 +#define SC_TOP_LEFT 0x16ec +#define SC_BOTTOM_RIGHT 0x16f0 +#define SRC_SC_BOTTOM_RIGHT 0x16f4 +#define WAIT_UNTIL 0x1720 +#define CACHE_CNTL 0x1724 +#define GUI_STAT 0x1740 +#define PC_GUI_MODE 0x1744 +#define PC_GUI_CTLSTAT 0x1748 +#define PC_DEBUG_MODE 0x1760 +#define BRES_DST_ERR_DEC 0x1780 +#define TRAIL_BRES_T12_ERR_DEC 0x1784 +#define TRAIL_BRES_T12_INC 0x1788 +#define DP_T12_CNTL 0x178c +#define DST_BRES_T1_LNTH 0x1790 +#define DST_BRES_T2_LNTH 0x1794 +#define SCALE_SRC_HEIGHT_WIDTH 0x1994 +#define SCALE_OFFSET_0 0x1998 +#define SCALE_PITCH 0x199c +#define SCALE_X_INC 0x19a0 +#define SCALE_Y_INC 0x19a4 +#define SCALE_HACC 0x19a8 +#define SCALE_VACC 0x19ac +#define SCALE_DST_X_Y 0x19b0 +#define SCALE_DST_HEIGHT_WIDTH 0x19b4 +#define SCALE_3D_CNTL 0x1a00 +#define SCALE_3D_DATATYPE 0x1a20 +#define SETUP_CNTL 0x1bc4 +#define SOLID_COLOR 0x1bc8 +#define WINDOW_XY_OFFSET 0x1bcc +#define DRAW_LINE_POINT 0x1bd0 +#define SETUP_CNTL_PM4 0x1bd4 +#define DST_PITCH_OFFSET_C 0x1c80 +#define DP_GUI_MASTER_CNTL_C 0x1c84 +#define SC_TOP_LEFT_C 0x1c88 +#define SC_BOTTOM_RIGHT_C 0x1c8c + +#define CLR_CMP_MASK_3D 0x1A28 +#define MISC_3D_STATE_CNTL_REG 0x1CA0 +#define MC_SRC1_CNTL 0x19D8 +#define TEX_CNTL 0x1800 + +/* CONSTANTS */ +#define ENG_3D_BUSY 0x02000000 +#define GUI_ACTIVE 0x80000000 + + +#define ENGINE_IDLE 0x0 + +#define PLL_WR_EN 0x00000080 + +#define CLK_PIN_CNTL 0x0001 +#define PPLL_CNTL 0x0002 +#define PPLL_REF_DIV 0x0003 +#define PPLL_DIV_0 0x0004 +#define PPLL_DIV_1 0x0005 +#define PPLL_DIV_2 0x0006 +#define PPLL_DIV_3 0x0007 +#define VCLK_ECP_CNTL 0x0008 +#define HTOTAL_CNTL 0x0009 +#define X_MPLL_REF_FB_DIV 0x000a +#define XPLL_CNTL 0x000b +#define XDLL_CNTL 0x000c +#define XCLK_CNTL 0x000d +#define MPLL_CNTL 0x000e +#define MCLK_CNTL 0x000f +#define AGP_PLL_CNTL 0x0010 +#define FCP_CNTL 0x0012 +#define PLL_TEST_CNTL 0x0013 + +#define PPLL_RESET 0x01 +#define PPLL_ATOMIC_UPDATE_EN 0x10000 +#define PPLL_VGA_ATOMIC_UPDATE_EN 0x20000 +#define PPLL_REF_DIV_MASK 0x3FF +#define PPLL_FB3_DIV_MASK 0x7FF +#define PPLL_POST3_DIV_MASK 0x70000 +#define PPLL_ATOMIC_UPDATE_R 0x8000 +#define PPLL_ATOMIC_UPDATE_W 0x8000 +#define MEM_CFG_TYPE_MASK 0x3 +#define XCLK_SRC_SEL_MASK 0x7 +#define XPLL_FB_DIV_MASK 0xFF00 +#define X_MPLL_REF_DIV_MASK 0xFF + +/* CRTC control values (CRTC_GEN_CNTL) */ +#define CRTC_CSYNC_EN 0x00000010 + +#define CRTC_PIX_WIDTH_MASK 0x00000700 +#define CRTC_PIX_WIDTH_4BPP 0x00000100 +#define CRTC_PIX_WIDTH_8BPP 0x00000200 +#define CRTC_PIX_WIDTH_15BPP 0x00000300 +#define CRTC_PIX_WIDTH_16BPP 0x00000400 +#define CRTC_PIX_WIDTH_24BPP 0x00000500 +#define CRTC_PIX_WIDTH_32BPP 0x00000600 + +/* DAC_CNTL bit constants */ +#define DAC_8BIT_EN 0x00000100 +#define DAC_MASK 0xFF000000 +#define DAC_BLANKING 0x00000004 +#define DAC_RANGE_CNTL 0x00000003 +#define DAC_RANGE_CNTL 0x00000003 +#define DAC_PALETTE_ACCESS_CNTL 0x00000020 +#define DAC_PDWN 0x00008000 + +/* GEN_RESET_CNTL bit constants */ +#define SOFT_RESET_GUI 0x00000001 +#define SOFT_RESET_VCLK 0x00000100 +#define SOFT_RESET_PCLK 0x00000200 +#define SOFT_RESET_ECP 0x00000400 +#define SOFT_RESET_DISPENG_XCLK 0x00000800 + +/* PC_GUI_CTLSTAT bit constants */ +#define PC_BUSY_INIT 0x10000000 +#define PC_BUSY_GUI 0x20000000 +#define PC_BUSY_NGUI 0x40000000 +#define PC_BUSY 0x80000000 + +#define BUS_MASTER_DIS 0x00000040 +#define PM4_BUFFER_CNTL_NONPM4 0x00000000 + +/* DP_DATATYPE bit constants */ +#define DST_8BPP 0x00000002 +#define DST_15BPP 0x00000003 +#define DST_16BPP 0x00000004 +#define DST_24BPP 0x00000005 +#define DST_32BPP 0x00000006 +#define DST_8BPP_RGB332 0x00000007 +#define DST_8BPP_Y8 0x00000008 +#define DST_8BPP_RGB8 0x00000009 +#define DST_16BPP_VYUY422 0x0000000b +#define DST_16BPP_YVYU422 0x0000000c +#define DST_32BPP_AYUV444 0x0000000e +#define DST_16BPP_ARGB4444 0x0000000f +#define BRUSH_8x8MONO 0x00000000 +#define BRUSH_8x8MONO_LBKGD 0x00000100 +#define BRUSH_8x1MONO 0x00000200 +#define BRUSH_8x1MONO_LBKGD 0x00000300 +#define BRUSH_1x8MONO 0x00000400 +#define BRUSH_1x8MONO_LBKGD 0x00000500 +#define BRUSH_32x1MONO 0x00000600 +#define BRUSH_32x1MONO_LBKGD 0x00000700 +#define BRUSH_32x32MONO 0x00000800 +#define BRUSH_32x32MONO_LBKGD 0x00000900 +#define BRUSH_8x8COLOR 0x00000a00 +#define BRUSH_8x1COLOR 0x00000b00 +#define BRUSH_1x8COLOR 0x00000c00 +#define BRUSH_SOLIDCOLOR 0x00000d00 +#define SRC_MONO 0x00000000 +#define SRC_MONO_LBKGD 0x00010000 +#define SRC_DSTCOLOR 0x00030000 +#define BYTE_ORDER_MSB_TO_LSB 0x00000000 +#define BYTE_ORDER_LSB_TO_MSB 0x40000000 +#define DP_CONVERSION_TEMP 0x80000000 + +/* DP_GUI_MASTER_CNTL bit constants */ +#define GMC_SRC_PITCH_OFFSET_DEFAULT 0x00000000 +#define GMC_DST_PITCH_OFFSET_DEFAULT 0x00000000 +#define GMC_SRC_CLIP_DEFAULT 0x00000000 +#define GMC_DST_CLIP_DEFAULT 0x00000000 +#define GMC_BRUSH_SOLIDCOLOR 0x000000d0 +#define GMC_SRC_DSTCOLOR 0x00003000 +#define GMC_BYTE_ORDER_MSB_TO_LSB 0x00000000 +#define GMC_DP_SRC_RECT 0x02000000 +#define GMC_3D_FCN_EN_CLR 0x00000000 +#define GMC_AUX_CLIP_CLEAR 0x20000000 +#define GMC_DST_CLR_CMP_FCN_CLEAR 0x10000000 +#define GMC_WRITE_MASK_SET 0x40000000 +#define GMC_DP_CONVERSION_TEMP_6500 0x00000000 + +/* DP_GUI_MASTER_CNTL ROP3 named constants */ +#define ROP3_PATCOPY 0x00f00000 +#define ROP3_SRCCOPY 0x00cc0000 + +#define SRC_DSTCOLOR 0x00030000 + +/* DP_CNTL bit constants */ +#define DST_X_RIGHT_TO_LEFT 0x00000000 +#define DST_X_LEFT_TO_RIGHT 0x00000001 +#define DST_Y_BOTTOM_TO_TOP 0x00000000 +#define DST_Y_TOP_TO_BOTTOM 0x00000002 +#define DST_X_MAJOR 0x00000000 +#define DST_Y_MAJOR 0x00000004 +#define DST_X_TILE 0x00000008 +#define DST_Y_TILE 0x00000010 +#define DST_LAST_PEL 0x00000020 +#define DST_TRAIL_X_RIGHT_TO_LEFT 0x00000000 +#define DST_TRAIL_X_LEFT_TO_RIGHT 0x00000040 +#define DST_TRAP_FILL_RIGHT_TO_LEFT 0x00000000 +#define DST_TRAP_FILL_LEFT_TO_RIGHT 0x00000080 +#define DST_BRES_SIGN 0x00000100 +#define DST_HOST_BIG_ENDIAN_EN 0x00000200 +#define DST_POLYLINE_NONLAST 0x00008000 +#define DST_RASTER_STALL 0x00010000 +#define DST_POLY_EDGE 0x00040000 + +/* DP_MIX bit constants */ +#define DP_SRC_RECT 0x00000200 +#define DP_SRC_HOST 0x00000300 +#define DP_SRC_HOST_BYTEALIGN 0x00000400 + +/* LVDS_GEN_CNTL constants */ +#define LVDS_BL_MOD_LEVEL_MASK 0x0000ff00 +#define LVDS_BL_MOD_LEVEL_SHIFT 0x8 +#define LVDS_BL_MOD_EN 0x00010000 +#define LVDS_DIGION 0x00040000 +#define LVDS_BLON 0x00080000 + + +/* from the ati128ddk */ + +#define FOG_3D_TABLE_START 0x1810 +#define FOG_3D_TABLE_END 0x1814 +#define FOG_3D_TABLE_DENSITY 0x181c + +#define FOG_TABLE_INDEX 0x1a14 +#define FOG_TABLE_DATA 0x1a18 + +/* MISC_3D_STATE */ +#define MISC_3D_STATE_SCALE_3D_FN_NOP (0x00000000 << 8) +#define MISC_3D_STATE_SCALE_3D_FN_SCALE (0x00000001 << 8) +#define MISC_3D_STATE_SCALE_3D_FN_TMAP_SHADE (0x00000002 << 8) +#define MISC_3D_STATE_SCALE_PIX_REP_BLEND (0x00000000 << 10) +#define MISC_3D_STATE_SCALE_PIX_REP_REPLICATE (0x00000001 << 10) +#define MISC_3D_STATE_ALPHA_COMB_FNC_ADD_CLAMP (0x00000000 << 12) +#define MISC_3D_STATE_ALPHA_COMB_FNC_ADD_NO_CLAMP (0x00000001 << 12) +#define MISC_3D_STATE_ALPHA_COMB_FNC_SUB_SRC_DST_CLAMP (0x00000002 << 12) +#define MISC_3D_STATE_ALPHA_COMB_FNC_SUB_SRC_DST_NO_CLAMP (0x00000003 << 12) +#define MISC_3D_STATE_FOG_TABLE_EN_VERTEX_FOG (0x00000000 << 14) +#define MISC_3D_STATE_FOG_TABLE_EN_TABLE_FOG (0x00000001 << 14) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_ZERO (0x00000000 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_ONE (0x00000001 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_SRCCOLOR (0x00000002 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_INVSRCCOLOR (0x00000003 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_SRCALPHA (0x00000004 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_INVSRCALPHA (0x00000005 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_DESTALPHA (0x00000006 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_INVDESTALPHA (0x00000007 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_DESTCOLOR (0x00000008 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_INVDESTCOLOR (0x00000009 << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_SRCALPHASAT (0x0000000a << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_BOTHSRCALPHA (0x0000000b << 16) +#define MISC_3D_STATE_ALPHA_BLEND_SRC_BOTHINVSRCALPHA (0x0000000c << 16) +#define MISC_3D_STATE_ALPHA_BLEND_DST_ZERO (0x00000000 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_ONE (0x00000001 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_SRCCOLOR (0x00000002 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_INVSRCCOLOR (0x00000003 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_SRCALPHA (0x00000004 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_INVSRCALPHA (0x00000005 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_DESTALPHA (0x00000006 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_INVDESTALPHA (0x00000007 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_DESTCOLOR (0x00000008 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_INVDESTCOLOR (0x00000009 << 20) +#define MISC_3D_STATE_ALPHA_BLEND_DST_SRCALPHASAT (0x0000000a << 20) +#define MISC_3D_STATE_ALPHA_TEST_OP_NEVER (0x00000000 << 24) +#define MISC_3D_STATE_ALPHA_TEST_OP_LESS (0x00000001 << 24) +#define MISC_3D_STATE_ALPHA_TEST_OP_LESSEQUAL (0x00000002 << 24) +#define MISC_3D_STATE_ALPHA_TEST_OP_EQUAL (0x00000003 << 24) +#define MISC_3D_STATE_ALPHA_TEST_OP_GREATEREQUAL (0x00000004 << 24) +#define MISC_3D_STATE_ALPHA_TEST_OP_GREATER (0x00000005 << 24) +#define MISC_3D_STATE_ALPHA_TEST_OP_NEQUAL (0x00000006 << 24) +#define MISC_3D_STATE_ALPHA_TEST_OP_ALWAYS (0x00000007 << 24) + + + +/* Z_STEN_CNTL */ +#define Z_STEN_CNTL_Z_PIX_WIDTH_16 (0x00000000 << 1) +#define Z_STEN_CNTL_Z_PIX_WIDTH_24 (0x00000001 << 1) +#define Z_STEN_CNTL_Z_PIX_WIDTH_32 (0x00000002 << 1) +#define Z_STEN_CNTL_Z_TEST_NEVER (0x00000000 << 4) +#define Z_STEN_CNTL_Z_TEST_LESS (0x00000001 << 4) +#define Z_STEN_CNTL_Z_TEST_LESSEQUAL (0x00000002 << 4) +#define Z_STEN_CNTL_Z_TEST_EQUAL (0x00000003 << 4) +#define Z_STEN_CNTL_Z_TEST_GREATEREQUAL (0x00000004 << 4) +#define Z_STEN_CNTL_Z_TEST_GREATER (0x00000005 << 4) +#define Z_STEN_CNTL_Z_TEST_NEQUAL (0x00000006 << 4) +#define Z_STEN_CNTL_Z_TEST_ALWAYS (0x00000007 << 4) +#define Z_STEN_CNTL_STENCIL_TEST_NEVER (0x00000000 << 12) +#define Z_STEN_CNTL_STENCIL_TEST_LESS (0x00000001 << 12) +#define Z_STEN_CNTL_STENCIL_TEST_LESSEQUAL (0x00000002 << 12) +#define Z_STEN_CNTL_STENCIL_TEST_EQUAL (0x00000003 << 12) +#define Z_STEN_CNTL_STENCIL_TEST_GREATEREQUAL (0x00000004 << 12) +#define Z_STEN_CNTL_STENCIL_TEST_GREATER (0x00000005 << 12) +#define Z_STEN_CNTL_STENCIL_TEST_NEQUAL (0x00000006 << 12) +#define Z_STEN_CNTL_STENCIL_TEST_ALWAYS (0x00000007 << 12) +#define Z_STEN_CNTL_STENCIL_S_FAIL_OP_KEEP (0x00000000 << 16) +#define Z_STEN_CNTL_STENCIL_S_FAIL_OP_ZERO (0x00000001 << 16) +#define Z_STEN_CNTL_STENCIL_S_FAIL_OP_REPLACE (0x00000002 << 16) +#define Z_STEN_CNTL_STENCIL_S_FAIL_OP_INC (0x00000003 << 16) +#define Z_STEN_CNTL_STENCIL_S_FAIL_OP_DEC (0x00000004 << 16) +#define Z_STEN_CNTL_STENCIL_S_FAIL_OP_INV (0x00000005 << 16) +#define Z_STEN_CNTL_STENCIL_ZPASS_OP_KEEP (0x00000000 << 20) +#define Z_STEN_CNTL_STENCIL_ZPASS_OP_ZERO (0x00000001 << 20) +#define Z_STEN_CNTL_STENCIL_ZPASS_OP_REPLACE (0x00000002 << 20) +#define Z_STEN_CNTL_STENCIL_ZPASS_OP_INC (0x00000003 << 20) +#define Z_STEN_CNTL_STENCIL_ZPASS_OP_DEC (0x00000004 << 20) +#define Z_STEN_CNTL_STENCIL_ZPASS_OP_INV (0x00000005 << 20) +#define Z_STEN_CNTL_STENCIL_ZFAIL_OP_KEEP (0x00000000 << 24) +#define Z_STEN_CNTL_STENCIL_ZFAIL_OP_ZERO (0x00000001 << 24) +#define Z_STEN_CNTL_STENCIL_ZFAIL_OP_REPLACE (0x00000002 << 24) +#define Z_STEN_CNTL_STENCIL_ZFAIL_OP_INC (0x00000003 << 24) +#define Z_STEN_CNTL_STENCIL_ZFAIL_OP_DEC (0x00000004 << 24) +#define Z_STEN_CNTL_STENCIL_ZFAIL_OP_INV (0x00000005 << 24) + +/* TEX_CNTL */ +#define TEX_CNTL_Z_EN_OFF (0x00000000 << 0) +#define TEX_CNTL_Z_EN_ON (0x00000001 << 0) +#define TEX_CNTL_Z_MASK_DIS (0x00000000 << 1) +#define TEX_CNTL_Z_MASK_EN (0x00000001 << 1) +#define TEX_CNTL_STENCIL_EN_OFF (0x00000000 << 3) +#define TEX_CNTL_STENCIL_EN_ON (0x00000001 << 3) +#define TEX_CNTL_TEX_EN_SHADE (0x00000000 << 4) +#define TEX_CNTL_TEX_EN_TMAP (0x00000001 << 4) +#define TEX_CNTL_SECONDARY_TEX_EN_OFF (0x00000000 << 5) +#define TEX_CNTL_SECONDARY_TEX_EN_ON (0x00000001 << 5) +#define TEX_CNTL_FOG_EN_OFF (0x00000000 << 7) +#define TEX_CNTL_FOG_EN_ON (0x00000001 << 7) +#define TEX_CNTL_DITHRE_EN_OFF (0x00000000 << 8) +#define TEX_CNTL_DITHRE_EN_ON (0x00000001 << 8) +#define TEX_CNTL_ALPHA_EN_OFF (0x00000000 << 9) +#define TEX_CNTL_ALPHA_EN_ON (0x00000001 << 9) +#define TEX_CNTL_ALPHA_TEST_EN_OFF (0x00000000 << 10) +#define TEX_CNTL_ALPHA_TEST_EN_ON (0x00000001 << 10) +#define TEX_CNTL_SPEC_LIGHT_EN_OFF (0x00000000 << 11) +#define TEX_CNTL_SPEC_LIGHT_EN_ON (0x00000001 << 11) +#define TEX_CNTL_TEX_CHROMA_KEY_EN_OFF (0x00000000 << 12) +#define TEX_CNTL_TEX_CHROMA_KEY_EN_ON (0x00000001 << 12) +#define TEX_CNTL_AMASK_EN_OFF (0x00000000 << 13) +#define TEX_CNTL_AMASK_EN_ON (0x00000001 << 13) +#define TEX_CNTL_LIGHT_FN_DIS (0x00000000 << 14) +#define TEX_CNTL_LIGHT_FN_COPY (0x00000001 << 14) +#define TEX_CNTL_LIGHT_FN_MODULATE (0x00000002 << 14) +#define TEX_CNTL_LIGHT_FN_ADD (0x00000003 << 14) +#define TEX_CNTL_LIGHT_FN_BLEND_CONSTANT (0x00000004 << 14) +#define TEX_CNTL_LIGHT_FN_BLEND_TEXTURE (0x00000005 << 14) +#define TEX_CNTL_LIGHT_FN_BLEND_VERTEX (0x00000006 << 14) +#define TEX_CNTL_LIGHT_FN_BLEND_CONST_COLOR (0x00000007 << 14) +#define TEX_CNTL_ALPHA_LIGHT_FN_DIS (0x00000000 << 18) +#define TEX_CNTL_ALPHA_LIGHT_FN_COPY (0x00000001 << 18) +#define TEX_CNTL_ALPHA_LIGHT_FN_MODULATE (0x00000002 << 18) +#define TEX_CNTL_ALPHA_LIGHT_FN_ADD (0x00000003 << 18) +//#define TEX_CNTL_ANTI_ALIAS_FN +#define TEX_CNTL_TEX_CACHE_FLUSH_OFF (0x00000000 << 23) +#define TEX_CNTL_TEX_CACHE_FLUSH_ON (0x00000001 << 23) +//#define TEX_CNTL_LOD_BIAS + + +/* PRIM_TEX_CNTL */ +#define PRIM_TEX_CNTL_PRIM_MIN_BLEND_FN_NEAREST (0x00000000 << 0) +#define PRIM_TEX_CNTL_PRIM_MIN_BLEND_FN_LINEAR (0x00000001 << 0) +#define PRIM_TEX_CNTL_PRIM_MIN_BLEND_FN_MIPNEAREST (0x00000002 << 0) +#define PRIM_TEX_CNTL_PRIM_MIN_BLEND_FN_MIPLINEAR (0x00000003 << 0) +#define PRIM_TEX_CNTL_PRIM_MIN_BLEND_FN_LINEARMIPNEAREST (0x00000004 << 0) +#define PRIM_TEX_CNTL_PRIM_MIN_BLEND_FN_LINEARMIPLINEAR (0x00000005 << 0) +#define PRIM_TEX_CNTL_PRIM_MAG_BLEND_FN_NEAREST (0x00000000 << 4) +#define PRIM_TEX_CNTL_PRIM_MAG_BLEND_FN_LINEAR (0x00000001 << 4) +#define PRIM_TEX_CNTL_MIP_MAP_DIS_OFF (0x00000000 << 7) +#define PRIM_TEX_CNTL_MIP_MAP_DIS_ON (0x00000001 << 7) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_S_WRAP (0x00000000 << 8) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_S_MIRROR (0x00000001 << 8) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_S_CLAMP (0x00000002 << 8) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_S_BORDER_COLOR (0x00000003 << 8) +#define PRIM_TEX_CNTL_PRIM_TEX_WRAP_S_OFF (0x00000000 << 10) +#define PRIM_TEX_CNTL_PRIM_TEX_WRAP_S_ON (0x00000001 << 10) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_T_WRAP (0x00000000 << 11) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_T_MIRROR (0x00000001 << 11) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_T_CLAMP (0x00000002 << 11) +#define PRIM_TEX_CNTL_PRIM_TEX_CLAMP_MODE_T_BORDER_COLOR (0x00000003 << 11) +#define PRIM_TEX_CNTL_PRIM_TEX_WRAP_T_OFF (0x00000000 << 13) +#define PRIM_TEX_CNTL_PRIM_TEX_WRAP_T_ON (0x00000001 << 13) +#define PRIM_TEX_CNTL_PRIM_TEX_PERSPECTIVE_DIS_OFF (0x00000000 << 14) +#define PRIM_TEX_CNTL_PRIM_TEX_PERSPECTIVE_DIS_ON (0x00000001 << 14) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_VQ (0x00000000 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_CI4 (0x00000001 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_CI8 (0x00000002 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_ARGB1555 (0x00000003 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_RGB565 (0x00000004 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_RGB888 (0x00000005 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_ARGB8888 (0x00000006 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_RGB332 (0x00000007 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_Y8 (0x00000008 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_RGB8 (0x00000009 << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_CI16 (0x0000000a << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_YUV422 (0x0000000b << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_YUV422_2 (0x0000000c << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_AYUV444 (0x0000000d << 16) +#define PRIM_TEX_CNTL_PRIM_DATATYPE_ARGB4444 (0x0000000e << 16) +//#define PRIM_TEX_CNTL_PRIM_PALETTE_OFF_ +//#define PRIM_TEX_CNTL_PRIM_PSEUDOCOLOR_DATATYPE_ + + +/* SETP_CNTL */ +#define SETUP_CNTL_DONT_START_TRI_OFF (0x00000000 << 0) +#define SETUP_CNTL_DONT_START_TRI_ON (0x00000001 << 0) +#define SETUP_CNTL_Z_BIAS (0x00000000 << 1) +#define SETUP_CNTL_DONT_START_ANY_OFF (0x00000000 << 2) +#define SETUP_CNTL_DONT_START_ANY_ON (0x00000001 << 2) +#define SETUP_CNTL_COLOR_FNC_SOLID_COLOR (0x00000000 << 3) +#define SETUP_CNTL_COLOR_FNC_FLAT_VERT_1 (0x00000001 << 3) +#define SETUP_CNTL_COLOR_FNC_FLAT_VERT_2 (0x00000002 << 3) +#define SETUP_CNTL_COLOR_FNC_FLAT_VERT_3 (0x00000003 << 3) +#define SETUP_CNTL_COLOR_FNC_GOURAUD (0x00000004 << 3) +#define SETUP_CNTL_PRIM_TYPE_SELECT_TRI (0x00000000 << 7) +#define SETUP_CNTL_PRIM_TYPE_SELECT_LINE (0x00000001 << 7) +#define SETUP_CNTL_PRIM_TYPE_SELECT_POINT (0x00000002 << 7) +#define SETUP_CNTL_PRIM_TYPE_SELECT_POLY_EDGE (0x00000003 << 7) +#define SETUP_CNTL_TEXTURE_ST_FORMAT_MULT_W (0x00000000 << 9) +#define SETUP_CNTL_TEXTURE_ST_FORMAT_DIRECT (0x00000001 << 9) +#define SETUP_CNTL_STARTING_VERTEX_SELECT_1 (0x00000001 << 14) +#define SETUP_CNTL_STARTING_VERTEX_SELECT_2 (0x00000002 << 14) +#define SETUP_CNTL_STARTING_VERTEX_SELECT_3 (0x00000003 << 14) +#define SETUP_CNTL_ENDING_VERTEX_SELECT_1 (0x00000001 << 16) +#define SETUP_CNTL_ENDING_VERTEX_SELECT_2 (0x00000002 << 16) +#define SETUP_CNTL_ENDING_VERTEX_SELECT_3 (0x00000003 << 16) +#define SETUP_CNTL_SU_POLY_LINE_LAST (0x00000000 << 18) +#define SETUP_CNTL_SU_POLY_LINE_NOT_LAST (0x00000001 << 18) +#define SETUP_CNTL_SUB_PIX_AMOUNT_2BITS (0x00000000 << 19) +#define SETUP_CNTL_SUB_PIX_AMOUNT_4BITS (0x00000001 << 19) +//#define SETUP_CNTL_SU_POLY_EDGE +//#define SETUP_CNTL_SU_EDGE_DST_Y_MAJOR +//#define SETUP_CNTL_SU_STATE +#define SETUP_CNTL_SET_UP_CONTINUE (0x00000001 << 31) + +/* PM4_VC_FPU_SETUP */ +#define PM4_VC_FPU_SETUP_FRONT_DIR_CW (0x00000000 << 0) +#define PM4_VC_FPU_SETUP_FRONT_DIR_CCW (0x00000001 << 0) +#define PM4_VC_FPU_SETUP_BACKFACE_CULLING_FN_CULL (0x00000000 << 1) +#define PM4_VC_FPU_SETUP_BACKFACE_CULLING_FN_POINT (0x00000001 << 1) +#define PM4_VC_FPU_SETUP_BACKFACE_CULLING_FN_LINE (0x00000002 << 1) +#define PM4_VC_FPU_SETUP_BACKFACE_CULLING_FN_REV_SOLID (0x00000003 << 1) +#define PM4_VC_FPU_SETUP_FRONTFACE_CULLING_FN_CULL (0x00000000 << 3) +#define PM4_VC_FPU_SETUP_FRONTFACE_CULLING_FN_POINT (0x00000001 << 3) +#define PM4_VC_FPU_SETUP_FRONTFACE_CULLING_FN_LINE (0x00000002 << 3) +#define PM4_VC_FPU_SETUP_FRONTFACE_CULLING_FN_REV_SOLID (0x00000003 << 3) +#define PM4_VC_FPU_SETUP_PM4_COLOR_FCN_SOLID (0x00000000 << 5) +#define PM4_VC_FPU_SETUP_PM4_COLOR_FCN_FLAT (0x00000001 << 5) +#define PM4_VC_FPU_SETUP_PM4_COLOR_FCN_GOURAUD (0x00000002 << 5) +#define PM4_VC_FPU_SETUP_PM4_COLOR_FCN_GOURAUD2 (0x00000003 << 5) +#define PM4_VC_FPU_SETUP_PM4_SUB_PIX_AMOUNT_2BITS (0x00000000 << 7) +#define PM4_VC_FPU_SETUP_PM4_SUB_PIX_AMOUNT_4BITS (0x00000001 << 7) +#define PM4_VC_FPU_SETUP_FPU_MODE_2D (0x00000000 << 8) +#define PM4_VC_FPU_SETUP_FPU_MODE_3D (0x00000001 << 8) +#define PM4_VC_FPU_SETUP_TRAP_DISABLE_OFF (0x00000000 << 9) +#define PM4_VC_FPU_SETUP_TRAP_DISABLE_ON (0x00000001 << 9) +#define PM4_VC_FPU_SETUP_EDGE_ANTIALIAS_OFF (0x00000000 << 10) +#define PM4_VC_FPU_SETUP_EDGE_ANTIALIAS_ON (0x00000001 << 10) +#define PM4_VC_FPU_SETUP_SUPERSAMPLE_OFF (0x00000000 << 11) +#define PM4_VC_FPU_SETUP_SUPERSAMPLE_ON (0x00000001 << 11) +#define PM4_VC_FPU_SETUP_XFACTOR_2 (0x00000000 << 12) +#define PM4_VC_FPU_SETUP_XFACTOR_4 (0x00000001 << 12) +#define PM4_VC_FPU_SETUP_YFACTOR_2 (0x00000000 << 13) +#define PM4_VC_FPU_SETUP_YFACTOR_4 (0x00000001 << 13) +#define PM4_VC_FPU_SETUP_FLAT_SHADE_VERTEX_D3D (0x00000000 << 14) +#define PM4_VC_FPU_SETUP_FLAT_SHADE_VERTEX_OPENGL (0x00000001 << 14) +#define PM4_VC_FPU_SETUP_FPU_ROUND_EN_OFF (0x00000000 << 15) +#define PM4_VC_FPU_SETUP_FPU_ROUND_EN_ON (0x00000001 << 15) +#define PM4_VC_FPU_SETUP_VC_WM_SEL_8DW (0x00000000 << 16) +#define PM4_VC_FPU_SETUP_VC_WM_SEL_16DW (0x00000001 << 16) +#define PM4_VC_FPU_SETUP_VC_WM_SEL_32DW (0x00000002 << 16) + +/* SEC_TEX_CNTL */ +#define SEC_TEX_CNTL_SEC_SRC_SEL_ST_0 (0x00000000 << 0) +#define SEC_TEX_CNTL_SEC_SRC_SEL_ST_1 (0x00000001 << 0) + +/* [PRIM_ | SEC_] SEC_TEX_COMBINE_CNTL */ +#define TEX_COMBINE_CNTL_COMB_FNC_DIS (0x00000000 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_COPY (0x00000001 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_COPY_INP (0x00000002 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_MODULATE (0x00000003 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_MODULATE2X (0x00000004 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_MODULATE4X (0x00000005 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_ADD (0x00000006 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_ADD_SIGNED (0x00000007 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_BLEND_VERTEX (0x00000008 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_BLEND_TEXTURE (0x00000009 << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_BLEND_CONST (0x0000000a << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_BLEND_PREMULT (0x0000000b << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_BLEND_PREV (0x0000000c << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_BLEND_PREMULT_INV (0x0000000d << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_ADD_SIGNED2X (0x0000000e << 0) +#define TEX_COMBINE_CNTL_COMB_FNC_BLEND_CONST_COLOR (0x0000000f << 0) +#define TEX_COMBINE_CNTL_COLOR_FACTOR_TEX (0x00000004 << 4) +#define TEX_COMBINE_CNTL_COLOR_FACTOR_NTEX (0x00000005 << 4) +#define TEX_COMBINE_CNTL_COLOR_FACTOR_ALPHA (0x00000006 << 4) +#define TEX_COMBINE_CNTL_COLOR_FACTOR_NALPHA (0x00000007 << 4) +#define TEX_COMBINE_CNTL_INPUT_FACTOR_CONST_COLOR (0x00000002 << 10) +#define TEX_COMBINE_CNTL_INPUT_FACTOR_CONST_ALPHA (0x00000003 << 10) +#define TEX_COMBINE_CNTL_INPUT_FACTOR_INT_COLOR (0x00000004 << 10) +#define TEX_COMBINE_CNTL_INPUT_FACTOR_INT_ALPHA (0x00000005 << 10) +#define TEX_COMBINE_CNTL_INPUT_FACTOR_PREV_COLOR (0x00000008 << 10) +#define TEX_COMBINE_CNTL_INPUT_FACTOR_PREV_ALPHA (0x00000009 << 10) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_DIS (0x00000000 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_COPY (0x00000001 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_COPY_INP (0x00000002 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_MODULATE (0x00000003 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_MODULATE2X (0x00000004 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_MODULATE4X (0x00000005 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_ADD (0x00000006 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_ADD_SIGNED (0x00000007 << 14) +#define TEX_COMBINE_CNTL_COMB_FNC_ALPHA_ADD_SIGNED2X (0x0000000e << 14) +#define TEX_COMBINE_CNTL_ALPHA_FACTOR_TEX_ALPHA (0x00000006 << 18) +#define TEX_COMBINE_CNTL_ALPHA_FACTOR_NTEX_ALPHA (0x00000007 << 18) +#define TEX_COMBINE_CNTL_INP_FACTOR_ALPHA_CONST_ALPHA (0x00000001 << 25) +#define TEX_COMBINE_CNTL_INP_FACTOR_ALPHA_INT_ALPHA (0x00000002 << 25) +#define TEX_COMBINE_CNTL_INP_FACTOR_ALPHA_PREV_ALPHA (0x00000004 << 25) + + +/* SCALE_3D_CNTL */ +#define SCALE_3D_CNTL_SCALE_DITHER_ERR_DIFF (0x00000000 << 1) +#define SCALE_3D_CNTL_SCALE_DITHER_TABLE (0x00000001 << 1) +#define SCALE_3D_CNTL_TEX_CACHE_SIZE_FULL (0x00000000 << 2) +#define SCALE_3D_CNTL_TEX_CACHE_SIZE_HALF (0x00000001 << 2) +#define SCALE_3D_CNTL_DITHER_INIT_CURR (0x00000000 << 3) +#define SCALE_3D_CNTL_DITHER_INIT_RESET (0x00000001 << 3) +#define SCALE_3D_CNTL_ROUND_EN_OFF (0x00000000 << 4) +#define SCALE_3D_CNTL_ROUND_EN_ON (0x00000001 << 4) +#define SCALE_3D_CNTL_TEX_CACHE_DIS_OFF (0x00000000 << 5) +#define SCALE_3D_CNTL_TEX_CACHE_DIS_ON (0x00000001 << 5) +#define SCALE_3D_CNTL_SCALE_3D_FN_NONE (0x00000000 << 6) +#define SCALE_3D_CNTL_SCALE_3D_FN_SCALE (0x00000001 << 6) +#define SCALE_3D_CNTL_SCALE_3D_FN_TMAP_SHADE (0x00000002 << 6) +#define SCALE_3D_CNTL_SCALE_PIX_REP_BLEND (0x00000000 << 8) +#define SCALE_3D_CNTL_SCALE_PIX_REP_REP (0x00000001 << 8) +#define SCALE_3D_CNTL_TEX_CACHE_SPLIT_OFF (0x00000000 << 9) +#define SCALE_3D_CNTL_TEX_CACHE_SPLIT_ON (0x00000001 << 9) +#define SCALE_3D_CNTL_APPLE_YUV_MODE_OFF (0x00000000 << 10) +#define SCALE_3D_CNTL_APPLE_YUV_MODE_ON (0x00000001 << 10) +#define SCALE_3D_CNTL_TEX_CACHE_PAL_MODE_OFF (0x00000000 << 11) +#define SCALE_3D_CNTL_TEX_CACHE_PAL_MODE_ON (0x00000001 << 11) +#define SCALE_3D_CNTL_ALPHA_COMB_FNC_ADD_CLAMP (0x00000000 << 12) +#define SCALE_3D_CNTL_ALPHA_COMB_FNC_ADD_NCLAMP (0x00000001 << 12) +#define SCALE_3D_CNTL_ALPHA_COMB_FNC_SUB_DST_SRC_CLAMP (0x00000002 << 12) +#define SCALE_3D_CNTL_ALPHA_COMB_FNC_SUB_DST_SRC_NCLAMP (0x00000003 << 12) +#define SCALE_3D_CNTL_FOG_TABLE_EN_OFF (0x00000000 << 14) +#define SCALE_3D_CNTL_FOG_TABLE_EN_ON (0x00000001 << 14) +#define SCALE_3D_CNTL_SIGNED_DST_CLAMP_OFF (0x00000000 << 15) +#define SCALE_3D_CNTL_SIGNED_DST_CLAMP_ON (0x00000001 << 15) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_ZERO (0x00000000 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_ONE (0x00000001 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_SRCCOLOR (0x00000002 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVSRCCOLOR (0x00000003 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_SRCALPHA (0x00000004 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVSRCALPHA (0x00000005 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_DSTALPHA (0x00000006 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVDSTALPHA (0x00000007 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_DSTCOLOR (0x00000008 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVDSTCOLOR (0x00000009 << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_SAT (0x0000000a << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_BLEND (0x0000000b << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVBLEND (0x0000000c << 16) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_ZERO (0x00000000 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_ONE (0x00000001 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_SRCCOLOR (0x00000002 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_INVSRCCOLOR (0x00000003 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_SRCALPHA (0x00000004 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_INVSRCALPHA (0x00000005 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_DSTALPHA (0x00000006 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_INVDSTALPHA (0x00000007 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_DSTCOLOR (0x00000008 << 20) +#define SCALE_3D_CNTL_ALPHA_BLEND_DST_INVDSTCOLOR (0x00000009 << 20) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_NEVER (0x00000000 << 24) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_LESS (0x00000001 << 24) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_LESSEQUAL (0x00000002 << 24) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_EQUAL (0x00000003 << 24) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_GREATEREQUAL (0x00000004 << 24) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_GREATER (0x00000005 << 24) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_NEQUAL (0x00000006 << 24) +#define SCALE_3D_CNTL_ALPHA_TEST_OP_ALWAYS (0x00000007 << 24) +#define SCALE_3D_CNTL_COMPOSITE_SHADOW_CMP_EQUAL (0x00000000 << 28) +#define SCALE_3D_CNTL_COMPOSITE_SHADOW_CMP_NEQUAL (0x00000001 << 28) +#define SCALE_3D_CNTL_COMPOSITE_SHADOW_EN_OFF (0x00000000 << 29) +#define SCALE_3D_CNTL_COMPOSITE_SHADOW_EN_ON (0x00000001 << 29) +#define SCALE_3D_CNTL_TEX_MAP_AEN_OFF (0x00000000 << 30) +#define SCALE_3D_CNTL_TEX_MAP_AEN_ON (0x00000001 << 30) +#define SCALE_3D_CNTL_TEX_CACHE_LINE_SIZE_8QW (0x00000000 << 31) +#define SCALE_3D_CNTL_TEX_CACHE_LINE_SIZE_4QW (0x00000001 << 31) + + + + +#define SCALE_3D_DATATYPE 0x1a20 +#define SETUP_CNTL 0x1bc4 +#define SOLID_COLOR 0x1bc8 +#define WINDOW_XY_OFFSET 0x1bcc +#define DRAW_LINE_POINT 0x1bd0 +#define SETUP_CNTL_PM4 0x1bd4 +#define DST_PITCH_OFFSET_C 0x1c80 +#define DP_GUI_MASTER_CNTL_C 0x1c84 +#define SC_TOP_LEFT_C 0x1c88 +#define SC_BOTTOM_RIGHT_C 0x1c8c + +#define Z_OFFSET_C 0x1c90 +#define Z_PITCH_C 0x1c94 +#define Z_STEN_CNTL_C 0x1c98 +#define TEX_CNTL_C 0x1c9c +#define TEXTURE_CLR_CMP_CLR_C 0x1CA4 +#define TEXTURE_CLR_CMP_MSK_C 0x1CA8 +#define FOG_COLOR_C 0x1CAC +#define PRIM_TEX_CNTL_C 0x1CB0 +#define PRIM_TEX_COMBINE_CNTL_C 0x1CB4 +#define TEX_SIZE_PITCH_C 0x1CB8 +#define PRIM_TEX_0_OFFSET_C 0x1CBC +#define PRIM_TEX_1_OFFSET_C 0x1CC0 +#define PRIM_TEX_2_OFFSET_C 0x1CC4 +#define PRIM_TEX_3_OFFSET_C 0x1CC8 +#define PRIM_TEX_4_OFFSET_C 0x1CCC +#define PRIM_TEX_5_OFFSET_C 0x1CD0 +#define PRIM_TEX_6_OFFSET_C 0x1CD4 +#define PRIM_TEX_7_OFFSET_C 0x1CD8 +#define PRIM_TEX_8_OFFSET_C 0x1CDC +#define PRIM_TEX_9_OFFSET_C 0x1CE0 +#define PRIM_TEX_10_OFFSET_C 0x1CE4 +#define SEC_TEX_CNTL_C 0x1D00 +#define SEC_TEX_COMBINE_CNTL_C 0x1D04 +#define SEC_TEX_0_OFFSET_C 0x1D08 +#define SEC_TEX_1_OFFSET_C 0x1D0C +#define SEC_TEX_2_OFFSET_C 0x1D10 +#define SEC_TEX_3_OFFSET_C 0x1D14 +#define SEC_TEX_4_OFFSET_C 0x1D18 +#define SEC_TEX_5_OFFSET_C 0x1D1C +#define SEC_TEX_6_OFFSET_C 0x1D20 +#define SEC_TEX_7_OFFSET_C 0x1D24 +#define SEC_TEX_8_OFFSET_C 0x1D28 +#define SEC_TEX_9_OFFSET_C 0x1D2C +#define SEC_TEX_10_OFFSET_C 0x1D30 +#define CONSTANT_COLOR_C 0x1D34 +#define PRIM_TEXTURE_BORDER_COLOR_C 0x1D38 +#define SEC_TEXTURE_BORDER_COLOR_C 0x1D3C +#define STEN_REF_MASK_C 0x1D40 +#define PLANE_3D_MASK_C 0x1D44 + +#define CLR_CMP_MASK_3D 0x1A28 +#define MC_SRC1_CNTL 0x19D8 +#define TEX_CNTL 0x1800 +#define CLR_CMP_CLR_3D 0x1A24 + + +/* first overlay unit (there is only one) */ + +#define OV0_Y_X_START 0x0400 +#define OV0_Y_X_END 0x0404 +#define OV0_EXCLUSIVE_HORZ 0x0408 +# define R128_EXCL_HORZ_START_MASK 0x000000ff +# define R128_EXCL_HORZ_END_MASK 0x0000ff00 +# define R128_EXCL_HORZ_BACK_PORCH_MASK 0x00ff0000 +# define R128_EXCL_HORZ_EXCLUSIVE_EN 0x80000000 +#define OV0_EXCLUSIVE_VERT 0x040C +# define R128_EXCL_VERT_START_MASK 0x000003ff +# define R128_EXCL_VERT_END_MASK 0x03ff0000 +#define OV0_REG_LOAD_CNTL 0x0410 +# define R128_REG_LD_CTL_LOCK 0x00000001L +# define R128_REG_LD_CTL_VBLANK_DURING_LOCK 0x00000002L +# define R128_REG_LD_CTL_STALL_GUI_UNTIL_FLIP 0x00000004L +# define R128_REG_LD_CTL_LOCK_READBACK 0x00000008L +#define OV0_SCALE_CNTL 0x0420 +# define R128_SCALER_PIX_EXPAND 0x00000001L +# define R128_SCALER_Y2R_TEMP 0x00000002L +# define R128_SCALER_HORZ_PICK_NEAREST 0x00000003L +# define R128_SCALER_VERT_PICK_NEAREST 0x00000004L +# define R128_SCALER_SIGNED_UV 0x00000010L +# define R128_SCALER_GAMMA_SEL_MASK 0x00000060L +# define R128_SCALER_GAMMA_SEL_BRIGHT 0x00000000L +# define R128_SCALER_GAMMA_SEL_G22 0x00000020L +# define R128_SCALER_GAMMA_SEL_G18 0x00000040L +# define R128_SCALER_GAMMA_SEL_G14 0x00000060L +# define R128_SCALER_COMCORE_SHIFT_UP_ONE 0x00000080L +# define R128_SCALER_SURFAC_FORMAT 0x00000f00L +# define R128_SCALER_SOURCE_15BPP 0x00000300L +# define R128_SCALER_SOURCE_16BPP 0x00000400L +# define R128_SCALER_SOURCE_32BPP 0x00000600L +# define R128_SCALER_SOURCE_YUV9 0x00000900L +# define R128_SCALER_SOURCE_YUV12 0x00000A00L +# define R128_SCALER_SOURCE_VYUY422 0x00000B00L +# define R128_SCALER_SOURCE_YVYU422 0x00000C00L +# define R128_SCALER_SMART_SWITCH 0x00008000L +# define R128_SCALER_BURST_PER_PLANE 0x00ff0000L +# define R128_SCALER_DOUBLE_BUFFER 0x01000000L +# define R128_SCALER_DIS_LIMIT 0x08000000L +# define R128_SCALER_PRG_LOAD_START 0x10000000L +# define R128_SCALER_INT_EMU 0x20000000L +# define R128_SCALER_ENABLE 0x40000000L +# define R128_SCALER_SOFT_RESET 0x80000000L +#define OV0_V_INC 0x0424 +#define OV0_P1_V_ACCUM_INIT 0x0428 +# define OV0_P1_MAX_LN_IN_PER_LN_OUT 0x00000003L +# define OV0_P1_V_ACCUM_INIT_MASK 0x01ff8000L +#define OV0_P23_V_ACCUM_INIT 0x042C +#define OV0_P1_BLANK_LINES_AT_TOP 0x0430 +# define R128_P1_BLNK_LN_AT_TOP_M1_MASK 0x00000fffL +# define R128_P1_ACTIVE_LINES_M1 0x0fff0000L +#define OV0_P23_BLANK_LINES_AT_TOP 0x0434 +# define R128_P23_BLNK_LN_AT_TOP_M1_MASK 0x000007ffL +# define R128_P23_ACTIVE_LINES_M1 0x07ff0000L +#define OV0_VID_BUF0_BASE_ADRS 0x0440 +# define R128_VIF_BUF0_PITCH_SEL 0x00000001L +# define R128_VIF_BUF0_TILE_ADRS 0x00000002L +# define R128_VIF_BUF0_BASE_ADRS_MASK 0x03fffff0L +# define R128_VIF_BUF0_1ST_LINE_LSBS_MASK 0x48000000L +#define OV0_VID_BUF1_BASE_ADRS 0x0444 +# define R128_VIF_BUF1_PITCH_SEL 0x00000001L +# define R128_VIF_BUF1_TILE_ADRS 0x00000002L +# define R128_VIF_BUF1_BASE_ADRS_MASK 0x03fffff0L +# define R128_VIF_BUF1_1ST_LINE_LSBS_MASK 0x48000000L +#define OV0_VID_BUF2_BASE_ADRS 0x0448 +# define R128_VIF_BUF2_PITCH_SEL 0x00000001L +# define R128_VIF_BUF2_TILE_ADRS 0x00000002L +# define R128_VIF_BUF2_BASE_ADRS_MASK 0x03fffff0L +# define R128_VIF_BUF2_1ST_LINE_LSBS_MASK 0x48000000L +#define OV0_VID_BUF3_BASE_ADRS 0x044C +#define OV0_VID_BUF4_BASE_ADRS 0x0450 +#define OV0_VID_BUF5_BASE_ADRS 0x0454 +#define OV0_VID_BUF_PITCH0_VALUE 0x0460 +#define OV0_VID_BUF_PITCH1_VALUE 0x0464 +#define OV0_AUTO_FLIP_CNTL 0x0470 +#define OV0_DEINTERLACE_PATTERN 0x0474 +#define OV0_H_INC 0x0480 +#define OV0_STEP_BY 0x0484 +#define OV0_P1_H_ACCUM_INIT 0x0488 +#define OV0_P23_H_ACCUM_INIT 0x048C +#define OV0_P1_X_START_END 0x0494 +#define OV0_P2_X_START_END 0x0498 +#define OV0_P3_X_START_END 0x049C +#define OV0_FILTER_CNTL 0x04A0 +#define OV0_FOUR_TAP_COEF_0 0x04B0 +#define OV0_FOUR_TAP_COEF_1 0x04B4 +#define OV0_FOUR_TAP_COEF_2 0x04B8 +#define OV0_FOUR_TAP_COEF_3 0x04BC +#define OV0_FOUR_TAP_COEF_4 0x04C0 +#define OV0_COLOR_CNTL 0x04E0 +#define OV0_VIDEO_KEY_CLR 0x04E4 +#define OV0_VIDEO_KEY_MSK 0x04E8 +#define OV0_GRAPHICS_KEY_CLR 0x04EC +#define OV0_GRAPHICS_KEY_MSK 0x04F0 +#define OV0_KEY_CNTL 0x04F4 +# define R128_VIDEO_KEY_FN_MASK 0x00000007L +# define R128_VIDEO_KEY_FN_FALSE 0x00000000L +# define R128_VIDEO_KEY_FN_TRUE 0x00000001L +# define R128_VIDEO_KEY_FN_EQ 0x00000004L +# define R128_VIDEO_KEY_FN_NE 0x00000005L +# define R128_GRAPHIC_KEY_FN_MASK 0x00000070L +# define R128_GRAPHIC_KEY_FN_FALSE 0x00000000L +# define R128_GRAPHIC_KEY_FN_TRUE 0x00000010L +# define R128_GRAPHIC_KEY_FN_EQ 0x00000040L +# define R128_GRAPHIC_KEY_FN_NE 0x00000050L +# define R128_CMP_MIX_MASK 0x00000100L +# define R128_CMP_MIX_OR 0x00000000L +# define R128_CMP_MIX_AND 0x00000100L +#define OV0_TEST 0x04F8 + + +/* added by DirectFB programmers */ +#define CRTC_OFFSET_FLIP_CNTL 0x00010000 +#define MEM_ADDR_CONFIG 0x0148 + +#endif + |