summaryrefslogtreecommitdiffstats
path: root/tiler
diff options
context:
space:
mode:
Diffstat (limited to 'tiler')
-rw-r--r--tiler/.gitignore27
-rw-r--r--tiler/Android.mk33
-rw-r--r--tiler/Makefile.am80
-rw-r--r--tiler/README136
-rwxr-xr-xtiler/bootstrap.sh18
-rwxr-xr-xtiler/configure.ac75
-rw-r--r--tiler/debug_utils.h211
-rwxr-xr-xtiler/fill_utr.py92
-rw-r--r--tiler/libtimemmgr.pc.in13
-rw-r--r--tiler/list_utils.h511
-rw-r--r--tiler/mem_types.h101
-rw-r--r--tiler/memmgr.c1078
-rw-r--r--tiler/memmgr.h311
-rw-r--r--tiler/memmgr_test.c1693
-rw-r--r--tiler/testlib.c163
-rw-r--r--tiler/testlib.h101
-rw-r--r--tiler/tiler.h105
-rw-r--r--tiler/tiler_ptest.c729
-rw-r--r--tiler/tilermem.h79
-rw-r--r--tiler/tilermem_utils.h52
-rw-r--r--tiler/tilermgr.c203
-rw-r--r--tiler/tilermgr.h54
-rw-r--r--tiler/utils.h63
-rw-r--r--tiler/utils_test.c489
24 files changed, 6417 insertions, 0 deletions
diff --git a/tiler/.gitignore b/tiler/.gitignore
new file mode 100644
index 0000000..c23ec1a
--- /dev/null
+++ b/tiler/.gitignore
@@ -0,0 +1,27 @@
+aclocal.m4
+autom4te.cache
+Makefile.in
+Makefile
+ltmain.sh
+stamp-h1
+.deps
+.libs
+*.o
+*.lo
+*.la
+libtool
+*.pc
+config.log
+config.status
+config.guess
+config.h
+config.h.in
+config.sub
+config
+configure
+m4
+build
+*~
+tests/testlib.c
+*_test
+*_ptest \ No newline at end of file
diff --git a/tiler/Android.mk b/tiler/Android.mk
new file mode 100644
index 0000000..60c8699
--- /dev/null
+++ b/tiler/Android.mk
@@ -0,0 +1,33 @@
+# only include if running on an omap4 platform
+ifeq ($(TARGET_BOARD_PLATFORM),omap4)
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := memmgr.c tilermgr.c
+LOCAL_MODULE := libtimemmgr
+LOCAL_MODULE_TAGS := optional tests
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := memmgr_test.c testlib.c
+LOCAL_SHARED_LIBRARIES := libtimemmgr
+LOCAL_MODULE := memmgr_test
+LOCAL_MODULE_TAGS := tests
+include $(BUILD_HEAPTRACKED_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := utils_test.c testlib.c
+LOCAL_SHARED_LIBRARIES := libtimemmgr
+LOCAL_MODULE := utils_test
+LOCAL_MODULE_TAGS := tests
+include $(BUILD_HEAPTRCKED_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := tiler_ptest.c
+LOCAL_SHARED_LIBRARIES := libtimemmgr
+LOCAL_MODULE := tiler_ptest
+LOCAL_MODULE_TAGS:= tests
+include $(BUILD_HEAPTRACKED_EXECUTABLE)
+
+endif
diff --git a/tiler/Makefile.am b/tiler/Makefile.am
new file mode 100644
index 0000000..9f9e70b
--- /dev/null
+++ b/tiler/Makefile.am
@@ -0,0 +1,80 @@
+#
+# Makefile.am
+#
+# TI OMAP Processor Memory Allocator Interface functions makefile.
+#
+# Copyright (C) 2009-2011 Texas Instruments, Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Texas Instruments Incorporated nor the names of
+# its contributors may be used to endorse or promote products derived
+# from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+AUTOMAKE_OPTIONS = foreign
+
+## sources
+
+h_sources = memmgr.h tilermem.h mem_types.h tiler.h tilermem_utils.h
+if STUB_TILER
+c_sources = memmgr.c
+else
+c_sources = memmgr.c tilermgr.c
+endif
+
+if TILERMGR
+library_include_HEADERS = $(h_sources) tilermgr.h
+else
+library_include_HEADERS = $(h_sources)
+noinst_HEADERS = tilermgr.h
+endif
+
+#Install the headers in library directory - e.g. examplelib-1.0:
+library_includedir=$(includedir)/timemmgr
+
+# library sources
+lib_LTLIBRARIES= libtimemmgr.la
+libtimemmgr_la_SOURCES = $(h_sources) $(c_sources)
+libtimemmgr_la_CFLAGS = $(MEMMGR_CFLAGS) -fpic -ansi
+libtimemmgr_la_LIBTOOLFLAGS = --tag=disable-static
+libtimemmgr_la_LDFLAGS = -version-info 2:0:0
+
+if UNIT_TESTS
+bin_PROGRAMS = utils_test memmgr_test tiler_ptest
+
+utils_testdir = .
+utils_test_SOURCES = utils_test.c testlib.c
+
+memmgr_testdir = .
+memmgr_test_SOURCES = memmgr_test.c testlib.c
+memmgr_test_LDADD = libtimemmgr.la
+
+tiler_ptest_SOURCES = tiler_ptest.c
+tiler_ptest_LDADD = libtimemmgr.la
+endif
+
+pkgconfig_DATA = libtimemmgr.pc
+pkgconfigdir = $(libdir)/pkgconfig
+
diff --git a/tiler/README b/tiler/README
new file mode 100644
index 0000000..e531b09
--- /dev/null
+++ b/tiler/README
@@ -0,0 +1,136 @@
+Validating MemMgr
+
+ MemMgr tests are not persistently enumerated, so the test # in
+ memmgr test may vary from release to release.
+
+ You need to run the test with the "list" argument to list all the test
+ descriptions and the corresponding test numbers.
+
+ E.g. "memmgr_test list"
+
+ If you have access to the official test report, the details column lists
+ the test description (in the last line). Match the test case description
+ to the last line of the cells in the Details column.
+
+ Negative MemMgr tests run multiple test cases, so they map to multiple rows
+ in the official test report. Some of the test cases may not be available,
+ or may succeed even if the whole test failed/succeeded.
+
+ To ease the generation of the test report, a python script is provided that
+ will populate most of the test report:
+
+ run memmgr_test and pipe the output of the tests into a
+ file, e.g.:
+
+ memmgr_test > test.log
+
+ open UTR and select Tiler User Space worksheet
+ run this script by piping the test logs into the script, e.g. (you may
+ have to copy the log file from the target to a location that you can
+ access from the machine that has the UTR open.)
+
+ python fill_utr.py < test.log
+
+Latest List of test cases
+
+memmgr_test
+
+TEST # 1 - alloc_1D_test(4096, 0)
+TEST # 2 - alloc_2D_test(64, 64, PIXEL_FMT_8BIT)
+TEST # 3 - alloc_2D_test(64, 64, PIXEL_FMT_16BIT)
+TEST # 4 - alloc_2D_test(64, 64, PIXEL_FMT_32BIT)
+TEST # 5 - alloc_NV12_test(64, 64)
+TEST # 6 - map_1D_test(4096, 0)
+TEST # 7 - alloc_1D_test(176 * 144 * 2, 512)
+TEST # 8 - alloc_2D_test(176, 144, PIXEL_FMT_8BIT)
+TEST # 9 - alloc_2D_test(176, 144, PIXEL_FMT_16BIT)
+TEST # 10 - alloc_2D_test(176, 144, PIXEL_FMT_32BIT)
+TEST # 11 - alloc_NV12_test(176, 144)
+TEST # 12 - map_1D_test(176 * 144 * 2, 2048)
+TEST # 13 - alloc_1D_test(640 * 480 * 2, 0)
+TEST # 14 - alloc_2D_test(640, 480, PIXEL_FMT_8BIT)
+TEST # 15 - alloc_2D_test(640, 480, PIXEL_FMT_16BIT)
+TEST # 16 - alloc_2D_test(640, 480, PIXEL_FMT_32BIT)
+TEST # 17 - alloc_NV12_test(640, 480)
+TEST # 18 - map_1D_test(640 * 480 * 2, 0)
+TEST # 19 - alloc_1D_test(848 * 480 * 2, 0)
+TEST # 20 - alloc_2D_test(848, 480, PIXEL_FMT_8BIT)
+TEST # 21 - alloc_2D_test(848, 480, PIXEL_FMT_16BIT)
+TEST # 22 - alloc_2D_test(848, 480, PIXEL_FMT_32BIT)
+TEST # 23 - alloc_NV12_test(848, 480)
+TEST # 24 - map_1D_test(848 * 480 * 2, 0)
+TEST # 25 - alloc_1D_test(1280 * 720 * 2, 0)
+TEST # 26 - alloc_2D_test(1280, 720, PIXEL_FMT_8BIT)
+TEST # 27 - alloc_2D_test(1280, 720, PIXEL_FMT_16BIT)
+TEST # 28 - alloc_2D_test(1280, 720, PIXEL_FMT_32BIT)
+TEST # 29 - alloc_NV12_test(1280, 720)
+TEST # 30 - map_1D_test(1280 * 720 * 2, 0)
+TEST # 31 - alloc_1D_test(1920 * 1080 * 2, 0)
+TEST # 32 - alloc_2D_test(1920, 1080, PIXEL_FMT_8BIT)
+TEST # 33 - alloc_2D_test(1920, 1080, PIXEL_FMT_16BIT)
+TEST # 34 - alloc_2D_test(1920, 1080, PIXEL_FMT_32BIT)
+TEST # 35 - alloc_NV12_test(1920, 1080)
+TEST # 36 - map_1D_test(1920 * 1080 * 2, 0)
+TEST # 37 - neg_alloc_tests()
+TEST # 38 - neg_free_tests()
+TEST # 39 - neg_map_tests()
+TEST # 40 - neg_unmap_tests()
+TEST # 41 - neg_check_tests()
+TEST # 42 - page_size_test()
+TEST # 43 - maxalloc_2D_test(2500, 32, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 44 - maxalloc_2D_test(2500, 16, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 45 - maxalloc_2D_test(1250, 16, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 46 - maxalloc_2D_test(5000, 32, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 47 - maxalloc_2D_test(5000, 16, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 48 - maxalloc_2D_test(2500, 16, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 49 - alloc_2D_test(8193, 16, PIXEL_FMT_8BIT)
+TEST # 50 - alloc_2D_test(8193, 16, PIXEL_FMT_16BIT)
+TEST # 51 - alloc_2D_test(4097, 16, PIXEL_FMT_32BIT)
+TEST # 52 - alloc_2D_test(16384, 16, PIXEL_FMT_8BIT)
+TEST # 53 - alloc_2D_test(16384, 16, PIXEL_FMT_16BIT)
+TEST # 54 - alloc_2D_test(8192, 16, PIXEL_FMT_32BIT)
+TEST # 55 - !alloc_2D_test(16385, 16, PIXEL_FMT_8BIT)
+TEST # 56 - !alloc_2D_test(16385, 16, PIXEL_FMT_16BIT)
+TEST # 57 - !alloc_2D_test(8193, 16, PIXEL_FMT_32BIT)
+TEST # 58 - maxalloc_1D_test(4096, MAX_ALLOCS)
+TEST # 59 - maxalloc_2D_test(64, 64, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 60 - maxalloc_2D_test(64, 64, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 61 - maxalloc_2D_test(64, 64, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 62 - maxalloc_NV12_test(64, 64, MAX_ALLOCS)
+TEST # 63 - maxmap_1D_test(4096, MAX_ALLOCS)
+TEST # 64 - maxalloc_1D_test(176 * 144 * 2, MAX_ALLOCS)
+TEST # 65 - maxalloc_2D_test(176, 144, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 66 - maxalloc_2D_test(176, 144, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 67 - maxalloc_2D_test(176, 144, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 68 - maxalloc_NV12_test(176, 144, MAX_ALLOCS)
+TEST # 69 - maxmap_1D_test(176 * 144 * 2, MAX_ALLOCS)
+TEST # 70 - maxalloc_1D_test(640 * 480 * 2, MAX_ALLOCS)
+TEST # 71 - maxalloc_2D_test(640, 480, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 72 - maxalloc_2D_test(640, 480, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 73 - maxalloc_2D_test(640, 480, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 74 - maxalloc_NV12_test(640, 480, MAX_ALLOCS)
+TEST # 75 - maxmap_1D_test(640 * 480 * 2, MAX_ALLOCS)
+TEST # 76 - maxalloc_1D_test(848 * 480 * 2, MAX_ALLOCS)
+TEST # 77 - maxalloc_2D_test(848, 480, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 78 - maxalloc_2D_test(848, 480, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 79 - maxalloc_2D_test(848, 480, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 80 - maxalloc_NV12_test(848, 480, MAX_ALLOCS)
+TEST # 81 - maxmap_1D_test(848 * 480 * 2, MAX_ALLOCS)
+TEST # 82 - maxalloc_1D_test(1280 * 720 * 2, MAX_ALLOCS)
+TEST # 83 - maxalloc_2D_test(1280, 720, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 84 - maxalloc_2D_test(1280, 720, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 85 - maxalloc_2D_test(1280, 720, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 86 - maxalloc_NV12_test(1280, 720, MAX_ALLOCS)
+TEST # 87 - maxmap_1D_test(1280 * 720 * 2, MAX_ALLOCS)
+TEST # 88 - maxalloc_1D_test(1920 * 1080 * 2, MAX_ALLOCS)
+TEST # 89 - maxalloc_2D_test(1920, 1080, PIXEL_FMT_8BIT, MAX_ALLOCS)
+TEST # 90 - maxalloc_2D_test(1920, 1080, PIXEL_FMT_16BIT, MAX_ALLOCS)
+TEST # 91 - maxalloc_2D_test(1920, 1080, PIXEL_FMT_32BIT, MAX_ALLOCS)
+TEST # 92 - maxalloc_NV12_test(1920, 1080, 2)
+TEST # 93 - maxalloc_NV12_test(1920, 1080, MAX_ALLOCS)
+TEST # 94 - maxmap_1D_test(1920 * 1080 * 2, MAX_ALLOCS)
+TEST # 95 - star_tiler_test(1000, 10)
+TEST # 96 - star_tiler_test(1000, 30)
+TEST # 97 - star_test(100, 10)
+TEST # 98 - star_test(1000, 10)
+
diff --git a/tiler/bootstrap.sh b/tiler/bootstrap.sh
new file mode 100755
index 0000000..6170918
--- /dev/null
+++ b/tiler/bootstrap.sh
@@ -0,0 +1,18 @@
+#! /bin/sh
+
+cd `dirname $0`
+
+# on some platforms, you have "g" versions of some of these tools instead,
+# ie glibtoolize instead of libtoolize..
+find_tool() {
+ which $1 2> /dev/null || which g$1 2> /dev/null
+}
+
+aclocal=`find_tool aclocal`
+libtoolize=`find_tool libtoolize`
+automake=`find_tool automake`
+autoconf=`find_tool autoconf`
+autoheader=`find_tool autoheader`
+
+mkdir -p config && $autoheader && $aclocal && $libtoolize --copy --force && $automake --copy --add-missing --foreign && $autoconf
+
diff --git a/tiler/configure.ac b/tiler/configure.ac
new file mode 100755
index 0000000..30d131c
--- /dev/null
+++ b/tiler/configure.ac
@@ -0,0 +1,75 @@
+# -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ(2.61)
+AC_INIT(timemmgr, 2.00, http://www.ti.com)
+AC_CONFIG_SRCDIR([memmgr.c])
+AC_CONFIG_HEADER([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_AUX_DIR([config])
+AC_CANONICAL_SYSTEM
+AM_INIT_AUTOMAKE([timemmgr], [2.00])
+LT_INIT
+
+# Checks for programs.
+AC_PROG_CC
+AM_PROG_LIBTOOL
+
+# Checks for libraries.
+
+# Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([fcntl.h stdint.h stdlib.h string.h sys/ioctl.h unistd.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_HEADER_STDBOOL
+AC_TYPE_UINT16_T
+AC_TYPE_UINT32_T
+
+# Checks for library functions.
+AC_PROG_GCC_TRADITIONAL
+#AC_FUNC_MALLOC
+#AC_FUNC_MMAP
+AC_CHECK_FUNCS([munmap strerror])
+
+AC_ARG_ENABLE(tilermgr,
+[ --enable-tilermgr Include TilerMgr headers],
+[case "${enableval}" in
+ yes) tilermgr=true ;;
+ no) tilermgr=false ;;
+ *) AC_MSG_ERROR(bad value ${enableval} for --enable-tilermgr) ;;
+esac],[tilermgr=true])
+
+AC_ARG_ENABLE(tests,
+[ --enable-tests Build unit tests],
+[case "${enableval}" in
+ yes) tests=true ;;
+ no) tests=false ;;
+ *) AC_MSG_ERROR(bad value ${enableval} for --enable-tests) ;;
+esac],[tests=false])
+
+AM_CONDITIONAL(UNIT_TESTS, test x$tests = xtrue)
+
+AM_CONDITIONAL(TILERMGR, test x$tilermgr != xfalse)
+
+AC_ARG_ENABLE(stub,
+[ --enable-stub Stubbing tiler and syslink on none-arm system],
+[case "${enableval}" in
+ yes) stub_tiler=true ;;
+ no) stub_tiler=false ;;
+ *) AC_MSG_ERROR(bad value ${enableval} for --enable-stub) ;;
+esac],[stub_tiler=false])
+
+AM_CONDITIONAL(STUB_TILER, test x$stub_tiler = xtrue)
+
+if test x$stub_tiler = xtrue; then
+AC_DEFINE([STUB_TILER],[1],[Use tiler stub])
+fi
+
+# Project build flags
+MEMMGR_CFLAGS="-Werror -Wall -pipe -ansi"
+AC_SUBST(MEMMGR_CFLAGS)
+
+AC_CONFIG_FILES([libtimemmgr.pc Makefile])
+AC_OUTPUT
+
diff --git a/tiler/debug_utils.h b/tiler/debug_utils.h
new file mode 100644
index 0000000..316e80e
--- /dev/null
+++ b/tiler/debug_utils.h
@@ -0,0 +1,211 @@
+/*
+ * debug_utils.h
+ *
+ * Debug Utility definitions.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _DEBUG_UTILS_H_
+#define _DEBUG_UTILS_H_
+
+#include <stdio.h>
+
+/*#define __DEBUG__*/
+/*#define __DEBUG_ENTRY__*/
+/*#define __DEBUG_ASSERT__*/
+
+/* ---------- Generic Debug Print Macros ---------- */
+
+/**
+ * Use as:
+ * P("val is %d", 5);
+ * ==> val is 5
+ * DP("val is %d", 15);
+ * ==> val is 5 at test.c:56:main()
+ */
+/* debug print (fmt must be a literal); adds new-line. */
+#define __DEBUG_PRINT(fmt, ...) do { fprintf(stdout, fmt "\n", ##__VA_ARGS__); fflush(stdout); } while(0)
+
+/* debug print with context information (fmt must be a literal) */
+#define __DEBUG_DPRINT(fmt, ...) __DEBUG_PRINT(fmt " at %s(" __FILE__ ":%d)", ##__VA_ARGS__, __FUNCTION__, __LINE__)
+
+#ifdef __DEBUG__
+#define P(fmt, ...) __DEBUG_PRINT(fmt, ##__VA_ARGS__)
+#define DP(fmt, ...) __DEBUG_DPRINT(fmt, ##__VA_ARGS__)
+#else
+#define P(fmt, ...)
+#define DP(fmt, ...)
+#endif
+
+/* ---------- Program Flow Debug Macros ---------- */
+
+/**
+ * Use as:
+ * int get5() {
+ * IN;
+ * return R_I(5);
+ * }
+ * void check(int i) {
+ * IN;
+ * if (i == 5) { RET; return; }
+ * OUT;
+ * }
+ * void main() {
+ * IN;
+ * check(get5());
+ * check(2);
+ * OUT;
+ * }
+ * ==>
+ * in main(test.c:11)
+ * in get5(test.c:2)
+ * out(5) at get5(test.c:3)
+ * in check(test.c:6)
+ * out() at check(test.c:7)
+ * in check(test.c:6)
+ * out check(test.c:8)
+ * out main(test.c:14)
+ */
+
+#ifdef __DEBUG_ENTRY__
+/* function entry */
+#define IN __DEBUG_PRINT("in %s(" __FILE__ ":%d)", __FUNCTION__, __LINE__)
+/* function exit */
+#define OUT __DEBUG_PRINT("out %s(" __FILE__ ":%d)", __FUNCTION__, __LINE__)
+/* function abort (return;) Use as { RET; return; } */
+#define RET __DEBUG_DPRINT("out() ")
+/* generic function return */
+#define R(val,type,fmt) ({ type __val__ = (type) val; __DEBUG_DPRINT("out(" fmt ")", __val__); __val__; })
+#else
+#define IN
+#define OUT
+#define RET
+#define R(val,type,fmt) (val)
+#endif
+
+/* integer return */
+#define R_I(val) R(val,int,"%d")
+/* pointer return */
+#define R_P(val) R(val,void *,"%p")
+/* long return */
+#define R_UP(val) R(val,long,"0x%lx")
+
+/* ---------- Assertion Debug Macros ---------- */
+
+/**
+ * Use as:
+ * int i = 5;
+ * // int j = i * 5;
+ * int j = A_I(i,==,3) * 5;
+ * // if (i > 3) P("bad")
+ * if (NOT_I(i,<=,3)) P("bad")
+ * P("j is %d", j);
+ * ==> assert: i (=5) !== 3 at test.c:56:main()
+ * assert: i (=5) !<= 3 at test.c:58:main()
+ * j is 25
+ *
+ */
+/* generic assertion check, A returns the value of exp, CHK return void */
+#ifdef __DEBUG_ASSERT__
+#define A(exp,cmp,val,type,fmt) ({ \
+ type __exp__ = (type) (exp); type __val__ = (type) (val); \
+ if (!(__exp__ cmp __val__)) __DEBUG_DPRINT("assert: %s (=" fmt ") !" #cmp " " fmt, #exp, __exp__, __val__); \
+ __exp__; \
+})
+#define CHK(exp,cmp,val,type,fmt) do { \
+ type __exp__ = (type) (exp); type __val__ = (type) (val); \
+ if (!(__exp__ cmp __val__)) __DEBUG_DPRINT("assert: %s (=" fmt ") !" #cmp " " fmt, #exp, __exp__, __val__); \
+} while(0)
+#else
+#define A(exp,cmp,val,type,fmt) (exp)
+#define CHK(exp,cmp,val,type,fmt)
+#endif
+
+/* typed assertions */
+#define A_I(exp,cmp,val) A(exp,cmp,val,int,"%d")
+#define A_L(exp,cmp,val) A(exp,cmp,val,long,"%ld")
+#define A_P(exp,cmp,val) A(exp,cmp,val,void *,"%p")
+#define CHK_I(exp,cmp,val) CHK(exp,cmp,val,int,"%d")
+#define CHK_L(exp,cmp,val) CHK(exp,cmp,val,long,"%ld")
+#define CHK_P(exp,cmp,val) CHK(exp,cmp,val,void *,"%p")
+
+/* generic assertion check, returns true iff assertion fails */
+#ifdef __DEBUG_ASSERT__
+#define NOT(exp,cmp,val,type,fmt) ({ \
+ type __exp__ = (type) (exp); type __val__ = (type) (val); \
+ if (!(__exp__ cmp __val__)) __DEBUG_DPRINT("assert: %s (=" fmt ") !" #cmp " " fmt, #exp, __exp__, __val__); \
+ !(__exp__ cmp __val__); \
+})
+#else
+#define NOT(exp,cmp,val,type,fmt) (!((exp) cmp (val)))
+#endif
+
+/* typed assertion checks */
+#define NOT_I(exp,cmp,val) NOT(exp,cmp,val,int,"%d")
+#define NOT_L(exp,cmp,val) NOT(exp,cmp,val,long,"%ld")
+#define NOT_P(exp,cmp,val) NOT(exp,cmp,val,void *,"%p")
+
+
+/* system assertions - will use perror to give external error information */
+#ifdef __DEBUG_ASSERT__
+#define ERR_S(fmt, ...) do { fprintf(stderr, fmt " at %s(" __FILE__ ":%d", ##__VA_ARGS__, __FUNCTION__, __LINE__); perror(")"); fflush(stderr); } while(0)
+#define A_S(exp,cmp,val) ({ \
+ int __exp__ = (int) (exp); int __val__ = (int) (val); \
+ if (!(__exp__ cmp __val__)) ERR_S("assert: %s (=%d) !" #cmp " %d", #exp, __exp__, __val__); \
+ __exp__; \
+})
+#define CHK_S(exp,cmp,val) do { \
+ int __exp__ = (int) (exp); int __val__ = (int) (val); \
+ if (!(__exp__ cmp __val__)) ERR_S("assert: %s (=%d) !" #cmp " %d", #exp, __exp__, __val__); \
+} while(0)
+#define NOT_S(exp,cmp,val) ({ \
+ int __exp__ = (int) (exp); int __val__ = (int) (val); \
+ if (!(__exp__ cmp __val__)) ERR_S("assert: %s (=%d) !" #cmp " %d", #exp, __exp__, __val__); \
+ !(__exp__ cmp __val__); \
+})
+#else
+#define A_S(exp,cmp,val) (exp)
+#define CHK_S(exp,cmp,val)
+#define NOT_S(exp,cmp,val) (!((exp) cmp (val)))
+#endif
+
+/* error propagation macros - these macros ensure evaluation of the expression
+ even if there was a prior error */
+
+/* new error is accumulated into error */
+#define ERR_ADD(err, exp) do { int __error__ = A_I(exp,==,0); err = err ? err : __error__; } while(0)
+#define ERR_ADD_S(err, exp) do { int __error__ = A_S(exp,==,0); err = err ? err : __error__; } while(0)
+/* new error overwrites old error */
+#define ERR_OVW(err, exp) do { int __error__ = A_I(exp,==,0); err = __error__ ? __error__ : err; } while(0)
+#define ERR_OVW_S(err, exp) do { int __error__ = A_S(exp,==,0); err = __error__ ? __error__ : err; } while(0)
+
+#endif
+
diff --git a/tiler/fill_utr.py b/tiler/fill_utr.py
new file mode 100755
index 0000000..d006298
--- /dev/null
+++ b/tiler/fill_utr.py
@@ -0,0 +1,92 @@
+# Use this script to fill out the UTR for MemMgr/D2C tests. You can use
+# either Python 2.6 or 3.1
+#
+# Limitations:
+# - only basic tests run by memmgr_test and d2c_test are filled out
+# - negative memmgr_tests are performed in one step and this script will
+# not separate which part of the test failed. If your negative memmgr
+# tests fail, you want to manually check which test case failed.
+
+# Usage:
+# 1. run memmgr_test and d2c_test, and pipe the output of the tests into a
+# file.
+#
+# memmgr_test > test.log
+# d2c_test >> test.log
+#
+# 2. open UTR and select Tiler/D2C User Space worksheet
+# 3. run this script by piping the test logs into the script, e.g.
+# python fill_utr.py < test.log
+
+import sys, re, win32com.client
+
+TCs, results = [], {}
+
+# gather test results from the log
+for line in sys.stdin:
+ # check for test description
+ desc = re.search("TEST #... - (.*)", line.strip())
+ if desc:
+ TCs.append(desc.group(1))
+
+ # check for any test result
+ result = re.search("==> TEST (.*)", line.strip())
+ if result:
+ result = result.group(1)
+ if result == 'OK':
+ result = 'P', ''
+ elif result == 'NOT AVAILABLE':
+ result = 'D', ''
+ else:
+ result = 'F', 'failed with error #' + result[5:-1]
+
+ results[TCs.pop(0)] = result
+
+assert "test_d2c(1920, 1080, 2)" in results
+
+# populate test results
+excel = win32com.client.Dispatch('Excel.Application')
+if not excel:
+ print('Could not find Excel application. The UTR is probably not open in Excel.')
+ sys.exit(1)
+
+sheet = excel.ActiveSheet
+if sheet.Name != 'Tiler' or sheet.Cells(1,1).Text != 'Test Metrics':
+ print('Active worksheet does not seem to be the Tiler UTR')
+ sys.exit(1)
+
+# find Header
+for r in range(1, 100):
+ if sheet.Cells(r, 1).Text == 'Test Case\nID':
+ break
+else:
+ print('Could not find header row starting with "Test Case\\nID"')
+ sys.exit(1)
+
+# find Status, Details and Comments columns
+heads = t_status, t_details, t_comments, t_desc = 'Status', 'Details', 'Comments', 'Test Case\nDescription'
+heads = set(heads)
+cols = {}
+for c in range(1, 100):
+ if sheet.Cells(r, c).Text in heads:
+ cols[sheet.Cells(r, c).Text] = c
+ heads.remove(sheet.Cells(r, c).Text)
+if heads:
+ print('Could not find columns', heads)
+ sys.exit(1)
+
+# populate sheet, quit after 20 empty Details/Description cells
+empties = 0
+while empties < 20:
+ r += 1
+ details = sheet.Cells(r, cols[t_details]).Text
+ if details:
+ empties = 0
+ # get test case description
+ desc = details.split('\n')[-1]
+ if not desc in results:
+ results[desc] = 'U', ''
+ sheet.Cells(r, cols[t_status]).Value, sheet.Cells(r, cols[t_comments]).Value = results[desc]
+ elif not sheet.Cells(r, cols[t_desc]).Text:
+ empties += 1
+
diff --git a/tiler/libtimemmgr.pc.in b/tiler/libtimemmgr.pc.in
new file mode 100644
index 0000000..7ecd886
--- /dev/null
+++ b/tiler/libtimemmgr.pc.in
@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: timemmgr
+Description: TI memory manager
+Version: @VERSION@
+Requires:
+Libs: -L${libdir} -ltimemmgr
+Cflags: -I${includedir}/timemmgr
+
+
diff --git a/tiler/list_utils.h b/tiler/list_utils.h
new file mode 100644
index 0000000..1643cf0
--- /dev/null
+++ b/tiler/list_utils.h
@@ -0,0 +1,511 @@
+/*
+ * list_utils.h
+ *
+ * Utility definitions for the Memory Interface for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LIST_UTILS_H_
+#define _LIST_UTILS_H_
+
+/*
+
+ DLIST macros facilitate double-linked lists in a generic fashion.
+
+ - Double-linked lists simplify list manipulations, so they are preferred to
+ single-linked lists.
+
+ - Having a double-linked list with a separate header allow accessing the
+ last element of the list easily, so this is also preferred to a double
+ linked list that uses NULL pointers at its ends.
+
+ Therefore, the following is required: a list info structure (separate from
+ the element structure, although the info structure can be a member of the
+ element structure). The info structure must contain (at least) the
+ following 3 members:
+
+ *next, *last: as pointers to the info structure. These are the next and
+ previous elements in the list.
+ *me: as a pointer to the element structure. This is how we get to the
+ element itself, as next and last points to another info structure.
+
+ The list element structure __MAY__ contain the info structure as a member,
+ or a pointer to the info structure if it is desired to be kept separately.
+ In such cases macros are provided to add the elements directly to the list,
+ and automatically set up the info structure fields correctly. You can also
+ iterate through the elements of the list using a pointer to the elements
+ itself, as the list structure can be obtained for each element.
+
+ Otherwise, macros are provided to manipulate list info structures and
+ link them in any shape or form into double linked lists. This allows
+ having NULL values as members of such lists.
+
+ :NOTE: If you use a macro with a field argument, you must not have NULL
+ elements because the field of any element must be/point to the list
+ info structure
+
+ DZLIST macros
+
+ Having the list info structure separate from the element structure also
+ allows to link elements into many separate lists (with separate info
+ structure fields/pointers). However, for cases where only a single list
+ is desired, a set of easy macros are also provided.
+
+ These macros combine the element and list structures. These macros
+ require the following 2 members in each element structure:
+
+ *next, *last: as pointers to the element structure. These are the next and
+ previous elements in the list.
+
+ :NOTE: In case of the DZLIST-s, the head of the list must be an element
+ structure, where only the next and last members are used. */
+
+/*
+ Usage:
+
+ DLIST macros are designed for preallocating the list info structures, e.g. in
+ an array. This is why most macros take a list info structure, and not a
+ pointer to a list info structure.
+
+ Basic linked list consists of element structure and list info structure
+
+ struct elem {
+ int data;
+ } *elA, *elB;
+ struct list {
+ struct elem *me;
+ struct list *last, *next;
+ } head, *inA, *inB, *in;
+
+ DLIST_INIT(head); // initialization -> ()
+ DLIST_IS_EMPTY(head) == TRUE; // emptiness check
+
+ // add element at beginning of list -> (1)
+ elA = NEW(struct elem);
+ elA->data = 1;
+ inA = NEW(struct list);
+ DLIST_ADD_AFTER(head, elA, *inA);
+
+ // add before an element -> (2, 1)
+ elB = NEW(struct elem);
+ elB->data = 2;
+ inB = NEW(struct list);
+ DLIST_ADD_BEFORE(*inA, elB, *inB);
+
+ // move an element to another position or another list -> (1, 2)
+ DLIST_MOVE_BEFORE(head, *inB);
+
+ // works even if the position is the same -> (1, 2)
+ DLIST_MOVE_BEFORE(head, *inB);
+
+ // get first and last elements
+ DLIST_FIRST(head) == elA;
+ DLIST_LAST(head) == elB;
+
+ // loop through elements
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+
+ // remove element -> (2)
+ DLIST_REMOVE(*inA);
+ FREE(elA);
+ FREE(inA);
+
+ // delete list
+ DLIST_SAFE_LOOP(head, in, inA) {
+ DLIST_REMOVE(*in);
+ FREE(in->me);
+ FREE(in);
+ }
+
+ You can combine the element and list info structures to create an easy list,
+ but you still need to specify both element and info structure while adding
+ elements.
+
+ struct elem {
+ int data;
+ struct elem *me, *last, *next;
+ } head, *el, *elA, *elB;
+
+ DLIST_INIT(head); // initialization -> ()
+ DLIST_IS_EMPTY(head) == TRUE; // emptiness check
+
+ // add element at beginning of list -> (1)
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DLIST_ADD_AFTER(head, elA, *elA);
+
+ // add before an element -> (2, 1)
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DLIST_ADD_BEFORE(*elA, elB, *elB);
+
+ // move an element to another position or another list -> (1, 2)
+ DLIST_MOVE_BEFORE(head, *elB);
+
+ // works even if the position is the same -> (1, 2)
+ DLIST_MOVE_BEFORE(head, *elB);
+
+ // get first and last elements
+ DLIST_FIRST(head) == elA;
+ DLIST_LAST(head) == elB;
+
+ // loop through elements
+ DLIST_LOOP(head, el) {
+ P("%d", el->data);
+ }
+
+ // remove element -> (2)
+ DLIST_REMOVE(*elA);
+ FREE(elA);
+
+ // delete list
+ DLIST_SAFE_LOOP(head, el, elA) {
+ DLIST_REMOVE(*el);
+ FREE(el);
+ }
+
+ Or, you can use a DZLIST.
+
+ struct elem {
+ int data;
+ struct elem *last, *next;
+ } head, *el, *elA, *elB;
+
+ DZLIST_INIT(head); // initialization -> ()
+ DZLIST_IS_EMPTY(head) == TRUE; // emptiness check
+
+ // add element at beginning of list -> (1)
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DZLIST_ADD_AFTER(head, *elA);
+
+ // add before an element -> (2, 1)
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DZLIST_ADD_BEFORE(*elA, *elB);
+
+ // move an element to another position or another list -> (1, 2)
+ DZLIST_MOVE_BEFORE(head, *elB);
+
+ // works even if the position is the same -> (1, 2)
+ DZLIST_MOVE_BEFORE(head, *elB);
+
+ // get first and last elements
+ DZLIST_FIRST(head) == elA;
+ DZLIST_LAST(head) == elB;
+
+ // loop through elements
+ DZLIST_LOOP(head, el) {
+ P("%d", el->data);
+ }
+
+ // remove element -> (2)
+ DZLIST_REMOVE(*elA);
+ FREE(elA);
+
+ // delete list
+ DZLIST_SAFE_LOOP(head, el, elA) {
+ DZLIST_REMOVE(*el);
+ FREE(el);
+ }
+
+ A better way to get to the list structure from the element structure is to
+ enclose a pointer the list structure in the element structure. This allows
+ getting to the next/previous element from the element itself.
+
+ struct elem;
+ struct list {
+ struct elem *me;
+ struct list *last, *next;
+ } head, *inA, *inB, *in;
+ struct elem {
+ int data;
+ struct list *list_data;
+ } *elA, *elB, *el;
+
+ // or
+
+ struct elem {
+ int data;
+ struct list {
+ struct elem *me;
+ struct list *last, *next;
+ } *list_data;
+ } *elA, *elB, *el;
+ struct list head, *inA, *inB, *in;
+
+ DLIST_INIT(head); // initialization -> ()
+ DLIST_IS_EMPTY(head) == TRUE; // emptiness check
+
+ // add element at beginning of list -> (1)
+ elA = NEW(struct elem);
+ elA->data = 1;
+ inA = NEW(struct list);
+ DLIST_PADD_AFTER(head, elA, inA, list_data);
+
+ // add before an element -> (2, 1)
+ elB = NEW(struct elem);
+ elB->data = 2;
+ inB = NEW(struct list);
+ DLIST_PADD_BEFORE(*elA, elB, inB, list_data);
+
+ // move an element to another position or another list -> (1, 2)
+ DLIST_MOVE_BEFORE(head, *inB);
+
+ // works even if the position is the same -> (1, 2)
+ DLIST_MOVE_BEFORE(head, *inB);
+
+ // get first and last elements
+ DLIST_FIRST(head) == elA;
+ DLIST_LAST(head) == elB;
+
+ // loop through elements
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ DLIST_PLOOP(head, el, list_data) {
+ P("%d", el->data);
+ }
+
+ // remove element
+ DLIST_REMOVE(*inA);
+ FREE(inA);
+ FREE(elA);
+
+ // delete list
+ DLIST_SAFE_PLOOP(head, el, elA, list_data) {
+ DLIST_REMOVE(*el->list_data);
+ FREE(el->list_data);
+ FREE(el);
+ }
+
+ Lastly, you can include the list data in the element structure itself.
+
+ struct elem {
+ int data;
+ struct list {
+ struct list *last, *next;
+ struct elem *me;
+ } list_data;
+ } *elA, *elB, *el;
+ struct list head, *in;
+
+ DLIST_INIT(head); // initialization -> ()
+ DLIST_IS_EMPTY(head) == TRUE; // emptiness check
+
+ // add element at beginning of list -> (1)
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DLIST_MADD_AFTER(head, elA, list_data);
+
+ // add before an element -> (2, 1)
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DLIST_PADD_BEFORE(elA->list_data, elB, list_data);
+
+ // move an element to another position or another list -> (1, 2)
+ DLIST_MOVE_BEFORE(head, elB->list_data);
+
+ // works even if the position is the same -> (1, 2)
+ DLIST_MOVE_BEFORE(head, elB->list_data);
+
+ // get first and last elements
+ DLIST_FIRST(head) == elA;
+ DLIST_LAST(head) == elB;
+
+ // loop through elements
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ DLIST_MLOOP(head, el, list_data) {
+ P("%d", el->data);
+ }
+
+ // remove element
+ DLIST_REMOVE(elA->list_data);
+ FREE(elA);
+
+ // delete list
+ DLIST_SAFE_MLOOP(head, el, elA, list_data) {
+ DLIST_REMOVE(el->list_data);
+ FREE(el);
+ }
+
+ */
+
+/* -- internal (generic direction) macros -- */
+#define DLIST_move__(base, info, next, last) \
+ ((info).last = &base)->next = ((info).next = (base).next)->last = &(info)
+#define DLIST_padd__(base, pInfo, pElem, pField, next, last) \
+ ((pInfo)->last = &base)->next = ((pInfo)->next = (base).next)->last = \
+ pElem->pField = pInfo
+#define DLIST_loop__(head, pInfo, next) \
+ for (pInfo=(head).next; pInfo != &(head); pInfo = (pInfo)->next)
+#define DLIST_ploop__(head, pElem, pField, next) \
+ for (pElem=(head).next->me; pElem; pElem = (pElem)->pField->next->me)
+#define DLIST_mloop__(head, pElem, mField, next) \
+ for (pElem=(head).next->me; pElem; pElem = (pElem)->mField.next->me)
+#define DLIST_safe_loop__(head, pInfo, pInfo_safe, next) \
+ for (pInfo=(head).next; pInfo != &(head); pInfo = pInfo_safe) \
+ if ((pInfo_safe = (pInfo)->next) || 1)
+#define DLIST_safe_ploop__(head, pElem, pElem_safe, pField, next) \
+ for (pElem=(head).next->me; pElem; pElem = pElem_safe) \
+ if ((pElem_safe = (pElem)->pField->next->me) || 1)
+#define DLIST_safe_mloop__(head, pElem, pElem_safe, mField, next) \
+ for (pElem=(head).next->me; pElem; pElem = pElem_safe) \
+ if ((pElem_safe = (pElem)->mField.next->me) || 1)
+
+#define DLIST_IS_EMPTY(head) ((head).next == &(head))
+
+/* Adds the element (referred to by the info structure) before/or after another
+ element (or list header) (base). */
+
+#define DLIST_ADD_AFTER(base, pElem, info) \
+ (DLIST_move__(base, info, next, last))->me = pElem
+#define DLIST_ADD_BEFORE(base, pElem, info) \
+ (DLIST_move__(base, info, last, next))->me = pElem
+
+/* Adds the element (referred to by pElem pointer) along with its info
+ structure (referred to by pInfo pointer) before/or after an element or
+ list header (base). It also sets up the list structure header to point to
+ the element as well as the element's field to point back to the list info
+ structure. */
+#define DLIST_PADD_BEFORE(base, pElem, pInfo, pField) \
+ (DLIST_padd__(base, pInfo, pElem, pField, last, next))->me = pElem
+#define DLIST_PADD_AFTER(base, pElem, pInfo, pField) \
+ (DLIST_padd__(base, pInfo, pElem, pField, next, last))->me = pElem
+
+/* Adds the element (referred to by pElem pointer) before/or after an element or
+ list header (base). It also sets up the list structure header (which is a
+ member of the element's structure) to point to the element. */
+#define DLIST_MADD_BEFORE(base, pElem, mField) \
+ (DLIST_move__(base, pElem->mField, last, next))->me = pElem
+#define DLIST_MADD_AFTER(base, pElem, mField) \
+ (DLIST_move__(base, pElem->mField, next, last))->me = pElem
+
+/* Removes the element (referred to by the info structure) from its current
+ list. This requires that the element is a part of a list.
+
+ :NOTE: the info structure will still think that it belongs to the list it
+ used to belong to. However, the old list will not contain this element any
+ longer. You want to discard the info/element after this call. Otherwise,
+ you can use one of the MOVE macros to also add the item to another list,
+ or another place in the same list. */
+#define DLIST_REMOVE(info) ((info).last->next = (info).next)->last = (info).last
+
+/* Initializes the list header (to an empty list) */
+#define DLIST_INIT(head) \
+ do { (head).me = NULL; (head).next = (head).last = &(head); } while(0)
+
+/* These functions move an element (referred to by the info structure) before
+ or after another element (or the list head).
+ :NOTE: This logic also works for moving an element after/before itself. */
+#define DLIST_MOVE_AFTER(base, info) \
+ do { DLIST_REMOVE(info); DLIST_move__(base, info, next, last); } while(0)
+#define DLIST_MOVE_BEFORE(base, info) \
+ do { DLIST_REMOVE(info); DLIST_move__(base, info, last, next); } while(0)
+
+/* Loops behave syntactically as a for() statement. They traverse the loop
+ variable from the 1st to the last element (or in the opposite direction in
+ case of RLOOP). There are 3 flavors of loops depending on the type of the
+ loop variable.
+
+ DLIST_LOOP's loop variable is a pointer to the list info structure. You can
+ get to the element by using the 'me' member. Nonetheless, this loop
+ construct allows having NULL elements in the list.
+
+ DLIST_MLOOP's loop variable is a pointer to a list element. mField is the
+ field of the element containing the list info structure. Naturally, this
+ list cannot have NULL elements.
+
+ DLIST_PLOOP's loop variable is also a pointer to a list element. Use this
+ construct if the element contains a pointer to the list info structure
+ instead of embedding it directly into the element structure.
+
+*/
+#define DLIST_LOOP(head, pInfo) DLIST_loop__(head, pInfo, next)
+#define DLIST_RLOOP(head, pInfo) DLIST_loop__(head, pInfo, last)
+#define DLIST_MLOOP(head, pElem, mField) \
+ DLIST_mloop__(head, pElem, mField, next)
+#define DLIST_RMLOOP(head, pElem, mField) \
+ DLIST_mloop__(head, pElem, mField, last)
+#define DLIST_PLOOP(head, pElem, pField) \
+ DLIST_ploop__(head, pElem, pField, next)
+#define DLIST_RPLOOP(head, pElem, pField) \
+ DLIST_ploop__(head, pElem, pField, last)
+
+/* Safe loops are like ordinary loops, but they allow removal of the current
+ element from the list. They require an extra loop variable that holds the
+ value of the next element in case the current element is moved/removed. */
+#define DLIST_SAFE_LOOP(head, pInfo, pInfo_safe) \
+ DLIST_safe_loop__(head, pInfo, pInfo_safe, next)
+#define DLIST_SAFE_RLOOP(head, pInfo, pInfo_safe) \
+ DLIST_safe_loop__(head, pInfo, pInfo_safe, last)
+#define DLIST_SAFE_MLOOP(head, pElem, pElem_safe, mField) \
+ DLIST_safe_mloop__(head, pElem, pElem_safe, mField, next)
+#define DLIST_SAFE_RMLOOP(head, pElem, pElem_safe, mField) \
+ DLIST_safe_mloop__(head, pElem, pElem_safe, mField, last)
+#define DLIST_SAFE_PLOOP(head, pElem, pElem_safe, pField) \
+ DLIST_safe_ploop__(head, pElem, pElem_safe, pField, next)
+#define DLIST_SAFE_RPLOOP(head, pElem, pElem_safe, pField) \
+ DLIST_safe_ploop__(head, pElem, pElem_safe, pField, last)
+
+/* returns the first element of a list */
+#define DLIST_FIRST(head) (head).next->me
+/* returns the last element of a list */
+#define DLIST_LAST(head) (head).last->me
+
+
+/* DZLIST equivalent API - provided so arguments are specified */
+#define DZLIST_INIT(head) do { (head).next = (head).last = &(head); } while(0)
+#define DZLIST_IS_EMPTY(head) DLIST_IS_EMPTY(head)
+#define DZLIST_FIRST(head) (head).next
+#define DZLIST_LAST(head) (head).last
+
+#define DZLIST_ADD_AFTER(base, elem) DLIST_move__(base, elem, next, last)
+#define DZLIST_ADD_BEFORE(base, elem) DLIST_move__(base, elem, last, next)
+
+#define DZLIST_REMOVE(elem) DLIST_REMOVE(elem)
+
+#define DZLIST_MOVE_AFTER(base, elem) DLIST_MOVE_AFTER(base, elem)
+#define DZLIST_MOVE_BEFORE(base, elem) DLIST_MOVE_BEFORE(base, elem)
+
+#define DZLIST_LOOP(head, pElem) DLIST_LOOP(head, pElem)
+#define DZLIST_RLOOP(head, pElem) DLIST_RLOOP(head, pElem)
+#define DZLIST_SAFE_LOOP(head, pElem, pElem_safe) \
+ DLIST_SAFE_LOOP(head, pElem, pElem_safe)
+#define DZLIST_SAFE_RLOOP(head, pElem, pElem_safe) \
+ DLIST_SAFE_RLOOP(head, pElem, pElem_safe)
+
+#endif
+
diff --git a/tiler/mem_types.h b/tiler/mem_types.h
new file mode 100644
index 0000000..18453bb
--- /dev/null
+++ b/tiler/mem_types.h
@@ -0,0 +1,101 @@
+/*
+ * types.h
+ *
+ * Type definitions for the Memory Interface for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _MEM_TYPES_H_
+#define _MEM_TYPES_H_
+
+/* for bool definition */
+#include <stdbool.h>
+#include <stdint.h>
+
+/** ---------------------------------------------------------------------------
+ * Type definitions
+ */
+
+/**
+ * Buffer length in bytes
+ */
+typedef uint32_t bytes_t;
+
+/**
+ * Length in pixels
+ */
+typedef uint16_t pixels_t;
+
+
+/**
+ * Pixel format
+ *
+ * Page mode is encoded in the pixel format to handle different
+ * set of buffers uniformly
+ */
+enum pixel_fmt_t {
+ PIXEL_FMT_MIN = 0,
+ PIXEL_FMT_8BIT = 0,
+ PIXEL_FMT_16BIT = 1,
+ PIXEL_FMT_32BIT = 2,
+ PIXEL_FMT_PAGE = 3,
+ PIXEL_FMT_MAX = 3
+};
+
+typedef enum pixel_fmt_t pixel_fmt_t;
+
+/**
+ * Ducati Space Virtual Address Pointer
+ *
+ * This is handled as a unsigned long so that no dereferencing
+ * is allowed by user space components.
+ */
+typedef uint32_t DSPtr;
+
+/**
+ * System Space Pointer
+ *
+ * This is handled as a unsigned long so that no dereferencing
+ * is allowed by user space components.
+ */
+typedef uint32_t SSPtr;
+
+/**
+ * Error values
+ *
+ * Page mode is encoded in the pixel format to handle different
+ * set of buffers uniformly
+ */
+#define MEMMGR_ERR_NONE 0
+#define MEMMGR_ERR_GENERIC 1
+
+#endif
+
diff --git a/tiler/memmgr.c b/tiler/memmgr.c
new file mode 100644
index 0000000..1f780cc
--- /dev/null
+++ b/tiler/memmgr.c
@@ -0,0 +1,1078 @@
+/*
+ * memmgr.c
+ *
+ * Memory Allocator Interface functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <pthread.h>
+#include <errno.h>
+
+#define BUF_ALLOCED 1
+#define BUF_MAPPED 2
+#define BUF_ANY ~0
+
+#include <tiler.h>
+
+typedef struct tiler_block_info tiler_block_info;
+
+#define __DEBUG__
+#undef __DEBUG_ENTRY__
+#define __DEBUG_ASSERT__
+
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+#include "utils.h"
+#include "list_utils.h"
+#include "debug_utils.h"
+#include "tilermem.h"
+#include "tilermem_utils.h"
+#include "memmgr.h"
+
+/* list of allocations */
+struct _AllocData {
+ struct tiler_buf_info buf;
+ int buf_type;
+ struct _AllocList {
+ struct _AllocList *next, *last;
+ struct _AllocData *me;
+ } link;
+};
+static struct _AllocList bufs = {0};
+static int bufs_inited = 0;
+
+typedef struct _AllocList _AllocList;
+typedef struct _AllocData _AllocData;
+
+static int refCnt = 0;
+static int td = -1;
+static pthread_mutex_t ref_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t che_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/**
+ * Initializes the static structures
+ *
+ * @author a0194118 (9/8/2009)
+ */
+static void init()
+{
+ if (!bufs_inited)
+ {
+ DLIST_INIT(bufs);
+ bufs_inited = 1;
+ }
+}
+
+/**
+ * Increases the reference count. Initialized tiler if this was
+ * the first reference
+ *
+ * @author a0194118 (9/2/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int inc_ref()
+{
+ /* initialize tiler on first call */
+ pthread_mutex_lock(&ref_mutex);
+
+ int res = MEMMGR_ERR_NONE;
+
+ if (!refCnt++) {
+ /* initialize lists */
+ init();
+#ifndef STUB_TILER
+ td = open("/dev/tiler", O_RDWR | O_SYNC);
+ if (NOT_I(td,>=,0)) res = MEMMGR_ERR_GENERIC;
+#else
+ td = 2;
+ res = MEMMGR_ERR_NONE;
+#endif
+ }
+ if (res)
+ {
+ refCnt--;
+ }
+
+ pthread_mutex_unlock(&ref_mutex);
+ return res;
+}
+
+/**
+ * Decreases the reference count. Deinitialized tiler if this
+ * was the last reference
+ *
+ * @author a0194118 (9/2/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int dec_ref()
+{
+ pthread_mutex_lock(&ref_mutex);
+
+ int res = MEMMGR_ERR_NONE;;
+
+ if (refCnt <= 0) res = MEMMGR_ERR_GENERIC;
+ else if (!--refCnt) {
+#ifndef STUB_TILER
+ close(td);
+ td = -1;
+#endif
+ }
+
+ pthread_mutex_unlock(&ref_mutex);
+ return res;
+}
+
+/**
+ * Returns the default page stride for this block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param width Width of 2D container in bytes
+ *
+ * @return Stride
+ */
+static bytes_t def_stride(bytes_t width)
+{
+ return ROUND_UP_TO2POW(width, PAGE_SIZE);
+}
+
+/**
+ * Returns the bytes per pixel for the pixel format.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param pixelFormat Pixelformat
+ *
+ * @return Bytes per pixel
+ */
+static bytes_t def_bpp(pixel_fmt_t pixelFormat)
+{
+ return (pixelFormat == PIXEL_FMT_32BIT ? 4 :
+ pixelFormat == PIXEL_FMT_16BIT ? 2 : 1);
+}
+
+/**
+ * Returns the size of the supplied block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param blk Pointer to the tiler_block_info struct
+ *
+ * @return size of the block in bytes
+ */
+static bytes_t def_size(tiler_block_info *blk)
+{
+ return (blk->fmt == PIXEL_FMT_PAGE ?
+ def_stride(blk->dim.len) :
+ blk->dim.area.height * def_stride(blk->dim.area.width * def_bpp(blk->fmt)));
+}
+
+/**
+ * Returns the map size based on an offset and buffer size
+ *
+ * @author a0194118 (7/8/2010)
+ *
+ * @param size Size of buffer
+ * @param offs Buffer offset
+ *
+ * @return (page aligned) size for mapping
+ */
+static bytes_t map_size(bytes_t size, bytes_t offs)
+{
+ return def_stride(size + (offs & (PAGE_SIZE - 1)));
+}
+
+/**
+ * Records a buffer-pointer -- tiler-ID mapping for a specific
+ * buffer type.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param bufPtr Buffer pointer
+ * @param tiler_id Tiler ID
+ * @param buf_type Buffer type: BUF_ALLOCED or BUF_MAPPED
+ *
+ * @return 0 on success, -ENOMEM on memory allocation failure
+ */
+static int buf_cache_add(struct tiler_buf_info *buf, int buf_type)
+{
+ pthread_mutex_lock(&che_mutex);
+ _AllocData *ad = NEW(_AllocData);
+ if (ad)
+ {
+ memcpy(&ad->buf, buf, sizeof(ad->buf));
+ ad->buf_type = buf_type;
+ DLIST_MADD_BEFORE(bufs, ad, link);
+ }
+ pthread_mutex_unlock(&che_mutex);
+ return ad == NULL ? -ENOMEM : 0;
+}
+
+/**
+ * Retrieves the tiler ID for given pointer and buffer type from
+ * the records. If the pointer lies within a tracked buffer,
+ * the tiler ID is returned. Otherwise 0 is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param bufPtr Buffer pointer
+ * @param buf_type Buffer type: BUF_ALLOCED or BUF_MAPPED
+ *
+ * @return Tiler ID on success, 0 on failure.
+ */
+static void buf_cache_query(void *ptr, struct tiler_buf_info *buf,
+ int buf_type_mask)
+{
+ IN;
+ if(0) DP("in(p=%p,t=%d,bp*=%p)", ptr, buf_type_mask, buf->blocks[0].ptr);
+ _AllocData *ad;
+ pthread_mutex_lock(&che_mutex);
+ DLIST_MLOOP(bufs, ad, link) {
+ if(0) {
+ DP("got(%p-%p,%d)", ad->buf.blocks->ptr, ad->buf.blocks->ptr + ad->buf.length, ad->buf_type);
+ CHK_P(ad->buf.blocks->ptr,<=,ptr);
+ CHK_P(ptr,<,ad->buf.blocks->ptr + ad->buf.length);
+ CHK_I(ad->buf_type & buf_type_mask,!=,0);
+ CHK_P(buf->blocks->ptr,!=,0);
+ }
+ if ((ad->buf_type & buf_type_mask) &&
+ ad->buf.blocks->ptr <= ptr && ptr < ad->buf.blocks->ptr + ad->buf.length) {
+ memcpy(buf, &ad->buf, sizeof(*buf));
+ pthread_mutex_unlock(&che_mutex);
+ return;
+ }
+ }
+ pthread_mutex_unlock(&che_mutex);
+ ZERO(*buf);
+ OUT;
+}
+
+/**
+ * Retrieves the tiler ID for given buffer pointer and buffer
+ * type from the records. If the tiler ID is found, it is
+ * removed from the records as well.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param bufPtr Buffer pointer
+ * @param buf_type Buffer type: BUF_ALLOCED or BUF_MAPPED
+ *
+ * @return Tiler ID on success, 0 on failure.
+ */
+static void buf_cache_del(void *bufPtr, struct tiler_buf_info *buf,
+ int buf_type)
+{
+ _AllocData *ad;
+ pthread_mutex_lock(&che_mutex);
+ DLIST_MLOOP(bufs, ad, link) {
+ if (ad->buf.blocks->ptr == bufPtr && ad->buf_type == buf_type) {
+ memcpy(buf, &ad->buf, sizeof(*buf));
+ DLIST_REMOVE(ad->link);
+ FREE(ad);
+ pthread_mutex_unlock(&che_mutex);
+ return;
+ }
+ }
+ pthread_mutex_unlock(&che_mutex);
+ OUT;
+ return;
+}
+
+/**
+ * Checks the consistency of the internal record cache. The
+ * number of elements in the cache should equal to the number of
+ * references.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int cache_check()
+{
+ int num_bufs = 0;
+ pthread_mutex_lock(&che_mutex);
+
+ init();
+
+ _AllocData *ad;
+ DLIST_MLOOP(bufs, ad, link) { num_bufs++; }
+
+ pthread_mutex_unlock(&che_mutex);
+ return (num_bufs == refCnt) ? MEMMGR_ERR_NONE : MEMMGR_ERR_GENERIC;
+}
+
+static void dump_block(struct tiler_block_info *blk, char *prefix, char *suffix)
+{
+#if 0
+ switch (blk->fmt)
+ {
+ case TILFMT_PAGE:
+ P("%s [%d:(%d,%08x), p=%p(0x%x),l=0x%x,s=%d,%d+%d]%s", prefix, blk->group_id, blk->key, blk->id, blk->ptr, blk->ssptr,
+ blk->dim.len, blk->stride, blk->align, blk->offs, suffix);
+ break;
+ case TILFMT_8BIT:
+ case TILFMT_16BIT:
+ case TILFMT_32BIT:
+ P("%s [%d:(%d,%08x), p=%p(0x%x),%d*%d*%d,s=%d,%d+%d]%s", prefix, blk->group_id, blk->key, blk->id, blk->ptr, blk->ssptr,
+ blk->dim.area.width, blk->dim.area.height, def_bpp(blk->fmt) * 8,
+ blk->stride, blk->align, blk->offs, suffix);
+ break;
+ default:
+ P("%s*[%d:(%d,%08x), p=%p(0x%x),l=0x%x,s=%d,%d+%d,fmt=0x%x]%s", prefix, blk->group_id, blk->key, blk->id, blk->ptr,
+ blk->ssptr, blk->dim.len, blk->stride, blk->align, blk->offs, blk->fmt, suffix);
+ }
+#endif
+}
+
+static void dump_buf(struct tiler_buf_info* buf, char* prefix)
+{
+#if 0
+ P("%sbuf={n=%d,id=0x%x,len=0x%x", prefix, buf->num_blocks, buf->offset, buf->length);
+ int ix = 0;
+ for (ix = 0; ix < buf->num_blocks; ix++)
+ {
+ dump_block(buf->blocks + ix, "", ix + 1 == buf->num_blocks ? "}" : "");
+ }
+#endif
+}
+
+/**
+ * Returns the tiler format for an address
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param ssptr Address
+ *
+ * @return The tiler format
+ */
+static enum tiler_fmt tiler_get_fmt(SSPtr ssptr)
+{
+#ifndef STUB_TILER
+ return (ssptr == 0 ? TILFMT_INVALID :
+ ssptr < TILER_MEM_8BIT ? TILFMT_NONE :
+ ssptr < TILER_MEM_16BIT ? TILFMT_8BIT :
+ ssptr < TILER_MEM_32BIT ? TILFMT_16BIT :
+ ssptr < TILER_MEM_PAGED ? TILFMT_32BIT :
+ ssptr < TILER_MEM_END ? TILFMT_PAGE : TILFMT_NONE);
+#else
+ /* if emulating, we need to get through all allocated memory segments */
+ pthread_mutex_lock(&che_mutex);
+ init();
+ _AllocData *ad;
+ void *ptr = (void *) ssptr;
+ if (!ptr) return TILFMT_INVALID;
+ /* P("?%p", (void *)ssptr); */
+ DLIST_MLOOP(bufs, ad, link) {
+ int ix;
+ struct tiler_buf_info *buf = (struct tiler_buf_info *) ad->buf.offset;
+ /* P("buf[%d]", buf->num_blocks); */
+ for (ix = 0; ix < buf->num_blocks; ix++)
+ {
+ /* P("block[%p-%p]", buf->blocks[ix].ptr, buf->blocks[ix].ptr + def_size(buf->blocks + ix)); */
+ if (ptr >= buf->blocks[ix].ptr &&
+ ptr < buf->blocks[ix].ptr + def_size(buf->blocks + ix)) {
+ enum tiler_fmt fmt = buf->blocks[ix].fmt;
+ pthread_mutex_unlock(&che_mutex);
+ return fmt;
+ }
+ }
+ }
+ pthread_mutex_unlock(&che_mutex);
+ return TILFMT_NONE;
+#endif
+}
+
+
+/**
+ * Allocates a memory block using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk Pointer to the block info
+ *
+ * @return ssptr of block allocated, or 0 on error
+ */
+static int tiler_alloc(struct tiler_block_info *blk)
+{
+ dump_block(blk, "=(ta)=>", "");
+ blk->ptr = NULL;
+ int ret = A_S(ioctl(td, TILIOC_GBLK, blk),==,0);
+ dump_block(blk, "alloced: ", "");
+ return R_I(ret);
+}
+
+/**
+ * Frees a memory block using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk Pointer to the block info
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int tiler_free(struct tiler_block_info *blk)
+{
+ return R_I(ioctl(td, TILIOC_FBLK, blk));
+}
+
+/**
+ * Maps a memory block into tiler using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk Pointer to the block info
+ *
+ * @return ssptr of block mapped, or 0 on error
+ */
+static int tiler_map(struct tiler_block_info *blk)
+{
+ dump_block(blk, "=(tm)=>", "");
+ int ret = A_S(ioctl(td, TILIOC_MBLK, blk),==,0);
+ dump_block(blk, "mapped: ", "");
+ return R_I(ret);
+}
+
+/**
+ * Unmaps a memory block from tiler using tiler
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blk Pointer to the block info
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int tiler_unmap(struct tiler_block_info *blk)
+{
+ return ioctl(td, TILIOC_UMBLK, blk);
+}
+
+/**
+ * Registers a buffer structure with tiler, and maps the buffer
+ * into memory using tiler. On success, it writes the tiler ID
+ * of the buffer into the area pointed by tiler ID.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blks Pointer to array of block info structures
+ * @param num_blocks Number of blocks
+ * @param tiler_id Pointer to tiler ID.
+ *
+ * @return pointer to the mapped buffer.
+ */
+static void *tiler_mmap(struct tiler_block_info *blks, int num_blocks,
+ int buf_type)
+{
+ IN;
+
+ /* get size */
+ int ix;
+ bytes_t size;
+
+ /* register buffer with tiler */
+ struct tiler_buf_info buf;
+ buf.num_blocks = num_blocks;
+ /* work on copy in buf */
+ memcpy(buf.blocks, blks, sizeof(tiler_block_info) * num_blocks);
+#ifndef STUB_TILER
+ dump_buf(&buf, "==(RBUF)=>");
+ int ret = ioctl(td, TILIOC_RBUF, &buf);
+ dump_buf(&buf, "<=(RBUF)==");
+ if (NOT_I(ret,==,0)) return NULL;
+ size = buf.length;
+#else
+ /* save buffer in stub */
+ struct tiler_buf_info *buf_c = NEWN(struct tiler_buf_info,2);
+ buf.offset = (uint32_t) buf_c;
+#endif
+ if (NOT_P(buf.offset,!=,0)) return NULL;
+
+ /* map blocks to process space */
+#ifndef STUB_TILER
+ void *bufPtr = mmap(0, map_size(size, buf.offset),
+ PROT_READ | PROT_WRITE, MAP_SHARED,
+ td, buf.offset & ~(PAGE_SIZE - 1));
+ if (bufPtr == MAP_FAILED){
+ bufPtr = NULL;
+ } else {
+ bufPtr += buf.offset & (PAGE_SIZE - 1);
+ }
+ if(0) DP("ptr=%p", bufPtr);
+#else
+ void *bufPtr = malloc(size + PAGE_SIZE - 1);
+ buf_c[1].blocks[0].ptr = bufPtr;
+ bufPtr = ROUND_UP_TO2POW(bufPtr, PAGE_SIZE);
+ /* P("<= [0x%x]", size); */
+
+ /* fill out pointers - this is needed for caching 1D/2D type */
+ for (size = ix = 0; ix < num_blocks; ix++)
+ {
+ buf.blocks[ix].ptr = bufPtr ? bufPtr + size : bufPtr;
+ size += def_size(blks + ix);
+ }
+
+ memcpy(buf_c, &buf, sizeof(struct tiler_buf_info));
+#endif
+
+ if (bufPtr != NULL)
+ {
+ /* fill out pointers */
+ for (size = ix = 0; ix < num_blocks; ix++)
+ {
+ buf.blocks[ix].ptr = bufPtr + size;
+ /* P(" [0x%p]", buf.blocks[ix].ptr); */
+ size += def_size(blks + ix);
+#ifdef STUB_TILER
+ buf.blocks[ix].ssptr = (uint32_t) buf.blocks[ix].ptr;
+#else
+ CHK_I((buf.blocks[ix].ssptr & (PAGE_SIZE - 1)),==,((uint32_t) buf.blocks[ix].ptr & (PAGE_SIZE - 1)));
+#endif
+ }
+ }
+ /* if failed to map: unregister buffer */
+ if (NOT_P(bufPtr,!=,NULL) ||
+ /* or failed to cache tiler buffer */
+ NOT_I(buf_cache_add(&buf, buf_type),==,0))
+ {
+#ifndef STUB_TILER
+ A_I(ioctl(td, TILIOC_URBUF, &buf),==,0);
+#else
+ FREE(buf_c);
+ buf.offset = 0;
+#endif
+ } else {
+ /* update original from local copy */
+ memcpy(blks, buf.blocks, sizeof(tiler_block_info) * num_blocks);
+ }
+
+ return R_P(bufPtr);
+}
+
+/**
+ * Checks whether the tiler_block_info is filled in correctly.
+ * Verifies the pixel format, correct length, width and or
+ * height, the length/stride relationship for 1D buffers, and
+ * the correct stride for 2D buffers. Also verifies block size
+ * to be page sized if desired.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param blk Pointer to the tiler_block_info struct
+ * @param is_page_sized Whether the block needs to be page
+ * sized (fit on whole pages).
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int check_block(tiler_block_info *blk, bool is_page_sized)
+{
+ /* check pixelformat */
+ if (NOT_I(blk->fmt,>=,PIXEL_FMT_MIN) ||
+ NOT_I(blk->fmt,<=,PIXEL_FMT_MAX)) return MEMMGR_ERR_GENERIC;
+
+
+ if (blk->fmt == PIXEL_FMT_PAGE)
+ { /* check 1D buffers */
+
+ /* length must be multiple of stride if stride > 0 */
+ if (NOT_I(blk->dim.len,>,0) ||
+ (blk->stride && NOT_I(blk->dim.len % blk->stride,==,0)))
+ return MEMMGR_ERR_GENERIC;
+ }
+ else
+ { /* check 2D buffers */
+
+ /* check width, height and stride (must be the default stride or 0) */
+ bytes_t stride = def_stride(blk->dim.area.width * def_bpp(blk->fmt));
+ if (NOT_I(blk->dim.area.width,>,0) ||
+ NOT_I(blk->dim.area.height,>,0) ||
+ (blk->stride && NOT_I(blk->stride,==,stride)))
+ return MEMMGR_ERR_GENERIC;
+ }
+
+ if (is_page_sized && NOT_I(def_size(blk) & (PAGE_SIZE - 1),==,0))
+ return MEMMGR_ERR_GENERIC;
+
+ return MEMMGR_ERR_NONE;
+}
+
+/**
+ * Checks whether the block information is correct for map and
+ * alloc operations. Checks the number of blocks, and validity
+ * of each block. Warns if reserved member is not 0. Also
+ * checks if the alignment/offset requirements are consistent
+ * across the buffer
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blks Pointer to the block info array.
+ * @param num_blocks Number of blocks.
+ * @param num_pagesize_blocks Number of blocks that must be
+ * page sized (these must be in
+ * front)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+static int check_blocks(struct tiler_block_info *blks, int num_blocks,
+ int num_pagesize_blocks)
+{
+ /* check arguments */
+ if (NOT_I(num_blocks,>,0) ||
+ NOT_I(num_blocks,<=,TILER_MAX_NUM_BLOCKS)) return MEMMGR_ERR_GENERIC;
+
+ /* check block allocation params */
+ int ix;
+ for (ix = 0; ix < num_blocks; ix++)
+ {
+ struct tiler_block_info *blk = blks + ix;
+ CHK_I(blk->ssptr,==,0);
+ CHK_I(blk->id,==,0);
+ int ret = check_block(blk, ix < num_pagesize_blocks);
+
+ /* check alignment */
+ if (!ret)
+ {
+ }
+ if (ret)
+ {
+ DP("for block[%d]", ix);
+ return ret;
+ }
+
+
+ }
+
+ /* set alignment parameters */
+ return MEMMGR_ERR_NONE;
+}
+
+/**
+ * Resets the ptr and reserved fields of the block info
+ * structures.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param blks Pointer to the block info array.
+ * @param num_blocks Number of blocks.
+ */
+static void reset_blocks(struct tiler_block_info *blks, int num_blocks)
+{
+ int ix;
+ for (ix = 0; ix < num_blocks; ix++)
+ {
+ blks[ix].ssptr = 0;
+ blks[ix].id = 0;
+ blks[ix].ptr = NULL;
+ }
+
+}
+
+bytes_t MemMgr_PageSize()
+{
+ return PAGE_SIZE;
+}
+
+void *MemMgr_Alloc(MemAllocBlock blocks[], int num_blocks)
+{
+ IN;
+ void *bufPtr = NULL;
+
+ /* need to access ssptrs */
+ struct tiler_block_info *blks = (tiler_block_info *) blocks;
+
+ /* check block allocation params, and state */
+ if (NOT_I(check_blocks(blks, num_blocks, num_blocks - 1),==,0) ||
+ NOT_I(inc_ref(),==,0)) goto DONE;
+
+ /* ----- begin recoverable portion ----- */
+ int ix;
+
+ /* allocate each buffer using tiler driver and initialize block info */
+ for (ix = 0; ix < num_blocks; ix++)
+ {
+ if (ix)
+ {
+ /* continue offset between pages */
+ }
+ CHK_I(blks[ix].ptr,==,NULL);
+ if (NOT_I(tiler_alloc(blks + ix),==,0)) goto FAIL_ALLOC;
+ }
+
+ bufPtr = tiler_mmap(blks, num_blocks, BUF_ALLOCED);
+ if (A_P(bufPtr,!=,0)) goto DONE;
+
+ /* ------ error handling ------ */
+FAIL_ALLOC:
+ while (ix)
+ {
+ tiler_free(blks + --ix);
+ }
+
+ /* clear ssptr and ptr fields for all blocks */
+ reset_blocks(blks, num_blocks);
+
+ A_I(dec_ref(),==,0);
+DONE:
+ CHK_I(cache_check(),==,0);
+ return R_P(bufPtr);
+}
+
+int MemMgr_Free(void *bufPtr)
+{
+ IN;
+
+ int ret = MEMMGR_ERR_GENERIC;
+ struct tiler_buf_info buf;
+ ZERO(buf);
+
+ /* retrieve registered buffers from vsptr */
+ /* :NOTE: if this succeeds, Memory Allocator stops tracking this buffer */
+ buf_cache_del(bufPtr, &buf, BUF_ALLOCED);
+
+ if (A_L(buf.offset,!=,0))
+ {
+#ifndef STUB_TILER
+ dump_buf(&buf, "==(URBUF)=>");
+ ret = A_I(ioctl(td, TILIOC_URBUF, &buf),==,0);
+ dump_buf(&buf, "<=(URBUF)==");
+
+ /* free each block */
+ int ix;
+ for (ix = 0; ix < buf.num_blocks; ix++)
+ {
+ ERR_ADD(ret, tiler_free(buf.blocks + ix));
+ }
+
+ /* unmap buffer */
+ bufPtr = (void *)((uint32_t)bufPtr & ~(PAGE_SIZE - 1));
+ ERR_ADD(ret, munmap(bufPtr, map_size(buf.length, buf.offset)));
+#else
+ void *ptr = (void *) buf.offset;
+ FREE(ptr);
+ ret = MEMMGR_ERR_NONE;
+#endif
+ ERR_ADD(ret, dec_ref());
+ }
+
+ CHK_I(cache_check(),==,0);
+ return R_I(ret);
+}
+
+void *MemMgr_Map(MemAllocBlock blocks[], int num_blocks)
+{
+ IN;
+ void *bufPtr = NULL;
+
+ /* need to access ssptrs */
+ struct tiler_block_info *blks = (tiler_block_info *) blocks;
+
+ /* check block params, and state */
+ if (check_blocks(blks, num_blocks, num_blocks) ||
+ NOT_I(inc_ref(),==,0)) goto DONE;
+
+ /* we only map 1 page aligned 1D buffer for now */
+ if (NOT_I(num_blocks,==,1) ||
+ NOT_I(blocks[0].pixelFormat,==,PIXEL_FMT_PAGE) ||
+ NOT_I(blocks[0].dim.len & (PAGE_SIZE - 1),==,0) ||
+#ifdef STUB_TILER
+ NOT_I(MemMgr_IsMapped(blocks[0].ptr),==,0) ||
+#endif
+ NOT_I((uint32_t)blocks[0].ptr & (PAGE_SIZE - 1),==,0))
+ goto FAIL;
+
+ /* ----- begin recoverable portion ----- */
+ int ix;
+
+ /* allocate each buffer using tiler driver */
+ for (ix = 0; ix < num_blocks; ix++)
+ {
+ if (ix)
+ {
+ /* continue offset between pages */
+ }
+ if (NOT_I(blks[ix].ptr,!=,NULL) ||
+ NOT_I(tiler_map(blks + ix),==,0)) goto FAIL_MAP;
+ }
+
+ /* map bufer into tiler space and register with tiler manager */
+ bufPtr = tiler_mmap(blks, num_blocks, BUF_MAPPED);
+ if (A_P(bufPtr,!=,0)) goto DONE;
+
+ /* ------ error handling ------ */
+FAIL_MAP:
+ while (ix)
+ {
+ tiler_unmap(blks + --ix);
+ }
+
+FAIL:
+ /* clear ssptr and ptr fields for all blocks */
+ reset_blocks(blks, num_blocks);
+
+ A_I(dec_ref(),==,0);
+DONE:
+ CHK_I(cache_check(),==,0);
+ return R_P(bufPtr);
+}
+
+int MemMgr_UnMap(void *bufPtr)
+{
+ IN;
+
+ int ret = MEMMGR_ERR_GENERIC;
+ struct tiler_buf_info buf;
+ ZERO(buf);
+
+ /* retrieve registered buffers from vsptr */
+ /* :NOTE: if this succeeds, Memory Allocator stops tracking this buffer */
+ buf_cache_del(bufPtr, &buf, BUF_MAPPED);
+
+ if (A_L(buf.offset,!=,0))
+ {
+#ifndef STUB_TILER
+ dump_buf(&buf, "==(URBUF)=>");
+ ret = A_I(ioctl(td, TILIOC_URBUF, &buf),==,0);
+ dump_buf(&buf, "<=(URBUF)==");
+
+ /* unmap each block */
+ int ix;
+ for (ix = 0; ix < buf.num_blocks; ix++)
+ {
+ ERR_ADD(ret, tiler_unmap(buf.blocks + ix));
+ }
+
+ /* unmap buffer */
+ bufPtr = (void *)((uint32_t)bufPtr & ~(PAGE_SIZE - 1));
+ ERR_ADD(ret, munmap(bufPtr, map_size(buf.length, buf.offset)));
+#else
+ struct tiler_buf_info *ptr = (struct tiler_buf_info *) buf.offset;
+ FREE(ptr[1].blocks[0].ptr);
+ FREE(ptr);
+ ret = MEMMGR_ERR_NONE;
+#endif
+ ERR_ADD(ret, dec_ref());
+ }
+
+ CHK_I(cache_check(),==,0);
+ return R_I(ret);
+}
+
+bool MemMgr_Is1DBlock(void *ptr)
+{
+ IN;
+
+ SSPtr ssptr = TilerMem_VirtToPhys(ptr);
+ enum tiler_fmt fmt = tiler_get_fmt(ssptr);
+ return R_I(fmt == TILFMT_PAGE);
+}
+
+bool MemMgr_Is2DBlock(void *ptr)
+{
+ IN;
+
+ SSPtr ssptr = TilerMem_VirtToPhys(ptr);
+ enum tiler_fmt fmt = tiler_get_fmt(ssptr);
+ return R_I(fmt == TILFMT_8BIT || fmt == TILFMT_16BIT ||
+ fmt == TILFMT_32BIT);
+}
+
+bool MemMgr_IsMapped(void *ptr)
+{
+ IN;
+ SSPtr ssptr = TilerMem_VirtToPhys(ptr);
+ enum tiler_fmt fmt = tiler_get_fmt(ssptr);
+ return R_I(fmt == TILFMT_8BIT || fmt == TILFMT_16BIT ||
+ fmt == TILFMT_32BIT || fmt == TILFMT_PAGE);
+}
+
+bytes_t MemMgr_GetStride(void *ptr)
+{
+ IN;
+#ifndef STUB_TILER
+ struct tiler_buf_info buf;
+ ZERO(buf);
+
+ /* find block that this buffer belongs to */
+ buf_cache_query(ptr, &buf, BUF_ALLOCED | BUF_MAPPED);
+ void *bufPtr = buf.blocks[0].ptr;
+
+ A_I(inc_ref(),==,0);
+
+ /* for tiler mapped buffers, get saved stride information */
+ if (buf.offset)
+ {
+ /* walk through block to determine which stride we need */
+ int ix;
+ for (ix = 0; ix < buf.num_blocks; ix++)
+ {
+ bytes_t size = def_size(buf.blocks + ix);
+ if (bufPtr <= ptr && ptr < bufPtr + size) {
+ A_I(dec_ref(),==,0);
+ return R_UP(buf.blocks[ix].stride);
+ }
+ bufPtr += size;
+ }
+ A_I(dec_ref(),==,0);
+ DP("assert: should not ever get here");
+ return R_UP(0);
+ }
+ /* see if pointer is valid */
+ else if (TilerMem_VirtToPhys(ptr) == 0)
+ {
+ A_I(dec_ref(),==,0);
+ return R_UP(0);
+ }
+ A_I(dec_ref(),==,0);
+#else
+ /* if emulating, we need to get through all allocated memory segments */
+ pthread_mutex_lock(&che_mutex);
+ init();
+
+ _AllocData *ad;
+ if (!ptr) return R_UP(0);
+ DLIST_MLOOP(bufs, ad, link) {
+ int ix;
+ struct tiler_buf_info *buf = (struct tiler_buf_info *) ad->buf.offset;
+ for (ix = 0; ix < buf->num_blocks; ix++)
+ {
+ if (ptr >= buf->blocks[ix].ptr &&
+ ptr < buf->blocks[ix].ptr + def_size(buf->blocks + ix))
+ {
+ bytes_t stride = buf->blocks[ix].stride;
+ pthread_mutex_unlock(&che_mutex);
+ return R_UP(stride);
+ }
+ }
+ }
+ pthread_mutex_unlock(&che_mutex);
+#endif
+ return R_UP(PAGE_SIZE);
+}
+
+bytes_t TilerMem_GetStride(SSPtr ssptr)
+{
+ IN;
+ switch(tiler_get_fmt(ssptr))
+ {
+ case TILFMT_8BIT: return R_UP(TILER_STRIDE_8BIT);
+ case TILFMT_16BIT: return R_UP(TILER_STRIDE_16BIT);
+ case TILFMT_32BIT: return R_UP(TILER_STRIDE_32BIT);
+ case TILFMT_PAGE: return R_UP(PAGE_SIZE);
+ default: return R_UP(0);
+ }
+}
+
+SSPtr TilerMem_VirtToPhys(void *ptr)
+{
+#ifndef STUB_TILER
+ SSPtr ssptr = 0;
+ if(!NOT_I(inc_ref(),==,0))
+ {
+ ssptr = ioctl(td, TILIOC_GSSP, (unsigned long) ptr);
+ A_I(dec_ref(),==,0);
+ }
+ return (SSPtr)R_P(ssptr);
+#else
+ return (SSPtr)ptr;
+#endif
+}
+
+/**
+ * Internal Unit Test. Tests the static methods of this
+ * library. Assumes an unitialized state as well.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @return 0 for success, non-0 error value for failure.
+ */
+int __test__MemMgr()
+{
+ int ret = 0;
+
+ /* state check */
+ ret |= NOT_I(TILER_PAGE_WIDTH * TILER_PAGE_HEIGHT,==,PAGE_SIZE);
+ ret |= NOT_I(refCnt,==,0);
+ ret |= NOT_I(inc_ref(),==,0);
+ ret |= NOT_I(refCnt,==,1);
+ ret |= NOT_I(dec_ref(),==,0);
+ ret |= NOT_I(refCnt,==,0);
+
+ /* enumeration check */
+ ret |= NOT_I(PIXEL_FMT_8BIT,==,TILFMT_8BIT);
+ ret |= NOT_I(PIXEL_FMT_16BIT,==,TILFMT_16BIT);
+ ret |= NOT_I(PIXEL_FMT_32BIT,==,TILFMT_32BIT);
+ ret |= NOT_I(PIXEL_FMT_PAGE,==,TILFMT_PAGE);
+ ret |= NOT_I(sizeof(MemAllocBlock),==,sizeof(struct tiler_block_info));
+
+ /* void * arithmetic */
+ void *a = (void *)1000, *b = a + 2000, *c = (void *)3000;
+ ret |= NOT_P(b,==,c);
+
+ /* def_stride */
+ ret |= NOT_I(def_stride(0),==,0);
+ ret |= NOT_I(def_stride(1),==,PAGE_SIZE);
+ ret |= NOT_I(def_stride(PAGE_SIZE),==,PAGE_SIZE);
+ ret |= NOT_I(def_stride(PAGE_SIZE + 1),==,2 * PAGE_SIZE);
+
+ /* def_bpp */
+ ret |= NOT_I(def_bpp(PIXEL_FMT_32BIT),==,4);
+ ret |= NOT_I(def_bpp(PIXEL_FMT_16BIT),==,2);
+ ret |= NOT_I(def_bpp(PIXEL_FMT_8BIT),==,1);
+
+ /* def_size */
+ tiler_block_info blk = {0};
+ blk.fmt = TILFMT_8BIT;
+ blk.dim.area.width = PAGE_SIZE * 8 / 10;
+ blk.dim.area.height = 10;
+ ret |= NOT_I(def_size(&blk),==,10 * PAGE_SIZE);
+
+ blk.fmt = TILFMT_16BIT;
+ blk.dim.area.width = PAGE_SIZE * 7 / 10;
+ ret |= NOT_I(def_size(&blk),==,20 * PAGE_SIZE);
+ blk.dim.area.width = PAGE_SIZE * 4 / 10;
+ ret |= NOT_I(def_size(&blk),==,10 * PAGE_SIZE);
+
+ blk.fmt = TILFMT_32BIT;
+ ret |= NOT_I(def_size(&blk),==,20 * PAGE_SIZE);
+ blk.dim.area.width = PAGE_SIZE * 6 / 10;
+ ret |= NOT_I(def_size(&blk),==,30 * PAGE_SIZE);
+
+ return ret;
+}
+
diff --git a/tiler/memmgr.h b/tiler/memmgr.h
new file mode 100644
index 0000000..8f99904
--- /dev/null
+++ b/tiler/memmgr.h
@@ -0,0 +1,311 @@
+/*
+ * memmgr.h
+ *
+ * Memory Allocator Interface functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _MEMMGR_H_
+#define _MEMMGR_H_
+
+/* retrieve type definitions */
+#include "mem_types.h"
+
+/**
+ * Memory Allocator is responsible for:
+ * <ol>
+ * <li>Allocate 1D and 2D blocks and pack them into a buffer.
+ * <li>Free such allocated blocks
+ * <li>Map 1D buffers into tiler space
+ * <li>Unmap 1D buffers from tiler space
+ * <li>Verify if an address lies in 1D or 2D space, whether it
+ * is mapped (to tiler space)
+ * <li>Mapping Ducati memory blocks to host processor and vice
+ * versa.
+ * </ol>
+ *
+ * The allocator distinguishes between:
+ * <ul>
+ * <li>1D and 2D blocks
+ * <li>2D blocks allocated by MemAlloc are non-cacheable. All
+ * other blocks are cacheable (e.g. 1D blocks). Preallocated
+ * may or may not be cacheable, depending on how they've been
+ * allocated, but are assumed to be cacheable.
+ * <li>buffers (an ordered collection of one or more blocks
+ * mapped consecutively)
+ * </ul>
+ *
+ * The allocator tracks each buffer based on (addr, size).
+ *
+ * Also, via the tiler manager, it tracks each block. The tiler
+ * manager itself also tracks each buffer.
+ *
+ */
+
+/**
+ * Memory Allocator block specification
+ *
+ * Size of a 2D buffer is calculated as height * stride. stride
+ * is the smallest multiple of page size that is at least
+ * the width, and is set by MemMgr_Alloc.
+ *
+ * Size of a 1D buffer is calculated as length. stride is not
+ * set by MemMgr_Alloc, but it can be set by the user. length
+ * must be a multiple of stride unless stride is 0.
+ *
+ * @author a0194118 (9/1/2009)
+ */
+struct MemAllocBlock {
+ pixel_fmt_t pixelFormat; /* pixel format */
+ union {
+ struct {
+ pixels_t width; /* width of 2D buffer */
+ pixels_t height; /* height of 2D buffer */
+ } area;
+ bytes_t len; /* length of 1D buffer. Must be multiple of
+ stride if stride is not 0. */
+ } dim;
+ uint32_t stride; /* must be multiple of page size. Can be 0 only
+ if pixelFormat is PIXEL_FMT_PAGE. */
+ void *ptr; /* pointer to beginning of buffer */
+ uint32_t id; /* buffer ID - received at allocation */
+ uint32_t key; /* buffer key - given at allocation */
+ uint32_t group_id; /* group ID */
+ /* alignment requirements for ssptr: ssptr & (align - 1) == offs */
+ uint32_t reserved; /* system space address (used internally) */
+};
+
+typedef struct MemAllocBlock MemAllocBlock;
+
+/**
+ * Returns the page size. This is required for allocating 1D
+ * blocks that stack under any other blocks.
+ *
+ * @author a0194118 (9/3/2009)
+ *
+ * @return Page size.
+ */
+bytes_t MemMgr_PageSize();
+
+/**
+ * Allocates a buffer as a list of blocks (1D or 2D), and maps
+ * them so that they are packaged consecutively. Returns the
+ * pointer to the first block, or NULL on failure.
+ * <p>
+ * The size of each block other than the last must be a multiple
+ * of the page size. This ensures that the blocks stack
+ * correctly. Set stride to 0 to avoid stride/length alignment
+ * constraints. Stride of 2D blocks will be updated by this
+ * method.
+ * <p>
+ * 2D blocks will be non-cacheable, while 1D blocks will be
+ * cacheable.
+ * <p>
+ * On success, the buffer is registered with the memory
+ * allocator.
+ * <p>
+ * As a side effect, if the operation was successful, the ssptr
+ * fields of the block specification will be filled with the
+ * system-space addresses, while the ptr fields will be set to
+ * the individual blocks. The stride information is set for 2D
+ * blocks.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param blocks Block specification information. This
+ * should be an array of at least num_blocks
+ * elements.
+ * @param num_blocks Number of blocks to be included in the
+ * allocated memory segment
+ *
+ * @return Pointer to the buffer, which is also the pointer to
+ * the first allocated block. NULL if allocation failed.
+ */
+void *MemMgr_Alloc(MemAllocBlock blocks[], int num_blocks);
+
+/**
+ * Frees a buffer allocated by MemMgr_Alloc(). It fails for
+ * any buffer not allocated by MemMgr_Alloc() or one that has
+ * been already freed.
+ * <p>
+ * It also unregisters the buffer with the memory allocator.
+ * <p>
+ * This function unmaps the processor's virtual address to the
+ * tiler address for all blocks allocated, unregisters the
+ * buffer, and frees all of its tiler blocks.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param bufPtr Pointer to the buffer allocated (returned)
+ * by MemMgr_Alloc()
+ *
+ * @return 0 on success. Non-0 error value on failure.
+ */
+int MemMgr_Free(void *bufPtr);
+
+/**
+ * This function maps the user provided data buffer to the tiler
+ * space as blocks, and maps that area into the process space
+ * consecutively. You can map a data buffer multiple times,
+ * resulting in multiple mapping for the same buffer. However,
+ * you cannot map a buffer that is already mapped to tiler, e.g.
+ * a buffer pointer returned by this method.
+ *
+ * In phase 1 and 2, the supported configurations are:
+ * <ol>
+ * <li> Mapping exactly one 1D block to tiler space (e.g.
+ * MapIn1DMode).
+ * </ol>
+ *
+ * @author a0194118 (9/3/2009)
+ *
+ * @param blocks Block specification information. This
+ * should be an array of at least num_blocks
+ * elements. The ptr fields must contain the
+ * user allocated buffers for the block.
+ * These will be updated with the mapped
+ * addresses of these blocks on success.
+ *
+ * Each block must be page aligned. Length of
+ * each block also must be page aligned.
+ *
+ * @param num_blocks Number of blocks to be included in the
+ * mapped memory segment
+ *
+ * @return Pointer to the buffer, which is also the pointer to
+ * the first mapped block. NULL if allocation failed.
+ */
+void *MemMgr_Map(MemAllocBlock blocks[], int num_blocks);
+
+/**
+ * This function unmaps the user provided data buffer from tiler
+ * space that was mapped to the tiler space in paged mode using
+ * MemMgr_Map(). It also unmaps the buffer itself from the
+ * process space. Trying to unmap a previously unmapped buffer
+ * will fail.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param bufPtr Pointer to the buffer as returned by a
+ * previous call to MemMgr_MapIn1DMode()
+ *
+ * @return 0 on success. Non-0 error value on failure.
+ */
+int MemMgr_UnMap(void *bufPtr);
+
+/**
+ * Checks if a given virtual address is mapped by tiler manager
+ * to tiler space.
+ * <p>
+ * This function is equivalent to MemMgr_Is1DBuffer(ptr) ||
+ * MemMgr_Is2DBuffer(ptr). It retrieves the system space
+ * address that the virtual address maps to. If this system
+ * space address lies within the tiler area, the function
+ * returns TRUE.
+ *
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr Pointer to a virtual address
+ *
+ * @return TRUE (non-0) if the virtual address is within a
+ * buffer that was mapped into tiler space, e.g. by
+ * calling MemMgr_MapIn1DMode() or MemMgr_MapIn2DMode()
+ */
+bool MemMgr_IsMapped(void *ptr);
+
+/**
+ * Checks if a given virtual address lies in a tiler 1D buffer.
+ * <p>
+ * This function retrieves the system space address that the
+ * virtual address maps to. If this system space address is
+ * within the 1D tiler area, it is considered lying within a 1D
+ * buffer.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr Pointer to a virtual address
+ *
+ * @return TRUE (non-0) if the virtual address is within a
+ * mapped 1D tiler buffer. FALSE (0) if the virtual
+ * address is not mapped, invalid, or is mapped to an
+ * area other than a 1D tiler buffer. In phase 1,
+ * however, it is TRUE it the virtual address is mapped
+ * to the page-mode area of the tiler space.
+ */
+bool MemMgr_Is1DBlock(void *ptr);
+
+/**
+ * Checks if a given virtual address lies in a 2D buffer.
+ * <p>
+ * This function retrieves the system space address that the
+ * virtual address maps to. If this system space address is
+ * within the 2D tiler area, it is considered lying within a 2D
+ * buffer.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr Pointer to a virtual address
+ *
+ * @return TRUE (non-0) if the virtual address is within a
+ * mapped 2D buffer. FALSE (0) if the virtual address
+ * is not mapped, invalid, or is mapped to an area other
+ * than a 2D buffer. In phase 1, however, it is TRUE it
+ * the virtual address is mapped to any area of the
+ * tiler space other than page mode.
+ */
+bool MemMgr_Is2DBlock(void *ptr);
+
+/**
+ * Returns the stride corresponding to a virtual address. For
+ * 1D and 2D buffers it returns the stride supplied
+ * with/acquired during the allocation/mapping. For non-tiler
+ * buffers it returns the page size.
+ * <p>
+ * NOTE: on Ducati phase 1, stride should return 16K for 8-bit
+ * 2D buffers, 32K for 16-bit and 32-bit 2D buffers, the stride
+ * used for alloc/map for 1D buffers, and the page size for
+ * non-tiler buffers.
+ *
+ * For unmapped addresses it returns 0. However, this cannot be
+ * used to determine if an address is unmapped as 1D buffers
+ * could also have 0 stride (e.g. compressed buffers).
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr pointer to a virtual address
+ *
+ * @return The virtual stride of the block that contains the
+ * address.
+ */
+bytes_t MemMgr_GetStride(void *ptr);
+
+#endif
diff --git a/tiler/memmgr_test.c b/tiler/memmgr_test.c
new file mode 100644
index 0000000..2bb76b6
--- /dev/null
+++ b/tiler/memmgr_test.c
@@ -0,0 +1,1693 @@
+/*
+ * memmgr_test.c
+ *
+ * Memory Allocator Interface tests.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* retrieve type definitions */
+#define __DEBUG__
+#undef __DEBUG_ENTRY__
+#define __DEBUG_ASSERT__
+
+#define __MAP_OK__
+#undef __WRITE_IN_STRIDE__
+#undef STAR_TRACE_MEM
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+#include <utils.h>
+#include <list_utils.h>
+#include <debug_utils.h>
+#include <memmgr.h>
+#include <tilermem.h>
+#include <tilermem_utils.h>
+#include <testlib.h>
+
+/* for star_tiler_test */
+#include <fcntl.h> /* open() */
+#include <unistd.h> /* close() */
+#include <sys/ioctl.h> /* ioctl() */
+
+#define FALSE 0
+#define TESTERR_NOTIMPLEMENTED -65378
+
+#define MAX_ALLOCS 512
+
+#define TESTS\
+ T(alloc_1D_test(4096, 0))\
+ T(alloc_2D_test(64, 64, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(64, 64, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(64, 64, PIXEL_FMT_32BIT))\
+ T(alloc_NV12_test(64, 64))\
+ T(map_1D_test(4096, 0))\
+ T(alloc_1D_test(176 * 144 * 2, 0))\
+ T(alloc_2D_test(176, 144, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(176, 144, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(176, 144, PIXEL_FMT_32BIT))\
+ T(alloc_NV12_test(176, 144))\
+ T(map_1D_test(176 * 144 * 2, 0))\
+ T(alloc_1D_test(640 * 480 * 2, 0))\
+ T(alloc_2D_test(640, 480, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(640, 480, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(640, 480, PIXEL_FMT_32BIT))\
+ T(alloc_NV12_test(640, 480))\
+ T(map_1D_test(640 * 480 * 2, 0))\
+ T(alloc_1D_test(848 * 480 * 2, 0))\
+ T(alloc_2D_test(848, 480, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(848, 480, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(848, 480, PIXEL_FMT_32BIT))\
+ T(alloc_NV12_test(848, 480))\
+ T(map_1D_test(848 * 480 * 2, 0))\
+ T(alloc_1D_test(1280 * 720 * 2, 0))\
+ T(alloc_2D_test(1280, 720, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(1280, 720, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(1280, 720, PIXEL_FMT_32BIT))\
+ T(alloc_NV12_test(1280, 720))\
+ T(map_1D_test(1280 * 720 * 2, 0))\
+ T(alloc_1D_test(1920 * 1080 * 2, 0))\
+ T(alloc_2D_test(1920, 1080, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(1920, 1080, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(1920, 1080, PIXEL_FMT_32BIT))\
+ T(alloc_NV12_test(1920, 1080))\
+ T(map_1D_test(1920 * 1080 * 2, 0))\
+ T(map_1D_test(4096, 0))\
+ T(map_1D_test(8192, 0))\
+ T(map_1D_test(16384, 0))\
+ T(map_1D_test(32768, 0))\
+ T(map_1D_test(65536, 0))\
+ T(neg_alloc_tests())\
+ T(neg_free_tests())\
+ T(neg_map_tests())\
+ T(neg_unmap_tests())\
+ T(neg_check_tests())\
+ T(page_size_test())\
+ T(maxalloc_2D_test(2500, 32, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(2500, 16, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(1250, 16, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(5000, 32, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(5000, 16, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(2500, 16, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(alloc_2D_test(8193, 16, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(8193, 16, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(4097, 16, PIXEL_FMT_32BIT))\
+ T(alloc_2D_test(16384, 16, PIXEL_FMT_8BIT))\
+ T(alloc_2D_test(16384, 16, PIXEL_FMT_16BIT))\
+ T(alloc_2D_test(8192, 16, PIXEL_FMT_32BIT))\
+ T(!alloc_2D_test(16385, 16, PIXEL_FMT_8BIT))\
+ T(!alloc_2D_test(16385, 16, PIXEL_FMT_16BIT))\
+ T(!alloc_2D_test(8193, 16, PIXEL_FMT_32BIT))\
+ T(maxalloc_1D_test(4096, MAX_ALLOCS))\
+ T(maxalloc_2D_test(64, 64, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(64, 64, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(64, 64, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(maxalloc_NV12_test(64, 64, MAX_ALLOCS))\
+ T(maxmap_1D_test(4096, MAX_ALLOCS))\
+ T(maxalloc_1D_test(176 * 144 * 2, MAX_ALLOCS))\
+ T(maxalloc_2D_test(176, 144, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(176, 144, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(176, 144, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(maxalloc_NV12_test(176, 144, MAX_ALLOCS))\
+ T(maxmap_1D_test(176 * 144 * 2, MAX_ALLOCS))\
+ T(maxalloc_1D_test(640 * 480 * 2, MAX_ALLOCS))\
+ T(maxalloc_2D_test(640, 480, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(640, 480, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(640, 480, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(maxalloc_NV12_test(640, 480, MAX_ALLOCS))\
+ T(maxmap_1D_test(640 * 480 * 2, MAX_ALLOCS))\
+ T(maxalloc_1D_test(848 * 480 * 2, MAX_ALLOCS))\
+ T(maxalloc_2D_test(848, 480, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(848, 480, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(848, 480, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(maxalloc_NV12_test(848, 480, MAX_ALLOCS))\
+ T(maxmap_1D_test(848 * 480 * 2, MAX_ALLOCS))\
+ T(maxalloc_1D_test(1280 * 720 * 2, MAX_ALLOCS))\
+ T(maxalloc_2D_test(1280, 720, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(1280, 720, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(1280, 720, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(maxalloc_NV12_test(1280, 720, MAX_ALLOCS))\
+ T(maxmap_1D_test(1280 * 720 * 2, MAX_ALLOCS))\
+ T(maxalloc_1D_test(1920 * 1080 * 2, MAX_ALLOCS))\
+ T(maxalloc_2D_test(1920, 1080, PIXEL_FMT_8BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(1920, 1080, PIXEL_FMT_16BIT, MAX_ALLOCS))\
+ T(maxalloc_2D_test(1920, 1080, PIXEL_FMT_32BIT, MAX_ALLOCS))\
+ T(maxalloc_NV12_test(1920, 1080, 2))\
+ T(maxalloc_NV12_test(1920, 1080, MAX_ALLOCS))\
+ T(maxmap_1D_test(1920 * 1080 * 2, MAX_ALLOCS))\
+ T(star_tiler_test(1000, 10))\
+ T(star_tiler_test(1000, 30))\
+ T(star_test(100, 10))\
+ T(star_test(1000, 10))\
+
+/* this is defined in memmgr.c, but not exported as it is for internal
+ use only */
+extern int __test__MemMgr();
+
+/**
+ * Returns the default page stride for this block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param width Width of 2D container
+ *
+ * @return Stride
+ */
+static bytes_t def_stride(bytes_t width)
+{
+ return ROUND_UP_TO2POW(width, PAGE_SIZE);
+}
+
+/**
+ * Returns the bytes per pixel for the pixel format.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param pixelFormat Pixelformat
+ *
+ * @return Bytes per pixel
+ */
+static bytes_t def_bpp(pixel_fmt_t pixelFormat)
+{
+ return (pixelFormat == PIXEL_FMT_32BIT ? 4 :
+ pixelFormat == PIXEL_FMT_16BIT ? 2 : 1);
+}
+
+/**
+ * This method fills up a range of memory using a start address
+ * and start value. The method of filling ensures that
+ * accidentally overlapping regions have minimal chances of
+ * matching, even if the same starting value is used. This is
+ * because the difference between successive values varies as
+ * such. This series only repeats after 704189 values, so the
+ * probability of a match for a range of at least 2 values is
+ * less than 2*10^-11.
+ *
+ * V(i + 1) - V(i) = { 1, 2, 3, ..., 65535, 2, 4, 6, 8 ...,
+ * 65534, 3, 6, 9, 12, ..., 4, 8, 12, 16, ... }
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start start value
+ * @param block pointer to block info strucure
+ */
+void fill_mem(uint16_t start, MemAllocBlock *block)
+{
+ IN;
+ uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+ bytes_t height, width, stride, i;
+ if (block->pixelFormat == PIXEL_FMT_PAGE)
+ {
+ height = 1;
+ stride = width = block->dim.len;
+ }
+ else
+ {
+ height = block->dim.area.height;
+ width = block->dim.area.width;
+ stride = block->stride;
+ }
+ width *= def_bpp(block->pixelFormat);
+ bytes_t size = height * stride;
+
+ P("(%p,0x%x*0x%x,s=0x%x)=0x%x", block->ptr, width, height, stride, start);
+
+ CHK_I(width,<=,stride);
+ uint32_t *ptr32 = (uint32_t *)ptr;
+ while (height--)
+ {
+ if (block->pixelFormat == PIXEL_FMT_32BIT)
+ {
+ for (i = 0; i < width; i += sizeof(uint32_t))
+ {
+ uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+ *ptr32++ = val;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+ {
+ *ptr32++ = 0;
+ i += sizeof(uint32_t);
+ }
+#else
+ ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+ }
+ else
+ {
+ for (i = 0; i < width; i += sizeof(uint16_t))
+ {
+ *ptr++ = start;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+ {
+ *ptr++ = 0;
+ i += sizeof(uint16_t);
+ }
+#else
+ ptr += (stride - i) / sizeof(uint16_t);
+#endif
+
+ }
+ }
+ CHK_P((block->pixelFormat == PIXEL_FMT_32BIT ? (void *)ptr32 : (void *)ptr),==,
+ (block->ptr + size));
+ OUT;
+}
+
+/**
+ * This verifies if a range of memory at a given address was
+ * filled up using the start value.
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start start value
+ * @param block pointer to block info strucure
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int check_mem(uint16_t start, MemAllocBlock *block)
+{
+ IN;
+ uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+ bytes_t height, width, stride, r, i;
+ if (block->pixelFormat == PIXEL_FMT_PAGE)
+ {
+ height = 1;
+ stride = width = block->dim.len;
+ }
+ else
+ {
+ height = block->dim.area.height;
+ width = block->dim.area.width;
+ stride = block->stride;
+ }
+ width *= def_bpp(block->pixelFormat);
+
+ CHK_I(width,<=,stride);
+ uint32_t *ptr32 = (uint32_t *)ptr;
+ for (r = 0; r < height; r++)
+ {
+ if (block->pixelFormat == PIXEL_FMT_32BIT)
+ {
+ for (i = 0; i < width; i += sizeof(uint32_t))
+ {
+ uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+ if (*ptr32++ != val) {
+ DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr32, val);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+ {
+ if (*ptr32++) {
+ DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr32);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ i += sizeof(uint32_t);
+ }
+#else
+ ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+ }
+ else
+ {
+ for (i = 0; i < width; i += sizeof(uint16_t))
+ {
+ if (*ptr++ != start) {
+ DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr, start);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+ {
+ if (*ptr++) {
+ DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ i += sizeof(uint16_t);
+ }
+#else
+ ptr += (stride - i) / sizeof(uint16_t);
+#endif
+ }
+ }
+ return R_I(MEMMGR_ERR_NONE);
+}
+
+/**
+ * This method allocates a 1D tiled buffer of the given length
+ * and stride using MemMgr_Alloc. If successful, it checks
+ * that the block information was updated with the pointer to
+ * the block. Additionally, it verifies the correct return
+ * values for MemMgr_IsMapped, MemMgr_Is1DBlock,
+ * MemMgr_Is2DBlock, MemMgr_GetStride, TilerMem_GetStride. It
+ * also verifies TilerMem_VirtToPhys using an internally stored
+ * value of the ssptr. If any of these verifications fail, the
+ * buffer is freed. Otherwise, it is filled using the given
+ * start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length Buffer length
+ * @param stride Buffer stride
+ * @param val Fill start value
+ *
+ * @return pointer to the allocated buffer, or NULL on failure
+ */
+void *alloc_1D(bytes_t length, bytes_t stride, uint16_t val)
+{
+ MemAllocBlock block;
+ memset(&block, 0, sizeof(block));
+
+ block.pixelFormat = PIXEL_FMT_PAGE;
+ block.dim.len = length;
+ block.stride = stride;
+
+ void *bufPtr = MemMgr_Alloc(&block, 1);
+ CHK_P(bufPtr,==,block.ptr);
+ if (bufPtr) {
+ if (NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+ NOT_I(MemMgr_Is1DBlock(bufPtr),!=,0) ||
+ NOT_I(MemMgr_Is2DBlock(bufPtr),==,0) ||
+ NOT_I(MemMgr_GetStride(bufPtr),==,block.stride) ||
+ NOT_P(TilerMem_VirtToPhys(bufPtr),==,block.reserved) ||
+ NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,PAGE_SIZE) ||
+ NOT_L((PAGE_SIZE - 1) & (long)bufPtr,==,(PAGE_SIZE - 1) & block.reserved))
+ {
+ MemMgr_Free(bufPtr);
+ return NULL;
+ }
+ fill_mem(val, &block);
+ }
+ return bufPtr;
+}
+
+/**
+ * This method frees a 1D tiled buffer. The given length,
+ * stride and start values are used to verify that the buffer is
+ * still correctly filled. In the event of any errors, the
+ * error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length Buffer length
+ * @param stride Buffer stride
+ * @param val Fill start value
+ * @param bufPtr Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_1D(bytes_t length, bytes_t stride, uint16_t val, void *bufPtr)
+{
+ MemAllocBlock block;
+ memset(&block, 0, sizeof(block));
+
+ block.pixelFormat = PIXEL_FMT_PAGE;
+ block.dim.len = length;
+ block.stride = stride;
+ block.ptr = bufPtr;
+
+ int ret = A_I(check_mem(val, &block),==,0);
+ ERR_ADD(ret, MemMgr_Free(bufPtr));
+ return ret;
+}
+
+/**
+ * This method allocates a 2D tiled buffer of the given width,
+ * height, stride and pixel format using
+ * MemMgr_Alloc. If successful, it checks that the block
+ * information was updated with the pointer to the block.
+ * Additionally, it verifies the correct return values for
+ * MemMgr_IsMapped, MemMgr_Is1DBlock, MemMgr_Is2DBlock,
+ * MemMgr_GetStride, TilerMem_GetStride. It also verifies
+ * TilerMem_VirtToPhys using an internally stored value of the
+ * ssptr. If any of these verifications fail, the buffer is
+ * freed. Otherwise, it is filled using the given start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ * @param fmt Pixel format
+ * @param stride Buffer stride
+ * @param val Fill start value
+ *
+ * @return pointer to the allocated buffer, or NULL on failure
+ */
+void *alloc_2D(pixels_t width, pixels_t height, pixel_fmt_t fmt, bytes_t stride,
+ uint16_t val)
+{
+ MemAllocBlock block;
+ memset(&block, 0, sizeof(block));
+
+ block.pixelFormat = fmt;
+ block.dim.area.width = width;
+ block.dim.area.height = height;
+ block.stride = stride;
+
+ void *bufPtr = MemMgr_Alloc(&block, 1);
+ CHK_P(bufPtr,==,block.ptr);
+ if (bufPtr) {
+ bytes_t cstride = (fmt == PIXEL_FMT_8BIT ? TILER_STRIDE_8BIT :
+ fmt == PIXEL_FMT_16BIT ? TILER_STRIDE_16BIT :
+ TILER_STRIDE_32BIT);
+
+ if (NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+ NOT_I(MemMgr_Is1DBlock(bufPtr),==,0) ||
+ NOT_I(MemMgr_Is2DBlock(bufPtr),!=,0) ||
+ NOT_I(block.stride,!=,0) ||
+ NOT_I(MemMgr_GetStride(bufPtr),==,block.stride) ||
+ NOT_P(TilerMem_VirtToPhys(bufPtr),==,block.reserved) ||
+ NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,cstride) ||
+ NOT_L((PAGE_SIZE - 1) & (long)bufPtr,==,(PAGE_SIZE - 1) & block.reserved))
+ {
+ MemMgr_Free(bufPtr);
+ return NULL;
+ }
+ fill_mem(val, &block);
+ }
+ return bufPtr;
+}
+
+/**
+ * This method frees a 2D tiled buffer. The given width,
+ * height, pixel format, stride and start values are used to
+ * verify that the buffer is still correctly filled. In the
+ * event of any errors, the error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ * @param fmt Pixel format
+ * @param stride Buffer stride
+ * @param val Fill start value
+ * @param bufPtr Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_2D(pixels_t width, pixels_t height, pixel_fmt_t fmt, bytes_t stride,
+ uint16_t val, void *bufPtr)
+{
+ MemAllocBlock block;
+ memset(&block, 0, sizeof(block));
+
+ block.pixelFormat = fmt;
+ block.dim.area.width = width;
+ block.dim.area.height = height;
+ block.stride = def_stride(width * def_bpp(fmt));
+ block.ptr = bufPtr;
+
+ int ret = A_I(check_mem(val, &block),==,0);
+ ERR_ADD(ret, MemMgr_Free(bufPtr));
+ return ret;
+}
+
+/**
+ * This method allocates an NV12 tiled buffer of the given width
+ * and height using MemMgr_Alloc. If successful, it checks that
+ * the block informations were updated with the pointers to the
+ * individual blocks. Additionally, it verifies the correct
+ * return values for MemMgr_IsMapped, MemMgr_Is1DBlock,
+ * MemMgr_Is2DBlock, MemMgr_GetStride, TilerMem_GetStride for
+ * both blocks. It also verifies TilerMem_VirtToPhys using an
+ * internally stored values of the ssptr. If any of these
+ * verifications fail, the buffer is freed. Otherwise, it is
+ * filled using the given start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ * @param val Fill start value
+ *
+ * @return pointer to the allocated buffer, or NULL on failure
+ */
+void *alloc_NV12(pixels_t width, pixels_t height, uint16_t val)
+{
+ MemAllocBlock blocks[2];
+ ZERO(blocks);
+
+ blocks[0].pixelFormat = PIXEL_FMT_8BIT;
+ blocks[0].dim.area.width = width;
+ blocks[0].dim.area.height = height;
+ blocks[1].pixelFormat = PIXEL_FMT_16BIT;
+ blocks[1].dim.area.width = width >> 1;
+ blocks[1].dim.area.height = height >> 1;
+
+ void *bufPtr = MemMgr_Alloc(blocks, 2);
+ CHK_P(blocks[0].ptr,==,bufPtr);
+ if (bufPtr) {
+ void *buf2 = bufPtr + blocks[0].stride * height;
+ if (NOT_P(blocks[1].ptr,==,buf2) ||
+ NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+ NOT_I(MemMgr_IsMapped(buf2),!=,0) ||
+ NOT_I(MemMgr_Is1DBlock(bufPtr),==,0) ||
+ NOT_I(MemMgr_Is1DBlock(buf2),==,0) ||
+ NOT_I(MemMgr_Is2DBlock(bufPtr),!=,0) ||
+ NOT_I(MemMgr_Is2DBlock(buf2),!=,0) ||
+ NOT_I(blocks[0].stride,!=,0) ||
+ NOT_I(blocks[1].stride,!=,0) ||
+ NOT_I(MemMgr_GetStride(bufPtr),==,blocks[0].stride) ||
+ NOT_I(MemMgr_GetStride(buf2),==,blocks[1].stride) ||
+ NOT_P(TilerMem_VirtToPhys(bufPtr),==,blocks[0].reserved) ||
+ NOT_P(TilerMem_VirtToPhys(buf2),==,blocks[1].reserved) ||
+ NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,TILER_STRIDE_8BIT) ||
+ NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(buf2)),==,TILER_STRIDE_16BIT) ||
+ NOT_L((PAGE_SIZE - 1) & (long)blocks[0].ptr,==,(PAGE_SIZE - 1) & blocks[0].reserved) ||
+ NOT_L((PAGE_SIZE - 1) & (long)blocks[1].ptr,==,(PAGE_SIZE - 1) & blocks[1].reserved))
+ {
+ MemMgr_Free(bufPtr);
+ return NULL;
+ }
+
+ fill_mem(val, blocks);
+ fill_mem(val, blocks + 1);
+ } else {
+ CHK_P(blocks[1].ptr,==,NULL);
+ }
+
+ return bufPtr;
+}
+
+/**
+ * This method frees an NV12 tiled buffer. The given width,
+ * height and start values are used to verify that the buffer is
+ * still correctly filled. In the event of any errors, the
+ * error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ * @param val Fill start value
+ * @param bufPtr Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_NV12(pixels_t width, pixels_t height, uint16_t val, void *bufPtr)
+{
+ MemAllocBlock blocks[2];
+ memset(blocks, 0, sizeof(blocks));
+
+ blocks[0].pixelFormat = PIXEL_FMT_8BIT;
+ blocks[0].dim.area.width = width;
+ blocks[0].dim.area.height = height;
+ blocks[0].stride = def_stride(width);
+ blocks[0].ptr = bufPtr;
+ blocks[1].pixelFormat = PIXEL_FMT_16BIT;
+ blocks[1].dim.area.width = width >> 1;
+ blocks[1].dim.area.height = height >> 1;
+ blocks[1].stride = def_stride(width);
+ blocks[1].ptr = bufPtr + blocks[0].stride * height;
+
+ int ret = A_I(check_mem(val, blocks),==,0);
+ ERR_ADD(ret, check_mem(val, blocks + 1));
+ ERR_ADD(ret, MemMgr_Free(bufPtr));
+ return ret;
+}
+
+/**
+ * This method maps a preallocated 1D buffer of the given length
+ * and stride into tiler space using MemMgr_Map. The mapped
+ * address must differ from the supplied address is successful.
+ * Moreover, it checks that the block information was
+ * updated with the pointer to the block. Additionally, it
+ * verifies the correct return values for MemMgr_IsMapped,
+ * MemMgr_Is1DBlock, MemMgr_Is2DBlock, MemMgr_GetStride,
+ * TilerMem_GetStride. It also verifies TilerMem_VirtToPhys
+ * using an internally stored value of the ssptr. If any of
+ * these verifications fail, the buffer is unmapped. Otherwise,
+ * the original buffer is filled using the given start value.
+ *
+ * :TODO: how do we verify the mapping?
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param dataPtr Pointer to the allocated buffer
+ * @param length Buffer length
+ * @param stride Buffer stride
+ * @param val Fill start value
+ *
+ * @return pointer to the mapped buffer, or NULL on failure
+ */
+void *map_1D(void *dataPtr, bytes_t length, bytes_t stride, uint16_t val)
+{
+ MemAllocBlock block;
+ memset(&block, 0, sizeof(block));
+
+ block.pixelFormat = PIXEL_FMT_PAGE;
+ block.dim.len = length;
+ block.stride = stride;
+ block.ptr = dataPtr;
+
+ void *bufPtr = MemMgr_Map(&block, 1);
+ CHK_P(bufPtr,==,block.ptr);
+ if (bufPtr) {
+ if (NOT_P(bufPtr,!=,dataPtr) ||
+ NOT_I(MemMgr_IsMapped(bufPtr),!=,0) ||
+ NOT_I(MemMgr_Is1DBlock(bufPtr),!=,0) ||
+ NOT_I(MemMgr_Is2DBlock(bufPtr),==,0) ||
+ NOT_I(MemMgr_GetStride(bufPtr),==,block.stride) ||
+ NOT_P(TilerMem_VirtToPhys(bufPtr),==,block.reserved) ||
+ NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(bufPtr)),==,PAGE_SIZE) ||
+ NOT_L((PAGE_SIZE - 1) & (long)bufPtr,==,0) ||
+ NOT_L((PAGE_SIZE - 1) & block.reserved,==,0))
+ {
+ MemMgr_UnMap(bufPtr);
+ return NULL;
+ }
+ block.ptr = dataPtr;
+ fill_mem(val, &block);
+ }
+ return bufPtr;
+}
+
+/**
+ * This method unmaps a 1D tiled buffer. The given data
+ * pointer, length, stride and start values are used to verify
+ * that the buffer is still correctly filled. In the event of
+ * any errors, the error value is returned.
+ *
+ * :TODO: how do we verify the mapping?
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param dataPtr Pointer to the preallocated buffer
+ * @param length Buffer length
+ * @param stride Buffer stride
+ * @param val Fill start value
+ * @param bufPtr Pointer to the mapped buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int unmap_1D(void *dataPtr, bytes_t length, bytes_t stride, uint16_t val, void *bufPtr)
+{
+ MemAllocBlock block;
+ memset(&block, 0, sizeof(block));
+
+ block.pixelFormat = PIXEL_FMT_PAGE;
+ block.dim.len = length;
+ block.stride = stride;
+ block.ptr = dataPtr;
+ int ret = A_I(check_mem(val, &block),==,0);
+ ERR_ADD(ret, MemMgr_UnMap(bufPtr));
+ return ret;
+}
+
+/**
+ * Tests the MemMgr_PageSize method.
+ *
+ * @author a0194118 (9/15/2009)
+ *
+ * @return 0 on success, non-0 error value on failure.
+ */
+int page_size_test()
+{
+ return NOT_I(MemMgr_PageSize(),==,PAGE_SIZE);
+}
+
+/**
+ * This method tests the allocation and freeing of a 1D tiled
+ * buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length Buffer length
+ * @param stride Buffer stride
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int alloc_1D_test(bytes_t length, bytes_t stride)
+{
+ printf("Allocate & Free %ub 1D buffer\n", length);
+
+ uint16_t val = (uint16_t) rand();
+ void *ptr = alloc_1D(length, stride, val);
+ if (!ptr) return 1;
+ int res = free_1D(length, stride, val, ptr);
+ return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a 2D tiled
+ * buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ * @param fmt Pixel format
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int alloc_2D_test(pixels_t width, pixels_t height, pixel_fmt_t fmt)
+{
+ printf("Allocate & Free %ux%ux%ub 1D buffer\n", width, height, def_bpp(fmt));
+
+ uint16_t val = (uint16_t) rand();
+ void *ptr = alloc_2D(width, height, fmt, 0, val);
+ if (!ptr) return 1;
+ int res = free_2D(width, height, fmt, 0, val, ptr);
+ return res;
+}
+
+/**
+ * This method tests the allocation and freeing of an NV12 tiled
+ * buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int alloc_NV12_test(pixels_t width, pixels_t height)
+{
+ printf("Allocate & Free %ux%u NV12 buffer\n", width, height);
+
+ uint16_t val = (uint16_t) rand();
+ void *ptr = alloc_NV12(width, height, val);
+ if (!ptr) return 1;
+ int res = free_NV12(width, height, val, ptr);
+ return res;
+}
+
+/**
+ * This method tests the mapping and unmapping of a 1D buffer.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length Buffer length
+ * @param stride Buffer stride
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int map_1D_test(bytes_t length, bytes_t stride)
+{
+ length = (length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+ printf("Mapping and UnMapping 0x%xb 1D buffer\n", length);
+
+#ifdef __MAP_OK__
+ /* allocate aligned buffer */
+ void *buffer = malloc(length + PAGE_SIZE - 1);
+ void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ uint16_t val = (uint16_t) rand();
+ void *ptr = map_1D(dataPtr, length, stride, val);
+ if (!ptr) return 1;
+ int res = unmap_1D(dataPtr, length, stride, val, ptr);
+ FREE(buffer);
+#else
+ int res = TESTERR_NOTIMPLEMENTED;
+#endif
+ return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a number of
+ * 1D tiled buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length Buffer length
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxalloc_1D_test(bytes_t length, int max_allocs)
+{
+ printf("Allocate & Free max # of %ub 1D buffers\n", length);
+
+ struct data {
+ uint16_t val;
+ void *bufPtr;
+ } *mem;
+
+ /* allocate as many buffers as we can */
+ mem = NEWN(struct data, max_allocs);
+ void *ptr = (void *)mem;
+ int ix, res = 0;
+ for (ix = 0; ptr && ix < max_allocs;)
+ {
+ uint16_t val = (uint16_t) rand();
+ ptr = alloc_1D(length, 0, val);
+ if (ptr)
+ {
+ mem[ix].val = val;
+ mem[ix].bufPtr = ptr;
+ ix++;
+ }
+ }
+
+ P(":: Allocated %d buffers", ix);
+
+ while (ix--)
+ {
+ ERR_ADD(res, free_1D(length, 0, mem[ix].val, mem[ix].bufPtr));
+ }
+ FREE(mem);
+ return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a number of
+ * 2D tiled buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ * @param fmt Pixel format
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxalloc_2D_test(pixels_t width, pixels_t height, pixel_fmt_t fmt, int max_allocs)
+{
+ printf("Allocate & Free max # of %ux%ux%ub 1D buffers\n", width, height, def_bpp(fmt));
+
+ struct data {
+ uint16_t val;
+ void *bufPtr;
+ } *mem;
+
+ /* allocate as many buffers as we can */
+ mem = NEWN(struct data, max_allocs);
+ void *ptr = (void *)mem;
+ int ix, res = 0;
+ for (ix = 0; ptr && ix < max_allocs;)
+ {
+ uint16_t val = (uint16_t) rand();
+ ptr = alloc_2D(width, height, fmt, 0, val);
+ if (ptr)
+ {
+ mem[ix].val = val;
+ mem[ix].bufPtr = ptr;
+ ix++;
+ }
+ }
+
+ P(":: Allocated %d buffers", ix);
+
+ while (ix--)
+ {
+ ERR_ADD(res, free_2D(width, height, fmt, 0, mem[ix].val, mem[ix].bufPtr));
+ }
+ FREE(mem);
+ return res;
+}
+
+/**
+ * This method tests the allocation and freeing of a number of
+ * NV12 tiled buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param width Buffer width
+ * @param height Buffer height
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxalloc_NV12_test(pixels_t width, pixels_t height, int max_allocs)
+{
+ printf("Allocate & Free max # of %ux%u NV12 buffers\n", width, height);
+
+ struct data {
+ uint16_t val;
+ void *bufPtr;
+ } *mem;
+
+ /* allocate as many buffers as we can */
+ mem = NEWN(struct data, max_allocs);
+ void *ptr = (void *)mem;
+ int ix, res = 0;
+ for (ix = 0; ptr && ix < max_allocs;)
+ {
+ uint16_t val = (uint16_t) rand();
+ ptr = alloc_NV12(width, height, val);
+ if (ptr)
+ {
+ mem[ix].val = val;
+ mem[ix].bufPtr = ptr;
+ ix++;
+ }
+ }
+
+ P(":: Allocated %d buffers", ix);
+
+ while (ix--)
+ {
+ ERR_ADD(res, free_NV12(width, height, mem[ix].val, mem[ix].bufPtr));
+ }
+ FREE(mem);
+ return res;
+}
+
+/**
+ * This method tests the mapping and unnapping of a number of
+ * 1D buffers (up to MAX_ALLOCS)
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param length Buffer length
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int maxmap_1D_test(bytes_t length, int max_maps)
+{
+ length = (length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+ printf("Map & UnMap max # of %xb 1D buffers\n", length);
+
+#ifdef __MAP_OK__
+ struct data {
+ uint16_t val;
+ void *bufPtr, *buffer, *dataPtr;
+ } *mem;
+
+ /* map as many buffers as we can */
+ mem = NEWN(struct data, max_maps);
+ void *ptr = (void *)mem;
+ int ix, res = 0;
+ for (ix = 0; ptr && ix < max_maps;)
+ {
+ /* allocate aligned buffer */
+ ptr = malloc(length + PAGE_SIZE - 1);
+ if (ptr)
+ {
+ void *buffer = ptr;
+ void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ uint16_t val = (uint16_t) rand();
+ ptr = map_1D(dataPtr, length, 0, val);
+ if (ptr)
+ {
+ mem[ix].val = val;
+ mem[ix].bufPtr = ptr;
+ mem[ix].buffer = buffer;
+ mem[ix].dataPtr = dataPtr;
+ ix++;
+ }
+ else
+ {
+ FREE(buffer);
+ break;
+ }
+ }
+ }
+
+ P(":: Mapped %d buffers", ix);
+
+ while (ix--)
+ {
+ ERR_ADD(res, unmap_1D(mem[ix].dataPtr, length, 0, mem[ix].val, mem[ix].bufPtr));
+ FREE(mem[ix].buffer);
+ }
+#else
+ int res = TESTERR_NOTIMPLEMENTED;
+#endif
+ return res;
+}
+
+/**
+ * This stress tests allocates/maps/frees/unmaps buffers at
+ * least num_ops times. The test maintains a set of slots that
+ * are initially NULL. For each operation, a slot is randomly
+ * selected. If the slot is not used, it is filled randomly
+ * with a 1D, 2D, NV12 or mapped buffer. If it is used, the
+ * slot is cleared by freeing/unmapping the buffer already
+ * there. The buffers are filled on alloc/map and this is
+ * checked on free/unmap to verify that there was no memory
+ * corruption. Failed allocation and maps are ignored as we may
+ * run out of memory. The return value is the first error code
+ * encountered, or 0 on success.
+ *
+ * This test sets the seed so that it produces reproducible
+ * results.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_ops Number of operations to perform
+ * @param num_slots Number of slots to maintain
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int star_test(uint32_t num_ops, uint16_t num_slots)
+{
+ printf("Random set of %d Allocs/Maps and Frees/UnMaps for %d slots\n", num_ops, num_slots);
+ srand(0x4B72316A);
+ struct data {
+ int op;
+ uint16_t val;
+ pixels_t width, height;
+ bytes_t length;
+ void *bufPtr;
+ void *buffer;
+ void *dataPtr;
+ } *mem;
+
+ /* allocate memory state */
+ mem = NEWN(struct data, num_slots);
+ if (!mem) return NOT_P(mem,!=,NULL);
+
+ /* perform alloc/free/unmaps */
+ int res = 0, ix;
+ while (!res && num_ops--)
+ {
+ ix = rand() % num_slots;
+ /* see if we need to free/unmap data */
+ if (mem[ix].bufPtr)
+ {
+ /* check memory fill */
+ switch (mem[ix].op)
+ {
+ case 0: res = unmap_1D(mem[ix].dataPtr, mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr);
+ FREE(mem[ix].buffer);
+ break;
+ case 1: res = free_1D(mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr); break;
+ case 2: res = free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_8BIT, 0, mem[ix].val, mem[ix].bufPtr); break;
+ case 3: res = free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_16BIT, 0, mem[ix].val, mem[ix].bufPtr); break;
+ case 4: res = free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_32BIT, 0, mem[ix].val, mem[ix].bufPtr); break;
+ case 5: res = free_NV12(mem[ix].width, mem[ix].height, mem[ix].val, mem[ix].bufPtr); break;
+ }
+ P("%s[%p]", mem[ix].op ? "free" : "unmap", mem[ix].bufPtr);
+ ZERO(mem[ix]);
+ }
+ /* we need to allocate/map data */
+ else
+ {
+ int op = rand();
+ /* set width */
+ pixels_t width, height;
+ switch ("AAAABBBBCCCDDEEF"[op & 15]) {
+ case 'F': width = 1920; height = 1080; break;
+ case 'E': width = 1280; height = 720; break;
+ case 'D': width = 640; height = 480; break;
+ case 'C': width = 848; height = 480; break;
+ case 'B': width = 176; height = 144; break;
+ case 'A': width = height = 64; break;
+ }
+ mem[ix].length = (bytes_t)width * height;
+ mem[ix].width = width;
+ mem[ix].height = height;
+ mem[ix].val = ((uint16_t)rand());
+
+ /* perform operation */
+ mem[ix].op = "AAABBBBCCCCDDDDE"[(op >> 4) & 15] - 'A';
+ switch (mem[ix].op)
+ {
+ case 0: /* map 1D buffer */
+#ifdef __MAP_OK__
+ /* allocate aligned buffer */
+ mem[ix].length = (mem[ix].length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+ mem[ix].buffer = malloc(mem[ix].length + PAGE_SIZE - 1);
+ if (mem[ix].buffer)
+ {
+ mem[ix].dataPtr = (void *)(((uint32_t)mem[ix].buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ mem[ix].bufPtr = map_1D(mem[ix].dataPtr, mem[ix].length, 0, mem[ix].val);
+ if (!mem[ix].bufPtr) FREE(mem[ix].buffer);
+ }
+ P("map[l=0x%x] = %p", mem[ix].length, mem[ix].bufPtr);
+ break;
+#else
+ mem[ix].op = 1;
+#endif
+ case 1:
+ mem[ix].bufPtr = alloc_1D(mem[ix].length, 0, mem[ix].val);
+ P("alloc[l=0x%x] = %p", mem[ix].length, mem[ix].bufPtr);
+ break;
+ case 2:
+ mem[ix].bufPtr = alloc_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_8BIT, 0, mem[ix].val);
+ P("alloc[%d*%d*8] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+ break;
+ case 3:
+ mem[ix].bufPtr = alloc_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_16BIT, 0, mem[ix].val);
+ P("alloc[%d*%d*16] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+ break;
+ case 4:
+ mem[ix].bufPtr = alloc_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_32BIT, 0, mem[ix].val);
+ P("alloc[%d*%d*32] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+ break;
+ case 5:
+ mem[ix].bufPtr = alloc_NV12(mem[ix].width, mem[ix].height, mem[ix].val);
+ P("alloc[%d*%d*NV12] = %p", mem[ix].width, mem[ix].height, mem[ix].bufPtr);
+ break;
+ }
+
+ /* check all previous buffers */
+#ifdef STAR_TRACE_MEM
+ for (ix = 0; ix < num_slots; ix++)
+ {
+ MemAllocBlock blk;
+ if (mem[ix].bufPtr)
+ {
+ if(0) P("ptr=%p, op=%d, w=%d, h=%d, l=%x, val=%x",
+ mem[ix].bufPtr, mem[ix].op, mem[ix].width, mem[ix].height,
+ mem[ix].length, mem[ix].val);
+ switch (mem[ix].op)
+ {
+ case 0: case 1:
+ blk.pixelFormat = PIXEL_FMT_PAGE;
+ blk.dim.len = mem[ix].length;
+ break;
+ case 5:
+ blk.pixelFormat = PIXEL_FMT_16BIT;
+ blk.dim.area.width = mem[ix].width >> 1;
+ blk.dim.area.height = mem[ix].height >> 1;
+ blk.stride = def_stride(mem[ix].width); /* same for Y and UV */
+ blk.ptr = mem[ix].bufPtr + mem[ix].height * blk.stride;
+ check_mem(mem[ix].val, &blk);
+ case 2:
+ blk.pixelFormat = PIXEL_FMT_8BIT;
+ blk.dim.area.width = mem[ix].width;
+ blk.dim.area.height = mem[ix].height;
+ blk.stride = def_stride(mem[ix].width);
+ break;
+ case 3:
+ blk.pixelFormat = PIXEL_FMT_16BIT;
+ blk.dim.area.width = mem[ix].width;
+ blk.dim.area.height = mem[ix].height;
+ blk.stride = def_stride(mem[ix].width * 2);
+ break;
+ case 4:
+ blk.pixelFormat = PIXEL_FMT_32BIT;
+ blk.dim.area.width = mem[ix].width;
+ blk.dim.area.height = mem[ix].height;
+ blk.stride = def_stride(mem[ix].width * 4);
+ break;
+ }
+ blk.ptr = mem[ix].bufPtr;
+ check_mem(mem[ix].val, &blk);
+ }
+ }
+#endif
+ }
+ }
+
+ /* unmap and free everything */
+ for (ix = 0; ix < num_slots; ix++)
+ {
+ if (mem[ix].bufPtr)
+ {
+ /* check memory fill */
+ switch (mem[ix].op)
+ {
+ case 0: ERR_ADD(res, unmap_1D(mem[ix].dataPtr, mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr));
+ FREE(mem[ix].buffer);
+ break;
+ case 1: ERR_ADD(res, free_1D(mem[ix].length, 0, mem[ix].val, mem[ix].bufPtr)); break;
+ case 2: ERR_ADD(res, free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_8BIT, 0, mem[ix].val, mem[ix].bufPtr)); break;
+ case 3: ERR_ADD(res, free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_16BIT, 0, mem[ix].val, mem[ix].bufPtr)); break;
+ case 4: ERR_ADD(res, free_2D(mem[ix].width, mem[ix].height, PIXEL_FMT_32BIT, 0, mem[ix].val, mem[ix].bufPtr)); break;
+ case 5: ERR_ADD(res, free_NV12(mem[ix].width, mem[ix].height, mem[ix].val, mem[ix].bufPtr)); break;
+ }
+ }
+ }
+ FREE(mem);
+
+ return res;
+}
+
+/**
+ * This stress tests allocates/maps/frees/unmaps buffers at
+ * least num_ops times. The test maintains a set of slots that
+ * are initially NULL. For each operation, a slot is randomly
+ * selected. If the slot is not used, it is filled randomly
+ * with a 1D, 2D, NV12 or mapped buffer. If it is used, the
+ * slot is cleared by freeing/unmapping the buffer already
+ * there. The buffers are filled on alloc/map and this is
+ * checked on free/unmap to verify that there was no memory
+ * corruption. Failed allocation and maps are ignored as we may
+ * run out of memory. The return value is the first error code
+ * encountered, or 0 on success.
+ *
+ * This test sets the seed so that it produces reproducible
+ * results.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_ops Number of operations to perform
+ * @param num_slots Number of slots to maintain
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int star_tiler_test(uint32_t num_ops, uint16_t num_slots)
+{
+ printf("Random set of %d tiler Allocs/Maps and Frees/UnMaps for %d slots\n", num_ops, num_slots);
+ srand(0x4B72316A);
+ struct data {
+ int op;
+ struct tiler_block_info blk;
+ void *buffer;
+ } *mem;
+
+ /* allocate memory state */
+ mem = NEWN(struct data, num_slots);
+ if (!mem) return NOT_P(mem,!=,NULL);
+
+ /* perform alloc/free/unmaps */
+ int ix, td = A_S(open("/dev/tiler", O_RDWR),>=,0), res = td < 0 ? td : 0;
+ while (!res && num_ops--)
+ {
+ ix = rand() % num_slots;
+ /* see if we need to free/unmap data */
+ if (mem[ix].blk.id)
+ {
+ P("free [0x%x(0x%x)]", mem[ix].blk.id, mem[ix].blk.ssptr);
+ res = A_S(ioctl(td, TILIOC_FBLK, &mem[ix].blk),==,0);
+ FREE(mem[ix].buffer);
+ ZERO(mem[ix]);
+ }
+ /* we need to allocate/map data */
+ else
+ {
+ int op = rand();
+ /* set width */
+ pixels_t width, height;
+ switch ("AAAABBBBCCCDDEEF"[op & 15]) {
+ case 'F': width = 1920; height = 1080; break;
+ case 'E': width = 1280; height = 720; break;
+ case 'D': width = 640; height = 480; break;
+ case 'C': width = 848; height = 480; break;
+ case 'B': width = 176; height = 144; break;
+ case 'A': width = height = 64; break;
+ }
+ bytes_t length = (bytes_t)width * height;
+
+ /* perform operation */
+ mem[ix].op = "AAABBBBCCCCDDDDE"[(op >> 4) & 15] - 'A';
+ switch (mem[ix].op)
+ {
+ case 0: /* map 1D buffer */
+ /* allocate aligned buffer */
+ length = (length + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1);
+ mem[ix].buffer = malloc(length + PAGE_SIZE - 1);
+ if (mem[ix].buffer)
+ {
+ mem[ix].blk.dim.len = length;
+ mem[ix].blk.fmt = TILFMT_PAGE;
+ mem[ix].blk.ptr = (void *)(((uint32_t)mem[ix].buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ res = A_S(ioctl(td, TILIOC_MBLK, &mem[ix].blk),==,0);
+ if (res)
+ FREE(mem[ix].buffer);
+ }
+ P("map[l=0x%x] = 0x%x(0x%x)", length, mem[ix].blk.id, mem[ix].blk.ssptr);
+ break;
+ case 1:
+ mem[ix].blk.dim.len = length;
+ mem[ix].blk.fmt = TILFMT_PAGE;
+ res = A_S(ioctl(td, TILIOC_GBLK, &mem[ix].blk),==,0);
+ P("alloc[l=0x%x] = 0x%x(0x%x)", length, mem[ix].blk.id, mem[ix].blk.ssptr);
+ break;
+ case 2: case 3: case 4:
+ mem[ix].blk.dim.area.width = width;
+ mem[ix].blk.dim.area.height = height;
+ mem[ix].blk.fmt = TILFMT_8BIT + mem[ix].op - 2;
+ res = A_S(ioctl(td, TILIOC_GBLK, &mem[ix].blk),==,0);
+ P("alloc[%d*%d*%d] = 0x%x(0x%x)", width, height, 8 << (mem[ix].op -2), mem[ix].blk.id, mem[ix].blk.ssptr);
+ break;
+ }
+ }
+ }
+
+ /* unmap and free everything */
+ for (ix = 0; ix < num_slots; ix++)
+ {
+ if (mem[ix].blk.id)
+ {
+ res = A_S(ioctl(td, TILIOC_FBLK, &mem[ix].blk),==,0);
+ FREE(mem[ix].buffer);
+ }
+ }
+ ERR_ADD_S(res, close(td));
+ FREE(mem);
+
+ return res;
+}
+
+#define NEGA(exp) ({ void *__ptr__ = A_P(exp,==,NULL); if (__ptr__) MemMgr_Free(__ptr__); __ptr__ != NULL; })
+
+/**
+ * Performs negative tests for MemMgr_Alloc.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_alloc_tests()
+{
+ printf("Negative Alloc tests\n");
+
+ MemAllocBlock block[2], *blk;
+ memset(&block, 0, sizeof(block));
+
+ int ret = 0, num_blocks;
+
+ for (num_blocks = 1; num_blocks < 3; num_blocks++)
+ {
+ blk = block + num_blocks - 1;
+
+ P("/* bad pixel format */");
+ blk->pixelFormat = PIXEL_FMT_MIN - 1;
+ blk->dim.len = PAGE_SIZE;
+ ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+ blk->pixelFormat = PIXEL_FMT_MAX + 1;
+ ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+ P("/* bad 1D stride */");
+ blk->pixelFormat = PIXEL_FMT_PAGE;
+ blk->stride = PAGE_SIZE - 1;
+ ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+ P("/* 0 1D length */");
+ blk->dim.len = blk->stride = 0;
+ ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+ P("/* bad 2D stride */");
+ blk->pixelFormat = PIXEL_FMT_8BIT;
+ blk->dim.area.width = PAGE_SIZE - 1;
+ blk->stride = PAGE_SIZE - 1;
+ blk->dim.area.height = 16;
+ ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+ P("/* bad 2D width */");
+ blk->stride = blk->dim.area.width = 0;
+ ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+ P("/* bad 2D height */");
+ blk->dim.area.height = 0;
+ blk->dim.area.width = 16;
+ ret |= NEGA(MemMgr_Alloc(block, num_blocks));
+
+ /* good 2D block */
+ blk->dim.area.height = 16;
+ }
+
+ block[0].pixelFormat = block[1].pixelFormat = PIXEL_FMT_8BIT;
+ block[0].dim.area.width = 16384;
+ block[0].dim.area.height = block[1].dim.area.width = 16;
+ block[1].dim.area.height = 8192;
+ ret |= NEGA(MemMgr_Alloc(block, 2));
+
+ return ret;
+}
+
+/**
+ * Performs negative tests for MemMgr_Free.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_free_tests()
+{
+ printf("Negative Free tests\n");
+
+ void *ptr = alloc_2D(2500, 10, PIXEL_FMT_16BIT, 2 * PAGE_SIZE, 0);
+ int ret = 0;
+
+ MemMgr_Free(ptr);
+
+ P("/* free something twice */");
+ ret |= NOT_I(MemMgr_Free(ptr),!=,0);
+
+ P("/* free NULL */");
+ ret |= NOT_I(MemMgr_Free(NULL),!=,0);
+
+ P("/* free arbitrary value */");
+ ret |= NOT_I(MemMgr_Free((void *)0x12345678),!=,0);
+
+ P("/* free mapped buffer */");
+ void *buffer = malloc(PAGE_SIZE * 2);
+ void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ ptr = map_1D(dataPtr, PAGE_SIZE, 0, 0);
+ ret |= NOT_I(MemMgr_Free(ptr),!=,0);
+
+ MemMgr_UnMap(ptr);
+
+ return ret;
+}
+
+#define NEGM(exp) ({ void *__ptr__ = A_P(exp,==,NULL); if (__ptr__) MemMgr_UnMap(__ptr__); __ptr__ != NULL; })
+
+/**
+ * Performs negative tests for MemMgr_Map.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_map_tests()
+{
+ printf("Negative Map tests\n");
+
+ MemAllocBlock block[2], *blk;
+ memset(&block, 0, sizeof(block));
+
+ int ret = 0, num_blocks;
+
+ for (num_blocks = 1; num_blocks < 3; num_blocks++)
+ {
+ blk = block + num_blocks - 1;
+
+ P("/* bad pixel format */");
+ blk->pixelFormat = PIXEL_FMT_MIN - 1;
+ blk->dim.len = PAGE_SIZE;
+ ret |= NEGM(MemMgr_Map(block, num_blocks));
+ blk->pixelFormat = PIXEL_FMT_MAX + 1;
+ ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+ P("/* bad 1D stride */");
+ blk->pixelFormat = PIXEL_FMT_PAGE;
+ blk->stride = PAGE_SIZE - 1;
+ ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+ P("/* 0 1D length */");
+ blk->dim.len = blk->stride = 0;
+ ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+ P("/* bad 2D stride */");
+ blk->pixelFormat = PIXEL_FMT_8BIT;
+ blk->dim.area.width = PAGE_SIZE - 1;
+ blk->stride = PAGE_SIZE - 1;
+ blk->dim.area.height = 16;
+ ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+ P("/* bad 2D width */");
+ blk->stride = blk->dim.area.width = 0;
+ ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+ P("/* bad 2D height */");
+ blk->dim.area.height = 0;
+ blk->dim.area.width = 16;
+ ret |= NEGM(MemMgr_Map(block, num_blocks));
+
+ /* good 2D block */
+ blk->dim.area.height = 16;
+ }
+
+ P("/* 2 buffers */");
+ ret |= NEGM(MemMgr_Map(block, 2));
+
+ P("/* 1 2D buffer */");
+ ret |= NEGM(MemMgr_Map(block, 1));
+
+ P("/* 1 1D buffer with no address */");
+ block[0].pixelFormat = PIXEL_FMT_PAGE;
+ block[0].dim.len = 2 * PAGE_SIZE;
+ block[0].ptr = NULL;
+ ret |= NEGM(MemMgr_Map(block, 1));
+
+ P("/* 1 1D buffer with not aligned start address */");
+ void *buffer = malloc(3 * PAGE_SIZE);
+ void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ block[0].ptr = dataPtr + 3;
+ ret |= NEGM(MemMgr_Map(block, 1));
+
+ P("/* 1 1D buffer with not aligned length */");
+ block[0].ptr = dataPtr;
+ block[0].dim.len -= 5;
+ ret |= NEGM(MemMgr_Map(block, 1));
+
+#if 0 /* TODO: it's possible that our va falls within the TILER addr range */
+ P("/* Mapping a tiled 1D buffer */");
+ void *ptr = alloc_1D(PAGE_SIZE * 2, 0, 0);
+ dataPtr = (void *)(((uint32_t)ptr + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ block[0].ptr = dataPtr;
+ block[0].dim.len = PAGE_SIZE;
+ ret |= NEGM(MemMgr_Map(block, 1));
+
+ MemMgr_Free(ptr);
+#endif
+
+ return ret;
+}
+
+/**
+ * Performs negative tests for MemMgr_UnMap.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_unmap_tests()
+{
+ printf("Negative Unmap tests\n");
+
+ void *ptr = alloc_1D(PAGE_SIZE, 0, 0);
+ int ret = 0;
+
+ P("/* unmap alloced buffer */");
+ ret |= NOT_I(MemMgr_UnMap(ptr),!=,0);
+
+ MemMgr_Free(ptr);
+
+ void *buffer = malloc(PAGE_SIZE * 2);
+ void *dataPtr = (void *)(((uint32_t)buffer + PAGE_SIZE - 1) &~ (PAGE_SIZE - 1));
+ ptr = map_1D(dataPtr, PAGE_SIZE, 0, 0);
+ MemMgr_UnMap(ptr);
+
+ P("/* unmap something twice */");
+ ret |= NOT_I(MemMgr_UnMap(ptr),!=,0);
+
+ P("/* unmap NULL */");
+ ret |= NOT_I(MemMgr_UnMap(NULL),!=,0);
+
+ P("/* unmap arbitrary value */");
+ ret |= NOT_I(MemMgr_UnMap((void *)0x12345678),!=,0);
+
+ return ret;
+}
+
+/**
+ * Performs negative tests for MemMgr_Is.. functions.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int neg_check_tests()
+{
+ printf("Negative Is... tests\n");
+ void *ptr = malloc(32);
+
+ int ret = 0;
+
+ ret |= NOT_I(MemMgr_Is1DBlock(NULL),==,FALSE);
+ ret |= NOT_I(MemMgr_Is1DBlock((void *)0x12345678),==,FALSE);
+ ret |= NOT_I(MemMgr_Is1DBlock(ptr),==,FALSE);
+ ret |= NOT_I(MemMgr_Is2DBlock(NULL),==,FALSE);
+ ret |= NOT_I(MemMgr_Is2DBlock((void *)0x12345678),==,FALSE);
+ ret |= NOT_I(MemMgr_Is2DBlock(ptr),==,FALSE);
+ ret |= NOT_I(MemMgr_IsMapped(NULL),==,FALSE);
+ ret |= NOT_I(MemMgr_IsMapped((void *)0x12345678),==,FALSE);
+ ret |= NOT_I(MemMgr_IsMapped(ptr),==,FALSE);
+
+ ret |= NOT_I(MemMgr_GetStride(NULL),==,0);
+ ret |= NOT_I(MemMgr_GetStride((void *)0x12345678),==,0);
+ ret |= NOT_I(MemMgr_GetStride(ptr),==,PAGE_SIZE);
+
+ ret |= NOT_P(TilerMem_VirtToPhys(NULL),==,0);
+ ret |= NOT_P(TilerMem_VirtToPhys((void *)0x12345678),==,0);
+ ret |= NOT_P(TilerMem_VirtToPhys(ptr),!=,0);
+
+ ret |= NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(NULL)),==,0);
+ ret |= NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys((void *)0x12345678)),==,0);
+ ret |= NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(ptr)),==,0);
+
+ FREE(ptr);
+
+ return ret;
+}
+
+DEFINE_TESTS(TESTS)
+
+/**
+ * We run the same identity check before and after running the
+ * tests.
+ *
+ * @author a0194118 (9/12/2009)
+ */
+void memmgr_identity_test(void *ptr)
+{
+ /* also execute internal unit tests - this also verifies that we did not
+ keep any references */
+ __test__MemMgr();
+}
+
+/**
+ * Main test function. Checks arguments for test case ranges,
+ * runs tests and prints usage or test list if required.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param argc Number of arguments
+ * @param argv Arguments
+ *
+ * @return -1 on usage or test list, otherwise # of failed
+ * tests.
+ */
+int main(int argc, char **argv)
+{
+ return TestLib_Run(argc, argv,
+ memmgr_identity_test, memmgr_identity_test, NULL);
+}
+
diff --git a/tiler/testlib.c b/tiler/testlib.c
new file mode 100644
index 0000000..63d1298
--- /dev/null
+++ b/tiler/testlib.c
@@ -0,0 +1,163 @@
+/*
+ * testlib.c
+ *
+ * Unit test interface.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* retrieve type definitions */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "testlib.h"
+
+#include <utils.h>
+#include <debug_utils.h>
+
+#define TESTLIB_OK 0
+#define TESTLIB_FAIL 1
+
+/** Returns TRUE iff str is a whole unsigned int */
+#define is_uint(str) \
+ ({ unsigned i; char c; sscanf(str, "%u%c", &i, &c) == 1; })
+
+extern int __internal__TestLib_DoList(int id);
+
+/**
+ * Prints test result and returns summary result
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param res Test result
+ *
+ * @return TEST_RESULT_OK on success, TEST_RESULT_FAIL on
+ * failure, TEST_RESULT_UNAVAILABLE if test is not
+ * available
+ */
+int __internal__TestLib_Report(int res)
+{
+ switch (res)
+ {
+ case TESTLIB_UNAVAILABLE:
+ printf("==> TEST NOT AVAILABLE\n");
+ fflush(stdout);
+ return TESTLIB_UNAVAILABLE;
+ case 0:
+ printf("==> TEST OK\n");
+ fflush(stdout);
+ return TESTLIB_OK;
+ default:
+ printf("==> TEST FAIL(%d)\n", res);
+ fflush(stdout);
+ return TESTLIB_FAIL;
+ }
+}
+
+void __internal__TestLib_NullFn(void *ptr)
+{
+}
+
+int TestLib_Run(int argc, char **argv, void(*init_fn)(void *),
+ void(*exit_fn)(void *), void *ptr)
+{
+ int start, end, res, failed = 0, succeeded = 0, unavailable = 0;
+
+ /* all tests */
+ if (argc == 1)
+ {
+ start = 1; end = -1;
+ }
+ /* test list */
+ else if (argc == 2 && !strcmp(argv[1], "list"))
+ {
+ __internal__TestLib_DoList(0);
+ return -1;
+ }
+ /* single test */
+ else if (argc == 2 && is_uint(argv[1]))
+ {
+ start = end = atoi(argv[1]);
+ }
+ /* open range .. b */
+ else if (argc == 3 && !strcmp(argv[1], "..") && is_uint(argv[2]))
+ {
+ start = 1;
+ end = atoi(argv[2]);
+ }
+ /* open range a .. */
+ else if (argc == 3 && !strcmp(argv[2], "..") && is_uint(argv[1]))
+ {
+ start = atoi(argv[1]);
+ end = -1;
+ }
+ else if (argc == 4 && !strcmp(argv[2], "..") && is_uint(argv[1]) && is_uint(argv[3]))
+ {
+ start = atoi(argv[1]);
+ end = atoi(argv[3]);
+ }
+ else
+ {
+ fprintf(stderr, "Usage: %s [<range>], where <range> is\n"
+ " empty: run all tests\n"
+ " list: list tests\n"
+ " ix: run test #ix\n"
+ " a ..: run tests #a, #a+1, ...\n"
+ " .. b: run tests #1, #2, .. #b\n"
+ " a .. b: run tests #a, #a+1, .. #b\n", argv[0]);
+ fflush(stderr);
+ return -1;
+ }
+
+ /* execute tests */
+ init_fn(ptr);
+
+ do
+ {
+ res = __internal__TestLib_DoList(start++);
+ if (res == TESTLIB_FAIL) failed++;
+ else if (res == TESTLIB_OK) succeeded++;
+ else if (res == TESTLIB_UNAVAILABLE) unavailable++;
+ printf("so far FAILED: %d, SUCCEEDED: %d, UNAVAILABLE: %d\n", failed, succeeded,
+ unavailable);
+ fflush(stdout);
+ } while (res != TESTLIB_INVALID && (end < 0 || start <= end));
+
+ printf("FAILED: %d, SUCCEEDED: %d, UNAVAILABLE: %d\n", failed, succeeded,
+ unavailable);
+ fflush(stdout);
+
+ /* also execute internal unit tests - this also verifies that we did not
+ keep any references */
+ exit_fn(ptr);
+
+ return failed;
+}
+
diff --git a/tiler/testlib.h b/tiler/testlib.h
new file mode 100644
index 0000000..bc1a799
--- /dev/null
+++ b/tiler/testlib.h
@@ -0,0 +1,101 @@
+/*
+ * testlib.h
+ *
+ * Unit test interface API.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TESTLIB_H_
+#define _TESTLIB_H_
+
+/* error type definitions */
+#define TESTLIB_UNAVAILABLE -65378
+#define TESTLIB_INVALID -1
+
+#define T(test) ++i; \
+ if (!id || i == id) printf("TEST #% 3d - %s\n", i, #test); \
+ if (i == id) { \
+ printf("TEST_DESC - "); \
+ fflush(stdout); \
+ return __internal__TestLib_Report(test); \
+ }
+
+/* test run function that must be defined from the test app */
+
+/**
+ * Runs a specified test by id, or lists all test cases. This
+ * function uses the TESTS macros, and defines each T(test) to
+ * run a test starting from id == 1, and then return the result.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param id Test case id, or 0 if only listing test cases
+ *
+ * @return Summary result: TEST_RESULT_OK, FAIL, INVALID or
+ * UNAVAILABLE.
+ */
+#define TESTS_ \
+ int __internal__TestLib_DoList(int id) { int i = 0;
+
+#define _TESTS \
+ return TESTLIB_INVALID; }
+
+#define DEFINE_TESTS(TESTS) TESTS_ TESTS _TESTS
+
+/* internal function prototypes and defines */
+extern int __internal__TestLib_Report(int res);
+extern void __internal__TestLib_NullFn(void *ptr);
+
+#define nullfn __internal__TestLib_NullFn
+
+/**
+ * Parses argument list, prints usage on error, lists test
+ * cases, runs tests and reports results.
+ *
+ * @author a0194118 (9/12/2009)
+ *
+ * @param argc Number of test arguments
+ * @param argv Test argument array
+ * @param init_fn Initialization function of void fn(void *).
+ * This is called before the testing.
+ * @param exit_fn Deinit function of void fn(void *). This is
+ * done after the testing concludes.
+ * @param ptr Custom pointer that is passed into the
+ * initialization functions.
+ *
+ * @return # of test cases failed, 0 on success, -1 if no tests
+ * were run because of an error or a list request.
+ */
+int TestLib_Run(int argc, char **argv, void(*init_fn)(void *),
+ void(*exit_fn)(void *), void *ptr);
+
+#endif
+
diff --git a/tiler/tiler.h b/tiler/tiler.h
new file mode 100644
index 0000000..8358f8d
--- /dev/null
+++ b/tiler/tiler.h
@@ -0,0 +1,105 @@
+/*
+ * tiler.h
+ *
+ * TILER driver support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILER_H_
+#define _TILER_H_
+
+#define TILER_MEM_8BIT 0x60000000
+#define TILER_MEM_16BIT 0x68000000
+#define TILER_MEM_32BIT 0x70000000
+#define TILER_MEM_PAGED 0x78000000
+#define TILER_MEM_END 0x80000000
+
+#define TILER_PAGE 0x1000
+#define TILER_WIDTH 256
+#define TILER_HEIGHT 128
+#define TILER_BLOCK_WIDTH 64
+#define TILER_BLOCK_HEIGHT 64
+#define TILER_LENGTH (TILER_WIDTH * TILER_HEIGHT * TILER_PAGE)
+
+#define TILER_DEVICE_PATH "/dev/tiler"
+#define TILER_MAX_NUM_BLOCKS 16
+
+enum tiler_fmt {
+ TILFMT_MIN = -2,
+ TILFMT_INVALID = -2,
+ TILFMT_NONE = -1,
+ TILFMT_8BIT = 0,
+ TILFMT_16BIT = 1,
+ TILFMT_32BIT = 2,
+ TILFMT_PAGE = 3,
+ TILFMT_MAX = 3,
+ TILFMT_8AND16 = 4,
+};
+
+struct area {
+ uint16_t width;
+ uint16_t height;
+};
+
+struct tiler_block_info {
+ enum tiler_fmt fmt;
+ union {
+ struct area area;
+ uint32_t len;
+ } dim;
+ uint32_t stride;
+ void *ptr;
+ uint32_t id;
+ uint32_t key;
+ uint32_t group_id;
+ uint32_t ssptr;
+};
+
+struct tiler_buf_info {
+ uint32_t num_blocks;
+ struct tiler_block_info blocks[TILER_MAX_NUM_BLOCKS];
+ uint32_t offset;
+ uint32_t length;
+};
+
+#define TILIOC_GBLK _IOWR('z', 100, struct tiler_block_info)
+#define TILIOC_FBLK _IOW('z', 101, struct tiler_block_info)
+#define TILIOC_GSSP _IOWR('z', 102, uint32_t)
+#define TILIOC_MBLK _IOWR('z', 103, struct tiler_block_info)
+#define TILIOC_UMBLK _IOW('z', 104, struct tiler_block_info)
+#define TILIOC_QBUF _IOWR('z', 105, struct tiler_buf_info)
+#define TILIOC_RBUF _IOWR('z', 106, struct tiler_buf_info)
+#define TILIOC_URBUF _IOWR('z', 107, struct tiler_buf_info)
+#define TILIOC_QBLK _IOWR('z', 108, struct tiler_block_info)
+#define TILIOC_PRBLK _IOW('z', 109, struct tiler_block_info)
+#define TILIOC_URBLK _IOW('z', 110, uint32_t)
+
+#endif
diff --git a/tiler/tiler_ptest.c b/tiler/tiler_ptest.c
new file mode 100644
index 0000000..7f06940
--- /dev/null
+++ b/tiler/tiler_ptest.c
@@ -0,0 +1,729 @@
+/*
+ * tiler_ptest.c
+ *
+ * Memory Allocator Interface tests.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* retrieve type definitions */
+#define __DEBUG__
+#undef __DEBUG_ENTRY__
+#define __DEBUG_ASSERT__
+
+#undef __WRITE_IN_STRIDE__
+#undef STAR_TRACE_MEM
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <stdint.h>
+#include <ctype.h>
+
+#ifdef HAVE_CONFIG_H
+ #include "config.h"
+#endif
+#include <utils.h>
+#include <list_utils.h>
+#include <debug_utils.h>
+#include <memmgr.h>
+#include <tilermem.h>
+#include <tilermem_utils.h>
+#include <testlib.h>
+
+#define FALSE 0
+
+/**
+ * Returns the default page stride for this block
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param width Width of 2D container
+ *
+ * @return Stride
+ */
+static bytes_t def_stride(pixels_t width)
+{
+ return (PAGE_SIZE - 1 + (bytes_t)width) & ~(PAGE_SIZE - 1);
+}
+
+/**
+ * Returns the bytes per pixel for the pixel format.
+ *
+ * @author a0194118 (9/4/2009)
+ *
+ * @param pixelFormat Pixelformat
+ *
+ * @return Bytes per pixel
+ */
+static bytes_t def_bpp(pixel_fmt_t pixelFormat)
+{
+ return (pixelFormat == PIXEL_FMT_32BIT ? 4 :
+ pixelFormat == PIXEL_FMT_16BIT ? 2 : 1);
+}
+
+enum ptr_type {
+ ptr_empty = 0,
+ ptr_alloced,
+ ptr_tiler_alloced,
+};
+
+struct ptr_info {
+ int num_blocks;
+ struct tiler_block_info blocks[TILER_MAX_NUM_BLOCKS];
+ int ptr;
+ short type;
+ uint16_t val;
+};
+
+static void dump_block(struct tiler_block_info *blk, char *prefix, char *suffix)
+{
+ switch (blk->fmt)
+ {
+ case PIXEL_FMT_PAGE:
+ P("%s [p=%p(0x%x),l=0x%x,s=%d]%s", prefix, blk->ptr, blk->ssptr,
+ blk->dim.len, blk->stride, suffix);
+ break;
+ case PIXEL_FMT_8BIT:
+ case PIXEL_FMT_16BIT:
+ case PIXEL_FMT_32BIT:
+ P("%s [p=%p(0x%x),%d*%d*%d,s=%d]%s", prefix, blk->ptr, blk->ssptr,
+ blk->dim.area.width, blk->dim.area.height, def_bpp(blk->fmt) * 8,
+ blk->stride, suffix);
+ break;
+ default:
+ P("%s*[p=%p(0x%x),l=0x%x,s=%d,fmt=0x%x]%s", prefix, blk->ptr,
+ blk->ssptr, blk->dim.len, blk->stride, blk->fmt, suffix);
+ }
+}
+
+static void dump_slot(struct ptr_info* buf, char* prefix)
+{
+ P("%sbuf={n=%d,ptr=0x%x,type=%d,", prefix, buf->num_blocks, buf->ptr,
+ buf->type);
+ int ix = 0;
+ for (ix = 0; ix < buf->num_blocks; ix++)
+ {
+ dump_block(buf->blocks + ix, "", ix + 1 == buf->num_blocks ? "}" : "");
+ }
+}
+
+/**
+ * This method fills up a range of memory using a start address
+ * and start value. The method of filling ensures that
+ * accidentally overlapping regions have minimal chances of
+ * matching, even if the same starting value is used. This is
+ * because the difference between successive values varies as
+ * such. This series only repeats after 704189 values, so the
+ * probability of a match for a range of at least 2 values is
+ * less than 2*10^-11.
+ *
+ * V(i + 1) - V(i) = { 1, 2, 3, ..., 65535, 2, 4, 6, 8 ...,
+ * 65534, 3, 6, 9, 12, ..., 4, 8, 12, 16, ... }
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start start value
+ * @param block pointer to block info strucure
+ */
+void fill_mem(uint16_t start, MemAllocBlock *block)
+{
+ IN;
+ uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+ bytes_t height, width, stride, i;
+ if (block->pixelFormat == PIXEL_FMT_PAGE)
+ {
+ height = 1;
+ stride = width = block->dim.len;
+ }
+ else
+ {
+ height = block->dim.area.height;
+ width = block->dim.area.width;
+ stride = block->stride;
+ }
+ width *= def_bpp(block->pixelFormat);
+ bytes_t size = height * stride;
+
+ P("(%p,0x%x*0x%x,s=0x%x)=0x%x", block->ptr, width, height, stride, start);
+
+ CHK_I(width,<=,stride);
+ uint32_t *ptr32 = (uint32_t *)ptr;
+ while (height--)
+ {
+ if (block->pixelFormat == PIXEL_FMT_32BIT)
+ {
+ for (i = 0; i < width; i += sizeof(uint32_t))
+ {
+ uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+ *ptr32++ = val;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+ {
+ *ptr32++ = 0;
+ i += sizeof(uint32_t);
+ }
+#else
+ ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+ }
+ else
+ {
+ for (i = 0; i < width; i += sizeof(uint16_t))
+ {
+ *ptr++ = start;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && (height || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+ {
+ *ptr++ = 0;
+ i += sizeof(uint16_t);
+ }
+#else
+ ptr += (stride - i) / sizeof(uint16_t);
+#endif
+
+ }
+ }
+ CHK_P((block->pixelFormat == PIXEL_FMT_32BIT ? (void *)ptr32 : (void *)ptr),==,
+ (block->ptr + size));
+ OUT;
+}
+
+/**
+ * This verifies if a range of memory at a given address was
+ * filled up using the start value.
+ *
+ * @author a0194118 (9/6/2009)
+ *
+ * @param start start value
+ * @param block pointer to block info strucure
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int check_mem(uint16_t start, MemAllocBlock *block)
+{
+ IN;
+ uint16_t *ptr = (uint16_t *)block->ptr, delta = 1, step = 1;
+ bytes_t height, width, stride, r, i;
+ if (block->pixelFormat == PIXEL_FMT_PAGE)
+ {
+ height = 1;
+ stride = width = block->dim.len;
+ }
+ else
+ {
+ height = block->dim.area.height;
+ width = block->dim.area.width;
+ stride = block->stride;
+ }
+ width *= def_bpp(block->pixelFormat);
+
+ CHK_I(width,<=,stride);
+ uint32_t *ptr32 = (uint32_t *)ptr;
+ for (r = 0; r < height; r++)
+ {
+ if (block->pixelFormat == PIXEL_FMT_32BIT)
+ {
+ for (i = 0; i < width; i += sizeof(uint32_t))
+ {
+ uint32_t val = (start & 0xFFFF) | (((uint32_t)(start + delta) & 0xFFFF) << 16);
+ if (*ptr32++ != val) {
+ DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr32, val);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr32)))
+ {
+ if (*ptr32++) {
+ DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr32);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ i += sizeof(uint32_t);
+ }
+#else
+ ptr32 += (stride - i) / sizeof(uint32_t);
+#endif
+ }
+ else
+ {
+ for (i = 0; i < width; i += sizeof(uint16_t))
+ {
+ if (*ptr++ != start) {
+ DP("assert: val[%u,%u] (=0x%x) != 0x%x", r, i, *--ptr, start);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ start += delta;
+ delta += step;
+ /* increase step if overflown */
+ if (delta < step) delta = ++step;
+ }
+#ifdef __WRITE_IN_STRIDE__
+ while (i < stride && ((r < height - 1) || ((PAGE_SIZE - 1) & (uint32_t)ptr)))
+ {
+ if (*ptr++) {
+ DP("assert: val[%u,%u] (=0x%x) != 0", r, i, *--ptr);
+ return R_I(MEMMGR_ERR_GENERIC);
+ }
+ i += sizeof(uint16_t);
+ }
+#else
+ ptr += (stride - i) / sizeof(uint16_t);
+#endif
+ }
+ }
+ return R_I(MEMMGR_ERR_NONE);
+}
+
+/**
+ * This method allocates a tiled buffer composed of an arbitrary
+ * set of tiled blocks. If successful, it checks
+ * that the block information was updated with the pointer to
+ * the block. Additionally, it verifies the correct return
+ * values for MemMgr_IsMapped, MemMgr_Is1DBlock,
+ * MemMgr_Is2DBlock, MemMgr_GetStride, TilerMem_GetStride. It
+ * also verifies TilerMem_VirtToPhys using an internally stored
+ * value of the ssptr. If any of these verifications fail, the
+ * buffer is freed. Otherwise, it is filled using the given
+ * start value.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_blocks Number of blocks in the buffer
+ * @param blocks Block information
+ * @param val Fill start value
+ * @param bufPtr Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+void *alloc_buf(int num_blocks, MemAllocBlock blocks[], uint16_t val)
+{
+ void *bufPtr = MemMgr_Alloc(blocks, num_blocks);
+ void *ptr = bufPtr;
+ int i;
+
+ for (i = 0; i < num_blocks; i++)
+ {
+ if (bufPtr)
+ {
+ pixel_fmt_t fmt = blocks[i].pixelFormat;
+ bytes_t cstride = (fmt == PIXEL_FMT_PAGE ? PAGE_SIZE :
+ fmt == PIXEL_FMT_8BIT ? TILER_STRIDE_8BIT :
+ fmt == PIXEL_FMT_16BIT ? TILER_STRIDE_16BIT :
+ TILER_STRIDE_32BIT);
+ if (NOT_P(blocks[i].ptr,==,ptr) ||
+ NOT_I(MemMgr_IsMapped(ptr),!=,0) ||
+ NOT_I(MemMgr_Is1DBlock(ptr),==,fmt == PIXEL_FMT_PAGE ? 1 : 0) ||
+ NOT_I(MemMgr_Is2DBlock(ptr),==,fmt == PIXEL_FMT_PAGE ? 0 : 1) ||
+ NOT_I(MemMgr_GetStride(bufPtr),==,blocks[i].stride) ||
+ NOT_P(TilerMem_VirtToPhys(ptr),==,blocks[i].reserved) ||
+ NOT_I(TilerMem_GetStride(TilerMem_VirtToPhys(ptr)),==,cstride) ||
+ NOT_L((PAGE_SIZE - 1) & (long)ptr,==,(PAGE_SIZE - 1) & blocks[i].reserved) ||
+ (fmt == PIXEL_FMT_PAGE || NOT_I(blocks[i].stride,!=,0)))
+ {
+ P(" for block %d", i);
+ MemMgr_Free(bufPtr);
+ return NULL;
+ }
+ fill_mem(val, blocks + i);
+ if (blocks[i].pixelFormat != PIXEL_FMT_PAGE)
+ {
+ ptr += def_stride(blocks[i].dim.area.width *
+ def_bpp(blocks[i].pixelFormat)) * blocks[i].dim.area.height;
+ }
+ else
+ {
+ ptr += def_stride(blocks[i].dim.len);
+ }
+ }
+ else
+ {
+ A_P(blocks[i].ptr,==,ptr);
+ A_I(blocks[i].reserved,==,0);
+ }
+ }
+ return bufPtr;
+}
+
+/**
+ * This method frees a tiled buffer composed of an arbitrary set
+ * of tiled blocks. The given start value is used to verify that
+ * the buffer is still correctly filled. In the event of any
+ * errors, the error value is returned.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param num_blocks Number of blocks in the buffer
+ * @param blocks Block information
+ * @param val Fill start value
+ * @param bufPtr Pointer to the allocated buffer
+ *
+ * @return 0 on success, non-0 error value on failure
+ */
+int free_buf(int num_blocks, MemAllocBlock blocks[], uint16_t val, void *bufPtr)
+{
+ MemAllocBlock blk;
+ void *ptr = bufPtr;
+ int ret = 0, i;
+ for (i = 0; i < num_blocks; i++)
+ {
+ blk = blocks[i];
+ blk.ptr = ptr;
+ ERR_ADD(ret, check_mem(val, &blk));
+ if (blk.pixelFormat != PIXEL_FMT_PAGE)
+ {
+ ptr += def_stride(blk.dim.area.width *
+ def_bpp(blk.pixelFormat)) * blk.dim.area.height;
+ }
+ else
+ {
+ ptr += def_stride(blk.dim.len);
+ }
+ blk.reserved = 0;
+ }
+
+ ERR_ADD(ret, MemMgr_Free(bufPtr));
+ return ret;
+}
+
+#if 0
+struct slot {
+ int op;
+ SSPtr ssptr;
+ void *buffer;
+ void *dataPtr;
+} *slots = NULL;
+
+enum op_enum {
+ op_map_1d,
+ op_alloc_1d,
+ op_alloc_8,
+ op_alloc_16,
+ op_alloc_32,
+ op_alloc_nv12,
+ op_alloc_gen,
+};
+
+static int free_slot(int ix)
+{
+ if (slots[ix].bufPtr)
+ {
+ /* check memory fill */
+ switch (slots[ix].op)
+ {
+ case op_map_1d:
+ res = unmap_1D(slot[ix].dataPtr, slot[ix].length, 0, slot[ix].val, slot[ix].bufPtr);
+ FREE(mem[ix].buffer);
+ break;
+ case op_alloc_1d:
+ res = free_1D(slot[ix].length, 0, slot[ix].val, mem[ix].bufPtr);
+ break;
+ case op_alloc_8:
+ res = free_2D(slot[ix].width, slot[ix].height, PIXEL_FMT_8BIT, 0, slot[ix].val, slot[ix].bufPtr);
+ break;
+ case op_alloc_16:
+ res = free_2D(slot[ix].width, slot[ix].height, PIXEL_FMT_16BIT, 0, slot[ix].val, slot[ix].bufPtr);
+ break;
+ case op_alloc_32:
+ res = free_2D(slot[ix].width, slot[ix].height, PIXEL_FMT_32BIT, 0, slot[ix].val, slot[ix].bufPtr);
+ break;
+ case op_alloc_nv12:
+ res = free_NV12(slot[ix].width, slot[ix].height, slot[ix].val, slot[ix].bufPtr);
+ break;
+ }
+ P("%s[%p]", mem[ix].op ? "free" : "unmap", mem[ix].bufPtr);
+ ZERO(slot[ix]);
+ }
+}
+#endif
+
+#include <tilermgr.h>
+
+char *parse_num(char *p, int *tgt)
+{
+ int len;
+ if (!strncmp(p, "0x", 2)) { /* hex number */
+ if (NOT_I(sscanf(p, "0x%x%n", tgt, &len),==,1))
+ return NULL;
+ return p + len;
+ } else {
+ if (NOT_I(sscanf(p, "%d%n", tgt, &len),==,1))
+ return NULL;
+ return p + len;
+ }
+}
+
+/**
+ * Parametric memmgr test. This is similar to the star test
+ * except the operations are read from the command line:
+ *
+ * [#=]a:w*h*bits[,w*h*bits...] allocates a list of blocks as
+ * buffer # (it frees any previously allocated/mapped buffer
+ * f:# frees a buffer
+ *
+ *
+ * @author a0194118 (11/4/2009)
+ *
+ * @param argc
+ * @param argv
+ */
+int param_test(int argc, char **argv)
+{
+ int delta_slots = 16;
+ int ix, i, n, t, type, max_n, num_slots = delta_slots;
+ struct ptr_info *slots;
+ ALLOCN(slots, num_slots);
+ if (NOT_P(slots,!=,NULL)) return 1;
+
+ int res = TilerMgr_Open();
+ for (i = 1; i < argc && !res; i++)
+ {
+ uint16_t val = (uint16_t) rand();
+
+ char *p = argv[i], *q;
+ struct ptr_info buf;
+ ZERO(buf);
+
+ /* read slot */
+ ix = -1;
+ if (isdigit(*p))
+ {
+ res = 1;
+ q = parse_num(p, &ix);
+ if (NOT_P(q,!=,NULL) || NOT_I(ix,>,0)) break;
+ p = q;
+ if (NOT_I(*p++,==,'.')) break;
+ res = 0;
+ ix--;
+ }
+
+ type = *p++;
+ /* get default slot */
+ if (ix < 0)
+ {
+ switch (type)
+ {
+ /* allocation defaults to the 1st free slot */
+ case 'a':
+ case 'A':
+ for (ix = 0; ix < num_slots && slots[ix].type; ix++);
+ break;
+
+ /* frees default to the 1st used block */
+ case 'f':
+ case 'F':
+ for (ix = 0; ix < num_slots && !slots[ix].type; ix++);
+ if (NOT_I(ix,<,num_slots)) res = 1;
+ break;
+ }
+ }
+ if (res) break;
+
+ /* allocate more slots if needed */
+ if (ix >= num_slots)
+ {
+ int more_slots = ROUND_UP_TO(ix + 1, delta_slots);
+ struct ptr_info *new_slots;
+ ALLOCN(new_slots, more_slots);
+ if (NOT_P(new_slots,!=,NULL)) break;
+ memcpy(new_slots, slots, sizeof(*slots) * num_slots);
+ FREE(slots);
+ slots = new_slots;
+ num_slots = more_slots;
+ }
+
+ /* perform opertaion */
+ res = 1; /* assume failure */
+ switch (type)
+ {
+ case 'a': /* allocate */
+ case 'A': /* tiler-allocate */
+ switch (type)
+ {
+ case 'a': buf.type = ptr_alloced; max_n = TILER_MAX_NUM_BLOCKS; break;
+ case 'A': buf.type = ptr_tiler_alloced; max_n = 1; break;
+ }
+ if (ix < num_slots && NOT_I(slots[ix].type,==,ptr_empty)) break;
+ if (NOT_I(*p++,==,':')) break;
+ for (n = 0; *p && n < max_n; n++) {
+ /* read length or width */
+ p = parse_num(p, (int *) &buf.blocks[n].dim.len);
+ if (NOT_P(p,!=,NULL)) break;
+ if (*p == '*') { /* 2d block */
+ buf.blocks[n].dim.area.width = (uint16_t) buf.blocks[n].dim.len;
+ /* read height */
+ p = parse_num(++p, &t);
+ if (NOT_P(p,!=,NULL) || NOT_I(*p++,==,'*')) break;
+ buf.blocks[n].dim.area.height = (uint16_t) t;
+ /* read bits */
+ p = parse_num(p, &t);
+ if (NOT_P(p,!=,NULL)) break;
+ /* handle nv12 */
+ if (t == 12 && n + 1 < max_n) {
+ buf.blocks[n + 1].dim.area.width = buf.blocks[n].dim.area.width >> 1;
+ buf.blocks[n + 1].dim.area.height = buf.blocks[n].dim.area.height >> 1;
+ buf.blocks[n].fmt = TILFMT_8BIT;
+ t = 16;
+ n++;
+ }
+
+ buf.blocks[n].fmt = (t == 8 ? TILFMT_8BIT :
+ t == 16 ? TILFMT_16BIT :
+ t == 32 ? TILFMT_32BIT : TILFMT_INVALID);
+ if (NOT_I(buf.blocks[n].fmt,!=,TILFMT_INVALID)) break;
+ } else { /* 1d block */
+ buf.blocks[n].fmt = TILFMT_PAGE;
+ }
+ if (*p && NOT_I(*p++,==,',')) break;
+ /* we're OK */
+ res = 0;
+ }
+ if (res || *p) break;
+ /* allocate buffer */
+
+ buf.num_blocks = n;
+ buf.val = val;
+ if (buf.type == ptr_alloced)
+ {
+ dump_slot(&buf, "==(alloc)=>");
+ buf.ptr = (int) alloc_buf(n, (MemAllocBlock *) buf.blocks, val);
+ dump_slot(&buf, "<=(alloc)==");
+ }
+ else
+ {
+ dump_slot(&buf, "==(tiler_alloc)=>");
+ if (buf.blocks[0].fmt == TILFMT_PAGE)
+ {
+ buf.ptr = (int) TilerMgr_PageModeAlloc(buf.blocks[0].dim.len);
+ }
+ else
+ {
+ buf.ptr =(int) TilerMgr_Alloc(buf.blocks[0].fmt,
+ buf.blocks[0].dim.area.width,
+ buf.blocks[0].dim.area.height);
+ }
+ buf.blocks[0].ssptr = (unsigned long) buf.ptr;
+ dump_slot(&buf, "<=(tiler_alloc)==");
+ }
+ if (NOT_I(buf.ptr,!=,0)) res = 1;
+ else memcpy(slots + ix, &buf, sizeof(buf));
+ break;
+
+ case 'f': /* free */
+ case 'F': /* tiler-free */
+ memcpy(&buf, slots + ix, sizeof(buf));
+ switch (type)
+ {
+ case 'f':
+ if (NOT_I(buf.type,==,ptr_alloced)) break;
+ dump_slot(&buf, "==(free)=>");
+ res = free_buf(buf.num_blocks, (MemAllocBlock *) buf.blocks,
+ buf.val, (void *) buf.ptr);
+ P("<=(free)==: %d", res);
+ break;
+ case 'F':
+ if (NOT_I(buf.type,==,ptr_tiler_alloced)) break;
+ dump_slot(&buf, "==(tiler_free)=>");
+ if (buf.blocks[0].fmt == TILFMT_PAGE)
+ {
+ res = TilerMgr_PageModeFree((SSPtr) buf.ptr);
+ }
+ else
+ {
+ res = TilerMgr_Free((SSPtr) buf.ptr);
+ }
+ P("<=(tiler_free)==: %d", res);
+ break;
+ }
+ ZERO(slots[ix]);
+ break;
+ }
+ }
+
+ /* free any memmgr allocated blocks */
+ for (ix = 0; ix < num_slots; ix++)
+ {
+ if (slots[ix].type == ptr_alloced)
+ {
+ dump_slot(slots + ix, "==(free)=>");
+ int res_free = free_buf(slots[ix].num_blocks, (MemAllocBlock *) slots[ix].blocks,
+ slots[ix].val, (void *) slots[ix].ptr);
+ P("<=(free)==: %d", res_free);
+ ERR_ADD(res, res_free);
+ }
+ }
+ ERR_ADD(res, TilerMgr_Close());
+
+ FREE(slots);
+ return res;
+}
+
+/**
+ * Main test function. Checks arguments for test case ranges,
+ * runs tests and prints usage or test list if required.
+ *
+ * @author a0194118 (9/7/2009)
+ *
+ * @param argc Number of arguments
+ * @param argv Arguments
+ *
+ * @return -1 on usage or test list, otherwise # of failed
+ * tests.
+ */
+int main(int argc, char **argv)
+{
+ int res = param_test(argc, argv);
+ P(res ? "FAILURE: %d" : "SUCCESS", res);
+ return res;
+}
+
diff --git a/tiler/tilermem.h b/tiler/tilermem.h
new file mode 100644
index 0000000..2c89d84
--- /dev/null
+++ b/tiler/tilermem.h
@@ -0,0 +1,79 @@
+/*
+ * tilermem.h
+ *
+ * Tiler Memory Interface functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILERMEM_H_
+#define _TILERMEM_H_
+
+/* retrieve type definitions */
+#include "mem_types.h"
+
+/**
+ * Tiler Memory Allocator is responsible for:
+ * <ol>
+ * <li>Getting the stride information for containers(???) or
+ * buffers
+ * <li>Converting virtual addresses to physical addresses.
+ * </ol>
+ */
+
+/**
+ * Returns the tiler stride corresponding to the system space
+ * address. For 2D buffers it returns the container stride. For
+ * 1D buffers it returns the page size. For non-tiler buffers
+ * it returns 0.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr pointer to a virtual address
+ *
+ * @return The stride of the block that contains the address.
+ */
+bytes_t TilerMem_GetStride(SSPtr ssptr);
+
+/**
+ * Retrieves the physical system-space address that corresponds
+ * to the virtual address.
+ *
+ * @author a0194118 (9/1/2009)
+ *
+ * @param ptr pointer to a virtual address
+ *
+ * @return The physical system-space address that the virtual
+ * address refers to. If the virtual address is invalid
+ * or unmapped, it returns 0.
+ */
+SSPtr TilerMem_VirtToPhys(void *ptr);
+
+#endif
diff --git a/tiler/tilermem_utils.h b/tiler/tilermem_utils.h
new file mode 100644
index 0000000..1d6210d
--- /dev/null
+++ b/tiler/tilermem_utils.h
@@ -0,0 +1,52 @@
+/*
+ * tilermem_utils.h
+ *
+ * Memory Allocator Interface internal definitions and functions needed for
+ * unit testing.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILERMEM_UTILS_H_
+#define _TILERMEM_UTILS_H_
+
+#include <tiler.h>
+
+#define TILER_PAGE_WIDTH 64
+#define TILER_PAGE_HEIGHT 64
+
+#define TILER_STRIDE_8BIT (TILER_WIDTH * TILER_PAGE_WIDTH)
+#define TILER_STRIDE_16BIT (TILER_WIDTH * TILER_PAGE_WIDTH * 2)
+#define TILER_STRIDE_32BIT (TILER_WIDTH * TILER_PAGE_WIDTH * 2)
+
+#define PAGE_SIZE TILER_PAGE
+
+#endif
+
diff --git a/tiler/tilermgr.c b/tiler/tilermgr.c
new file mode 100644
index 0000000..470de5c
--- /dev/null
+++ b/tiler/tilermgr.c
@@ -0,0 +1,203 @@
+/*
+ * tilermgr.c
+ *
+ * TILER library support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h> /* strerror() */
+#include <fcntl.h> /* open() */
+#include <unistd.h> /* close() */
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <tiler.h>
+#include "tilermgr.h"
+#include "mem_types.h"
+
+
+#define TILERMGR_ERROR() \
+ fprintf(stderr, "%s()::%d: errno(%d) - \"%s\"\n", \
+ __FUNCTION__, __LINE__, errno, strerror(errno)); \
+ fflush(stderr);
+
+static int fd;
+
+int TilerMgr_Close()
+{
+ close(fd);
+ return TILERMGR_ERR_NONE;
+}
+
+int TilerMgr_Open()
+{
+ fd = open(TILER_DEVICE_PATH, O_RDWR);
+ if (fd < 0) {
+ TILERMGR_ERROR();
+ return TILERMGR_ERR_GENERIC;
+ }
+
+ return TILERMGR_ERR_NONE;
+}
+
+SSPtr TilerMgr_Alloc(enum pixel_fmt_t pixfmt, pixels_t width, pixels_t height)
+{
+ int ret = -1;
+ struct tiler_block_info block = {0};
+
+ if (pixfmt < PIXEL_FMT_8BIT || pixfmt > PIXEL_FMT_32BIT)
+ return 0x0;
+ if (width <= 0 || width > TILER_WIDTH * 64)
+ return 0x0;
+ if (height <= 0 || height > TILER_HEIGHT * 64)
+ return 0x0;
+
+ block.fmt = pixfmt;
+ block.dim.area.width = width;
+ block.dim.area.height = height;
+
+ ret = ioctl(fd, TILIOC_GBLK, (unsigned long)(&block));
+ if (ret < 0) {
+ TILERMGR_ERROR();
+ return 0x0;
+ }
+ return block.ssptr;
+}
+
+int TilerMgr_Free(SSPtr addr)
+{
+ int ret = -1;
+ struct tiler_block_info block = {0};
+
+ if (addr < TILER_MEM_8BIT || addr >= TILER_MEM_PAGED)
+ return TILERMGR_ERR_GENERIC;
+
+ block.ssptr = addr;
+
+ ret = ioctl(fd, TILIOC_FBLK, (unsigned long)(&block));
+ if (ret < 0) {
+ TILERMGR_ERROR();
+ return TILERMGR_ERR_GENERIC;
+ }
+ return TILERMGR_ERR_NONE;
+}
+
+SSPtr TilerMgr_PageModeAlloc(bytes_t len)
+{
+ int ret = -1;
+ struct tiler_block_info block = {0};
+
+ if(len < 0 || len > TILER_LENGTH)
+ return 0x0;
+
+ block.fmt = TILFMT_PAGE;
+ block.dim.len = len;
+
+ ret = ioctl(fd, TILIOC_GBLK, (unsigned long)(&block));
+ if (ret < 0) {
+ TILERMGR_ERROR();
+ return 0x0;
+ }
+ return block.ssptr;
+}
+
+int TilerMgr_PageModeFree(SSPtr addr)
+{
+ int ret = -1;
+ struct tiler_block_info block = {0};
+
+ if (addr < TILER_MEM_PAGED || addr >= TILER_MEM_END)
+ return TILERMGR_ERR_GENERIC;
+
+ block.ssptr = addr;
+
+ ret = ioctl(fd, TILIOC_FBLK, (unsigned long)(&block));
+ if (ret < 0) {
+ TILERMGR_ERROR();
+ return TILERMGR_ERR_GENERIC;
+ }
+ return TILERMGR_ERR_NONE;
+}
+
+SSPtr TilerMgr_VirtToPhys(void *ptr)
+{
+ int ret = -1;
+ unsigned long tmp = 0x0;
+
+ if(ptr == NULL)
+ return 0x0;
+
+ tmp = (unsigned long)ptr;
+ ret = ioctl(fd, TILIOC_GSSP, tmp);
+
+ return (SSPtr)ret;
+}
+
+SSPtr TilerMgr_Map(void *ptr, bytes_t len)
+{
+ int ret = -1;
+ struct tiler_block_info block = {0};
+
+ if (len < 0 || len > TILER_LENGTH)
+ return 0x0;
+
+ block.fmt = TILFMT_PAGE;
+ block.dim.len = len;
+ block.ptr = ptr;
+
+ ret = ioctl(fd, TILIOC_MBLK, (unsigned long)(&block));
+ if (ret < 0) {
+ TILERMGR_ERROR();
+ return 0x0;
+ }
+ return block.ssptr;
+}
+
+int TilerMgr_Unmap(SSPtr addr)
+{
+ int ret = -1;
+ struct tiler_block_info block = {0};
+
+ if (addr < TILER_MEM_PAGED || addr >= TILER_MEM_END)
+ return TILERMGR_ERR_GENERIC;
+
+ block.ssptr = addr;
+
+ ret = ioctl(fd, TILIOC_UMBLK, (unsigned long)(&block));
+ if (ret < 0) {
+ TILERMGR_ERROR();
+ return TILERMGR_ERR_GENERIC;
+ }
+ return TILERMGR_ERR_NONE;
+}
+
diff --git a/tiler/tilermgr.h b/tiler/tilermgr.h
new file mode 100644
index 0000000..cd76822
--- /dev/null
+++ b/tiler/tilermgr.h
@@ -0,0 +1,54 @@
+/*
+ * tilermgr.h
+ *
+ * TILER library support functions for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _TILERMGR_H_
+#define _TILERMGR_H_
+
+#include "mem_types.h"
+
+#define TILERMGR_ERR_NONE (0)
+#define TILERMGR_ERR_GENERIC (-1)
+
+int TilerMgr_Open();
+int TilerMgr_Close();
+SSPtr TilerMgr_Alloc(enum pixel_fmt_t pixfmt, pixels_t width, pixels_t height);
+int TilerMgr_Free(SSPtr ssptr);
+SSPtr TilerMgr_PageModeAlloc(bytes_t length);
+int TilerMgr_PageModeFree(SSPtr ssptr);
+SSPtr TilerMgr_Map(void *ptr, bytes_t length);
+int TilerMgr_Unmap(SSPtr ssptr);
+SSPtr TilerMgr_VirtToPhys(void *ptr);
+
+#endif
diff --git a/tiler/utils.h b/tiler/utils.h
new file mode 100644
index 0000000..d194a43
--- /dev/null
+++ b/tiler/utils.h
@@ -0,0 +1,63 @@
+/*
+ * utils.h
+ *
+ * Utility definitions for the Memory Interface for TI OMAP processors.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _UTILS_H_
+#define _UTILS_H_
+
+/* ---------- Generic Macros Used in Macros ---------- */
+
+/* allocation macro */
+#define NEW(type) (type*)calloc(1, sizeof(type))
+#define NEWN(type,n) (type*)calloc(n, sizeof(type))
+#define ALLOC(var) var = calloc(1, sizeof(*var))
+#define ALLOCN(var,n) var = calloc(n, sizeof(*var))
+
+
+/* free variable and set it to NULL */
+#define FREE(var) do { free(var); var = NULL; } while(0)
+
+/* clear variable */
+#define ZERO(var) memset(&(var), 0, sizeof(var))
+
+/* binary round methods */
+#define ROUND_DOWN_TO2POW(x, N) ((x) & ~((N)-1))
+#define ROUND_UP_TO2POW(x, N) ROUND_DOWN_TO2POW((x) + (N) - 1, N)
+
+/* regulare round methods */
+#define ROUND_DOWN_TO(x, N) ((x) / (N) * (N))
+#define ROUND_UP_TO(x, N) ROUND_DOWN_TO((x) + (N) - 1, N)
+
+#endif
+
diff --git a/tiler/utils_test.c b/tiler/utils_test.c
new file mode 100644
index 0000000..c152125
--- /dev/null
+++ b/tiler/utils_test.c
@@ -0,0 +1,489 @@
+/*
+ * utils_test.c
+ *
+ * Memory Allocator Utility tests.
+ *
+ * Copyright (C) 2009-2011 Texas Instruments, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define __DEBUG__
+#define __DEBUG_ASSERT__
+#define __DEBUG_ENTRY__
+
+#include <utils.h>
+#include <list_utils.h>
+#include <debug_utils.h>
+#include "testlib.h"
+
+#define TESTS\
+ T(test_new())\
+ T(test_list())\
+ T(test_ezlist())\
+ T(test_dzlist())\
+ T(test_plist())\
+ T(test_mlist())\
+ T(test_math())
+
+#define F() in = head.next;
+#define N(a) res |= NOT_P(in,!=,&head); \
+ res |= NOT_P(in->me,!=,NULL) || NOT_I(in->me->data,==,a); in = in->next;
+#define Z(a) res |= NOT_P(in,!=,&head); \
+ res |= NOT_I(in->data,==,a); in = in->next;
+#define L() res |= NOT_P(in,==,&head);
+
+int all_zero(int *p, int len)
+{
+ IN;
+ int ix = 0;
+ for (ix = 0; ix < len; ix ++)
+ {
+ if (p[ix])
+ {
+ P("[%d]=%d\n", ix, p[ix]);
+ return R_I(1);
+ }
+ }
+ return R_I(0);
+}
+
+int test_new() {
+ IN;
+ int *p;
+ p = NEW(int);
+ int res = NOT_I(all_zero(p, 1),==,0);
+ FREE(p);
+ res |= NOT_I(p,==,NULL);
+ p = NEWN(int, 8000);
+ res |= NOT_I(all_zero(p, 8000),==,0);
+ FREE(p);
+ p = NEWN(int, 1000000);
+ res |= NOT_I(all_zero(p, 1000000),==,0);
+ FREE(p);
+ return R_I(res);
+}
+
+int test_list() {
+ IN;
+
+ struct elem {
+ int data;
+ } *elA, *elB;
+ struct list {
+ struct elem *me;
+ struct list *last, *next;
+ } head, *inA, *inB, *in, *in_safe;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ inA = NEW(struct list);
+ DLIST_ADD_AFTER(head, elA, *inA);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ inB = NEW(struct list);
+ DLIST_ADD_AFTER(*inA, elB, *inB);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ inB = NEW(struct list);
+ (DLIST_ADD_BEFORE(head, elB, *inB))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, *inB);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_LOOP(head, in, in_safe) {
+ if (in->me->data > 1)
+ {
+ DLIST_REMOVE(*in);
+ FREE(in->me);
+ FREE(in);
+ }
+ }
+ F()N(1)L();
+
+ /* delete list */
+ DLIST_SAFE_LOOP(head, in, in_safe) {
+ DLIST_REMOVE(*in);
+ FREE(in->me);
+ FREE(in);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_ezlist() {
+ IN;
+
+ struct elem {
+ int data;
+ struct elem *me, *last, *next;
+ } *elA, *elB, head, *el, *el_safe, *in;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DLIST_ADD_AFTER(head, elA, *elA);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DLIST_ADD_AFTER(*elA, elB, *elB);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ (DLIST_ADD_BEFORE(head, elB, *elB))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, *elB);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, *elB);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, *elB);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, el) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_RLOOP(head, el, el_safe) {
+ if (el->me->data == 1)
+ {
+ DLIST_REMOVE(*el);
+ FREE(el);
+ }
+ }
+ F()N(2)N(3)L();
+
+ /* delete list */
+ DLIST_SAFE_LOOP(head, el, el_safe) {
+ DLIST_REMOVE(*el);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_dzlist() {
+ IN;
+
+ struct elem {
+ int data;
+ struct elem *last, *next;
+ } *elA, *elB, head, *el, *el_safe, *in;
+
+ /* initialization */
+ DZLIST_INIT(head);
+ int res = NOT_I(DZLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DZLIST_ADD_AFTER(head, *elA);
+ F()Z(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DZLIST_ADD_AFTER(*elA, *elB);
+ F()Z(1)Z(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ (DZLIST_ADD_BEFORE(head, *elB))->data = 3;
+ F()Z(1)Z(2)Z(3)L();
+
+ /* move an element to another position or another list */
+ DZLIST_MOVE_AFTER(head, *elB);
+ F()Z(3)Z(1)Z(2)L();
+
+ DZLIST_MOVE_BEFORE(head, *elB);
+ F()Z(1)Z(2)Z(3)L();
+
+ /* works even if the position is the same */
+ DZLIST_MOVE_BEFORE(head, *elB);
+ F()Z(1)Z(2)Z(3)L();
+
+ res |= NOT_I(DZLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DZLIST_LAST(head)->data,==,3);
+
+ DZLIST_LOOP(head, el) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DZLIST_SAFE_RLOOP(head, el, el_safe) {
+ if (el->data == 1)
+ {
+ DZLIST_REMOVE(*el);
+ FREE(el);
+ }
+ }
+ F()Z(2)Z(3)L();
+
+ /* delete list */
+ DZLIST_SAFE_LOOP(head, el, el_safe) {
+ DZLIST_REMOVE(*el);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_plist() {
+ IN;
+
+ struct elem;
+ struct list {
+ struct elem *me;
+ struct list *last, *next;
+ } head, *inA, *inB, *in;
+ struct elem {
+ int data;
+ struct list *list_data;
+ } *elA, *elB, *el, *el_safe;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ inA = NEW(struct list);
+ DLIST_PADD_AFTER(head, elA, inA, list_data);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ inB = NEW(struct list);
+ DLIST_PADD_AFTER(*inA, elB, inB, list_data);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ inB = NEW(struct list);
+ (DLIST_PADD_BEFORE(head, elB, inB, list_data))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, *inB);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, *inB);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ P(".");
+ DLIST_PLOOP(head, el, list_data) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_PLOOP(head, el, el_safe, list_data) {
+ if (el->data == 2)
+ {
+ DLIST_REMOVE(*el->list_data);
+ FREE(el->list_data);
+ FREE(el);
+ }
+ }
+ F()N(1)N(3)L();
+
+ /* delete list */
+ DLIST_SAFE_PLOOP(head, el, el_safe, list_data) {
+ DLIST_REMOVE(*el->list_data);
+ FREE(el->list_data);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_mlist() {
+ IN;
+
+ struct elem {
+ int data;
+ struct list {
+ struct list *last, *next;
+ struct elem *me;
+ } list_data;
+ } *elA, *elB, *el, *el_safe;
+ struct list head, *in;
+
+ /* initialization */
+ DLIST_INIT(head);
+ int res = NOT_I(DLIST_IS_EMPTY(head),!=,0);
+
+ /* add element at beginning of list */
+ elA = NEW(struct elem);
+ elA->data = 1;
+ DLIST_MADD_AFTER(head, elA, list_data);
+ F()N(1)L();
+
+ /* add element after an element */
+ elB = NEW(struct elem);
+ elB->data = 2;
+ DLIST_MADD_AFTER(elA->list_data, elB, list_data);
+ F()N(1)N(2)L();
+
+ /* add element at the end of the list */
+ elB = NEW(struct elem);
+ (DLIST_MADD_BEFORE(head, elB, list_data))->data = 3;
+ F()N(1)N(2)N(3)L();
+
+ /* move an element to another position or another list */
+ DLIST_MOVE_AFTER(head, elB->list_data);
+ F()N(3)N(1)N(2)L();
+
+ DLIST_MOVE_BEFORE(head, elB->list_data);
+ F()N(1)N(2)N(3)L();
+
+ /* works even if the position is the same */
+ DLIST_MOVE_BEFORE(head, elB->list_data);
+ F()N(1)N(2)N(3)L();
+
+ res |= NOT_I(DLIST_FIRST(head)->data,==,1);
+ res |= NOT_I(DLIST_LAST(head)->data,==,3);
+
+ DLIST_LOOP(head, in) {
+ P("%d", in->me->data);
+ }
+ P(".");
+ DLIST_MLOOP(head, el, list_data) {
+ P("%d", el->data);
+ }
+ P(".");
+
+ /* remove elements */
+ DLIST_SAFE_MLOOP(head, el, el_safe, list_data) {
+ if (el->data != 2)
+ {
+ DLIST_REMOVE(el->list_data);
+ FREE(el);
+ }
+ }
+ F()N(2)L();
+
+ /* delete list */
+ DLIST_SAFE_MLOOP(head, el, el_safe, list_data) {
+ DLIST_REMOVE(el->list_data);
+ FREE(el);
+ }
+ F()L();
+
+ return R_I(res);
+}
+
+int test_math()
+{
+ IN;
+ int res = 0;
+ res |= NOT_I(ROUND_UP_TO2POW(0, 4096),==,0);
+ res |= NOT_I(ROUND_UP_TO2POW(1, 4096),==,4096);
+ res |= NOT_I(ROUND_UP_TO2POW(4095, 4096),==,4096);
+ res |= NOT_I(ROUND_UP_TO2POW(4096, 4096),==,4096);
+ res |= NOT_I(ROUND_UP_TO2POW(4097, 4096),==,8192);
+ res |= NOT_I(ROUND_DOWN_TO2POW(0, 4096),==,0);
+ res |= NOT_I(ROUND_DOWN_TO2POW(1, 4096),==,0);
+ res |= NOT_I(ROUND_DOWN_TO2POW(4095, 4096),==,0);
+ res |= NOT_I(ROUND_DOWN_TO2POW(4096, 4096),==,4096);
+ res |= NOT_I(ROUND_DOWN_TO2POW(4097, 4096),==,4096);
+ return R_I(res);
+}
+
+DEFINE_TESTS(TESTS)
+
+int main(int argc, char **argv)
+{
+ return TestLib_Run(argc, argv, nullfn, nullfn, NULL);
+}
+
generated by cgit v1.1 at 2025-01-25 05:43:20 +0000